Merge "JNI: Fix crash in btgattc_scan_result_cb" into tm-qpr-dev (0b1c633f) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_gatt.cpp

+71 −2

Original line number	Diff line number	Diff line
		@@ -199,6 +199,7 @@ static std::shared_mutex callbacks_mutex;
		*/

		void btgattc_register_app_cb(int status, int clientIf, const Uuid& app_uuid) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientRegistered, status,
		@@ -212,6 +213,7 @@ void btgattc_scan_result_cb(uint16_t event_type, uint8_t addr_type,
		uint16_t periodic_adv_int,
		std::vector<uint8_t> adv_data,
		RawAddress* original_bda) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -233,6 +235,7 @@ void btgattc_scan_result_cb(uint16_t event_type, uint8_t addr_type,

		void btgattc_open_cb(int conn_id, int status, int clientIf,
		const RawAddress& bda) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -244,6 +247,7 @@ void btgattc_open_cb(int conn_id, int status, int clientIf,

		void btgattc_close_cb(int conn_id, int status, int clientIf,
		const RawAddress& bda) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -254,6 +258,7 @@ void btgattc_close_cb(int conn_id, int status, int clientIf,
		}

		void btgattc_search_complete_cb(int conn_id, int status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -263,6 +268,7 @@ void btgattc_search_complete_cb(int conn_id, int status) {

		void btgattc_register_for_notification_cb(int conn_id, int registered,
		int status, uint16_t handle) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -271,6 +277,7 @@ void btgattc_register_for_notification_cb(int conn_id, int registered,
		}

		void btgattc_notify_cb(int conn_id, const btgatt_notify_params_t& p_data) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -288,6 +295,7 @@ void btgattc_notify_cb(int conn_id, const btgatt_notify_params_t& p_data) {

		void btgattc_read_characteristic_cb(int conn_id, int status,
		btgatt_read_params_t* p_data) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -308,6 +316,7 @@ void btgattc_read_characteristic_cb(int conn_id, int status,

		void btgattc_write_characteristic_cb(int conn_id, int status, uint16_t handle,
		uint16_t len, const uint8_t* value) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -319,6 +328,7 @@ void btgattc_write_characteristic_cb(int conn_id, int status, uint16_t handle,
		}

		void btgattc_execute_write_cb(int conn_id, int status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -328,6 +338,7 @@ void btgattc_execute_write_cb(int conn_id, int status) {

		void btgattc_read_descriptor_cb(int conn_id, int status,
		const btgatt_read_params_t& p_data) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -346,6 +357,7 @@ void btgattc_read_descriptor_cb(int conn_id, int status,

		void btgattc_write_descriptor_cb(int conn_id, int status, uint16_t handle,
		uint16_t len, const uint8_t* value) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -358,6 +370,7 @@ void btgattc_write_descriptor_cb(int conn_id, int status, uint16_t handle,

		void btgattc_remote_rssi_cb(int client_if, const RawAddress& bda, int rssi,
		int status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -369,6 +382,7 @@ void btgattc_remote_rssi_cb(int client_if, const RawAddress& bda, int rssi,
		}

		void btgattc_configure_mtu_cb(int conn_id, int status, int mtu) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConfigureMTU, conn_id,
		@@ -376,6 +390,7 @@ void btgattc_configure_mtu_cb(int conn_id, int status, int mtu) {
		}

		void btgattc_congestion_cb(int conn_id, bool congested) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientCongestion,
		@@ -384,6 +399,7 @@ void btgattc_congestion_cb(int conn_id, bool congested) {

		void btgattc_batchscan_reports_cb(int client_if, int status, int report_format,
		int num_records, std::vector<uint8_t> data) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(),
		@@ -396,6 +412,7 @@ void btgattc_batchscan_reports_cb(int client_if, int status, int report_format,
		}

		void btgattc_batchscan_threshold_cb(int client_if) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj,
		@@ -403,6 +420,7 @@ void btgattc_batchscan_threshold_cb(int client_if) {
		}

		void btgattc_track_adv_event_cb(btgatt_track_adv_info_t* p_adv_track_info) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -506,6 +524,7 @@ void fillGattDbElementArray(JNIEnv* env, jobject* array,

		void btgattc_get_gatt_db_cb(int conn_id, const btgatt_db_element_t* db,
		int count) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -525,6 +544,7 @@ void btgattc_get_gatt_db_cb(int conn_id, const btgatt_db_element_t* db,

		void btgattc_phy_updated_cb(int conn_id, uint8_t tx_phy, uint8_t rx_phy,
		uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -534,6 +554,7 @@ void btgattc_phy_updated_cb(int conn_id, uint8_t tx_phy, uint8_t rx_phy,

		void btgattc_conn_updated_cb(int conn_id, uint16_t interval, uint16_t latency,
		uint16_t timeout, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -542,6 +563,7 @@ void btgattc_conn_updated_cb(int conn_id, uint16_t interval, uint16_t latency,
		}

		void btgattc_service_changed_cb(int conn_id) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -583,6 +605,7 @@ static const btgatt_client_callbacks_t sGattClientCallbacks = {
		*/

		void btgatts_register_app_cb(int status, int server_if, const Uuid& uuid) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerRegistered, status,
		@@ -591,6 +614,7 @@ void btgatts_register_app_cb(int status, int server_if, const Uuid& uuid) {

		void btgatts_connection_cb(int conn_id, int server_if, int connected,
		const RawAddress& bda) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -603,6 +627,7 @@ void btgatts_connection_cb(int conn_id, int server_if, int connected,
		void btgatts_service_added_cb(int status, int server_if,
		const btgatt_db_element_t* service,
		size_t service_count) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -620,6 +645,7 @@ void btgatts_service_added_cb(int status, int server_if,
		}

		void btgatts_service_stopped_cb(int status, int server_if, int srvc_handle) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceStopped, status,
		@@ -627,6 +653,7 @@ void btgatts_service_stopped_cb(int status, int server_if, int srvc_handle) {
		}

		void btgatts_service_deleted_cb(int status, int server_if, int srvc_handle) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceDeleted, status,
		@@ -637,6 +664,7 @@ void btgatts_request_read_characteristic_cb(int conn_id, int trans_id,
		const RawAddress& bda,
		int attr_handle, int offset,
		bool is_long) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -650,6 +678,7 @@ void btgatts_request_read_characteristic_cb(int conn_id, int trans_id,
		void btgatts_request_read_descriptor_cb(int conn_id, int trans_id,
		const RawAddress& bda, int attr_handle,
		int offset, bool is_long) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -666,6 +695,7 @@ void btgatts_request_write_characteristic_cb(int conn_id, int trans_id,
		bool need_rsp, bool is_prep,
		const uint8_t* value,
		size_t length) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -685,6 +715,7 @@ void btgatts_request_write_descriptor_cb(int conn_id, int trans_id,
		int offset, bool need_rsp,
		bool is_prep, const uint8_t* value,
		size_t length) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -701,6 +732,7 @@ void btgatts_request_write_descriptor_cb(int conn_id, int trans_id,

		void btgatts_request_exec_write_cb(int conn_id, int trans_id,
		const RawAddress& bda, int exec_write) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -711,6 +743,7 @@ void btgatts_request_exec_write_cb(int conn_id, int trans_id,
		}

		void btgatts_response_confirmation_cb(int status, int handle) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onResponseSendCompleted,
		@@ -718,6 +751,7 @@ void btgatts_response_confirmation_cb(int status, int handle) {
		}

		void btgatts_indication_sent_cb(int conn_id, int status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNotificationSent,
		@@ -725,6 +759,7 @@ void btgatts_indication_sent_cb(int conn_id, int status) {
		}

		void btgatts_congestion_cb(int conn_id, bool congested) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerCongestion,
		@@ -732,6 +767,7 @@ void btgatts_congestion_cb(int conn_id, bool congested) {
		}

		void btgatts_mtu_changed_cb(int conn_id, int mtu) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerMtuChanged,
		@@ -740,6 +776,7 @@ void btgatts_mtu_changed_cb(int conn_id, int mtu) {

		void btgatts_phy_updated_cb(int conn_id, uint8_t tx_phy, uint8_t rx_phy,
		uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -749,6 +786,7 @@ void btgatts_phy_updated_cb(int conn_id, uint8_t tx_phy, uint8_t rx_phy,

		void btgatts_conn_updated_cb(int conn_id, uint16_t interval, uint16_t latency,
		uint16_t timeout, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -890,6 +928,7 @@ class JniScanningCallbacks : ScanningCallbacks {

		void OnScannerRegistered(const Uuid app_uuid, uint8_t scannerId,
		uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScannerRegistered,
		@@ -897,6 +936,7 @@ class JniScanningCallbacks : ScanningCallbacks {
		}

		void OnSetScannerParameterComplete(uint8_t scannerId, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(
		@@ -907,6 +947,7 @@ class JniScanningCallbacks : ScanningCallbacks {
		uint8_t primary_phy, uint8_t secondary_phy,
		uint8_t advertising_sid, int8_t tx_power, int8_t rssi,
		uint16_t periodic_adv_int, std::vector<uint8_t> adv_data) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -932,6 +973,7 @@ class JniScanningCallbacks : ScanningCallbacks {
		}

		void OnTrackAdvFoundLost(AdvertisingTrackInfo track_info) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -973,6 +1015,7 @@ class JniScanningCallbacks : ScanningCallbacks {

		void OnBatchScanReports(int client_if, int status, int report_format,
		int num_records, std::vector<uint8_t> data) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(),
		@@ -986,6 +1029,7 @@ class JniScanningCallbacks : ScanningCallbacks {
		}

		void OnBatchScanThresholdCrossed(int client_if) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj,
		@@ -996,6 +1040,7 @@ class JniScanningCallbacks : ScanningCallbacks {
		uint8_t sid, uint8_t address_type,
		RawAddress address, uint8_t phy,
		uint16_t interval) override {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		if (!mPeriodicScanCallbacksObj) {
		@@ -1013,6 +1058,7 @@ class JniScanningCallbacks : ScanningCallbacks {
		void OnPeriodicSyncReport(uint16_t sync_handle, int8_t tx_power, int8_t rssi,
		uint8_t data_status,
		std::vector<uint8_t> data) override {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -1027,6 +1073,7 @@ class JniScanningCallbacks : ScanningCallbacks {
		}

		void OnPeriodicSyncLost(uint16_t sync_handle) override {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -1036,6 +1083,7 @@ class JniScanningCallbacks : ScanningCallbacks {

		void OnPeriodicSyncTransferred(int pa_source, uint8_t status,
		RawAddress address) override {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		if (!mPeriodicScanCallbacksObj) {
		@@ -1168,6 +1216,7 @@ static void classInitNative(JNIEnv* env, jclass clazz) {
		static const bt_interface_t* btIf;

		static void initializeNative(JNIEnv* env, jobject object) {
		std::unique_lock<std::shared_mutex> lock(callbacks_mutex);
		if (btIf) return;

		btIf = getBluetoothInterface();
		@@ -1210,6 +1259,8 @@ static void initializeNative(JNIEnv* env, jobject object) {
		}

		static void cleanupNative(JNIEnv* env, jobject object) {
		std::unique_lock<std::shared_mutex> lock(callbacks_mutex);

		if (!btIf) return;

		if (sGattIf != NULL) {
		@@ -1250,6 +1301,7 @@ static void gattClientUnregisterAppNative(JNIEnv* env, jobject object,

		void btgattc_register_scanner_cb(const Uuid& app_uuid, uint8_t scannerId,
		uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScannerRegistered,
		@@ -1305,6 +1357,7 @@ static void gattClientSetPreferredPhyNative(JNIEnv* env, jobject object,

		static void readClientPhyCb(uint8_t clientIf, RawAddress bda, uint8_t tx_phy,
		uint8_t rx_phy, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -1451,6 +1504,7 @@ static void gattClientReadRemoteRssiNative(JNIEnv* env, jobject object,
		}

		void set_scan_params_cmpl_cb(int client_if, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScanParamSetupCompleted,
		@@ -1468,6 +1522,7 @@ static void gattSetScanParametersNative(JNIEnv* env, jobject object,

		void scan_filter_param_cb(uint8_t client_if, uint8_t avbl_space, uint8_t action,
		uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj,
		@@ -1547,6 +1602,7 @@ static void gattClientScanFilterParamClearAllNative(JNIEnv* env, jobject object,
		static void scan_filter_cfg_cb(uint8_t client_if, uint8_t filt_type,
		uint8_t avbl_space, uint8_t action,
		uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScanFilterConfig, action,
		@@ -1697,6 +1753,7 @@ static void gattClientScanFilterClearNative(JNIEnv* env, jobject object,
		}

		void scan_enable_cb(uint8_t client_if, uint8_t action, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScanFilterEnableDisabled,
		@@ -1729,6 +1786,7 @@ static void gattConnectionParameterUpdateNative(JNIEnv* env, jobject object,
		}

		void batchscan_cfg_storage_cb(uint8_t client_if, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(
		@@ -1746,6 +1804,7 @@ static void gattClientConfigBatchScanStorageNative(
		}

		void batchscan_enable_cb(uint8_t client_if, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onBatchScanStartStopped,
		@@ -1820,6 +1879,7 @@ static void gattServerSetPreferredPhyNative(JNIEnv* env, jobject object,

		static void readServerPhyCb(uint8_t serverIf, RawAddress bda, uint8_t tx_phy,
		uint8_t rx_phy, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -2000,7 +2060,7 @@ static void advertiseClassInitNative(JNIEnv* env, jclass clazz) {
		}

		static void advertiseInitializeNative(JNIEnv* env, jobject object) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		std::unique_lock<std::shared_mutex> lock(callbacks_mutex);
		if (mAdvertiseCallbacksObj != NULL) {
		ALOGW("Cleaning up Advertise callback object");
		env->DeleteGlobalRef(mAdvertiseCallbacksObj);
		@@ -2011,7 +2071,7 @@ static void advertiseInitializeNative(JNIEnv* env, jobject object) {
		}

		static void advertiseCleanupNative(JNIEnv* env, jobject object) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		std::unique_lock<std::shared_mutex> lock(callbacks_mutex);
		if (mAdvertiseCallbacksObj != NULL) {
		env->DeleteGlobalRef(mAdvertiseCallbacksObj);
		mAdvertiseCallbacksObj = NULL;
		@@ -2100,6 +2160,7 @@ static PeriodicAdvertisingParameters parsePeriodicParams(JNIEnv* env,

		static void ble_advertising_set_started_cb(int reg_id, uint8_t advertiser_id,
		int8_t tx_power, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
		@@ -2109,6 +2170,7 @@ static void ble_advertising_set_started_cb(int reg_id, uint8_t advertiser_id,

		static void ble_advertising_set_timeout_cb(uint8_t advertiser_id,
		uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
		@@ -2160,6 +2222,7 @@ static void stopAdvertisingSetNative(JNIEnv* env, jobject object,

		static void getOwnAddressCb(uint8_t advertiser_id, uint8_t address_type,
		RawAddress address) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;

		@@ -2178,6 +2241,7 @@ static void getOwnAddressNative(JNIEnv* env, jobject object,

		static void callJniCallback(jmethodID method, uint8_t advertiser_id,
		uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method, advertiser_id,
		@@ -2185,6 +2249,7 @@ static void callJniCallback(jmethodID method, uint8_t advertiser_id,
		}

		static void enableSetCb(uint8_t advertiser_id, bool enable, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
		@@ -2224,6 +2289,7 @@ static void setScanResponseDataNative(JNIEnv* env, jobject object,

		static void setAdvertisingParametersNativeCb(uint8_t advertiser_id,
		uint8_t status, int8_t tx_power) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
		@@ -2268,6 +2334,7 @@ static void setPeriodicAdvertisingDataNative(JNIEnv* env, jobject object,

		static void enablePeriodicSetCb(uint8_t advertiser_id, bool enable,
		uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid()) return;
		sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
		@@ -2295,6 +2362,7 @@ static void periodicScanClassInitNative(JNIEnv* env, jclass clazz) {
		}

		static void periodicScanInitializeNative(JNIEnv* env, jobject object) {
		std::unique_lock<std::shared_mutex> lock(callbacks_mutex);
		if (mPeriodicScanCallbacksObj != NULL) {
		ALOGW("Cleaning up periodic scan callback object");
		env->DeleteGlobalRef(mPeriodicScanCallbacksObj);
		@@ -2305,6 +2373,7 @@ static void periodicScanInitializeNative(JNIEnv* env, jobject object) {
		}

		static void periodicScanCleanupNative(JNIEnv* env, jobject object) {
		std::unique_lock<std::shared_mutex> lock(callbacks_mutex);
		if (mPeriodicScanCallbacksObj != NULL) {
		env->DeleteGlobalRef(mPeriodicScanCallbacksObj);
		mPeriodicScanCallbacksObj = NULL;