Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d904b453 authored by Jakub Pawlowski's avatar Jakub Pawlowski Committed by Jakub Pawłowski
Browse files

JNI: check if callback object is null before invoking it 

Bug: 247492602
Bug: 257929630
Test: stress test on/off
Change-Id: Ibbb382404875e61bf24d86e00294c6b470152126
parent a80d0f65

android/app/jni/com_android_bluetooth_gatt.cpp

+62 −62
Original line number Diff line number Diff line
@@ -201,7 +201,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientRegistered, status,

                               clientIf, UUID_PARAMS(app_uuid));

}
@@ -215,7 +215,7 @@ void btgattc_scan_result_cb(uint16_t event_type, uint8_t addr_type, 
                            RawAddress* original_bda) {

  std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), bda));
@@ -237,7 +237,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -249,7 +249,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -260,7 +260,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onSearchCompleted, conn_id,

                               status);
@@ -270,7 +270,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onRegisterForNotifications,

                               conn_id, status, registered, handle);
@@ -279,7 +279,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(

      sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &p_data.bda));
@@ -297,7 +297,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(), NULL);

  if (status == 0) {  // Success
@@ -318,7 +318,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(), NULL);

  jb.reset(sCallbackEnv->NewByteArray(len));
@@ -330,7 +330,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExecuteCompleted,

                               conn_id, status);
@@ -340,7 +340,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(), NULL);

  if (p_data.value.len != 0) {
@@ -359,7 +359,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(), NULL);

  jb.reset(sCallbackEnv->NewByteArray(len));
@@ -372,7 +372,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -384,7 +384,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConfigureMTU, conn_id,

                               status, mtu);

}
@@ -392,7 +392,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientCongestion,

                               conn_id, congested);

}
@@ -401,7 +401,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(),

                                sCallbackEnv->NewByteArray(data.size()));

  sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(),
@@ -414,7 +414,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj,

                               method_onBatchScanThresholdCrossed, client_if);

}
@@ -422,7 +422,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(

      sCallbackEnv.get(),
@@ -526,7 +526,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  jclass arrayListclazz = sCallbackEnv->FindClass("java/util/ArrayList");

  ScopedLocalRef<jobject> array(
@@ -546,7 +546,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientPhyUpdate, conn_id,

                               tx_phy, rx_phy, status);
@@ -556,7 +556,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientConnUpdate,

                               conn_id, interval, latency, timeout, status);
@@ -565,7 +565,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceChanged, conn_id);

}
@@ -607,7 +607,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerRegistered, status,

                               server_if, UUID_PARAMS(uuid));

}
@@ -616,7 +616,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -629,7 +629,7 @@ void btgatts_service_added_cb(int status, int server_if, 
                              size_t service_count) {

  std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  jclass arrayListclazz = sCallbackEnv->FindClass("java/util/ArrayList");

  ScopedLocalRef<jobject> array(
@@ -647,7 +647,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceStopped, status,

                               server_if, srvc_handle);

}
@@ -655,7 +655,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceDeleted, status,

                               server_if, srvc_handle);

}
@@ -666,7 +666,7 @@ void btgatts_request_read_characteristic_cb(int conn_id, int trans_id, 
                                            bool is_long) {

  std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -680,7 +680,7 @@ void btgatts_request_read_descriptor_cb(int conn_id, int trans_id, 
                                        int offset, bool is_long) {

  std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -697,7 +697,7 @@ void btgatts_request_write_characteristic_cb(int conn_id, int trans_id, 
                                             size_t length) {

  std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -717,7 +717,7 @@ void btgatts_request_write_descriptor_cb(int conn_id, int trans_id, 
                                         size_t length) {

  std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -734,7 +734,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -745,7 +745,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onResponseSendCompleted,

                               status, handle);

}
@@ -753,7 +753,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNotificationSent,

                               conn_id, status);

}
@@ -761,7 +761,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerCongestion,

                               conn_id, congested);

}
@@ -769,7 +769,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerMtuChanged,

                               conn_id, mtu);

}
@@ -778,7 +778,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerPhyUpdate, conn_id,

                               tx_phy, rx_phy, status);
@@ -788,7 +788,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerConnUpdate,

                               conn_id, interval, latency, timeout, status);
@@ -930,7 +930,7 @@ class JniScanningCallbacks : ScanningCallbacks { 
                           uint8_t status) {

    std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid()) return;

    if (!sCallbackEnv.valid() || !mCallbacksObj) return;

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScannerRegistered,

                                 status, scannerId, UUID_PARAMS(app_uuid));

  }
@@ -938,7 +938,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;

    if (!sCallbackEnv.valid() || !mCallbacksObj) return;

    sCallbackEnv->CallVoidMethod(

        mCallbacksObj, method_onScanParamSetupCompleted, status, scannerId);

  }
@@ -949,7 +949,7 @@ class JniScanningCallbacks : ScanningCallbacks { 
                    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;

    if (!sCallbackEnv.valid() || !mCallbacksObj) return;



    ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                    bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -975,7 +975,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;

    if (!sCallbackEnv.valid() || !mCallbacksObj) return;



    ScopedLocalRef<jstring> address(

        sCallbackEnv.get(),
@@ -1017,7 +1017,7 @@ class JniScanningCallbacks : ScanningCallbacks { 
                          int num_records, std::vector<uint8_t> data) {

    std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid()) return;

    if (!sCallbackEnv.valid() || !mCallbacksObj) return;

    ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(),

                                  sCallbackEnv->NewByteArray(data.size()));

    sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(),
@@ -1031,7 +1031,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;

    if (!sCallbackEnv.valid() || !mCallbacksObj) return;

    sCallbackEnv->CallVoidMethod(mCallbacksObj,

                                 method_onBatchScanThresholdCrossed, client_if);

  }
@@ -1060,7 +1060,7 @@ class JniScanningCallbacks : ScanningCallbacks { 
                            std::vector<uint8_t> data) override {

    std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid()) return;

    if (!sCallbackEnv.valid() || !mPeriodicScanCallbacksObj) return;



    ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(),

                                  sCallbackEnv->NewByteArray(data.size()));
@@ -1075,7 +1075,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;

    if (!sCallbackEnv.valid() || !mPeriodicScanCallbacksObj) return;



    sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncLost,

                                 sync_handle);
@@ -1303,7 +1303,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScannerRegistered,

                               status, scannerId, UUID_PARAMS(app_uuid));

}
@@ -1359,7 +1359,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -1506,7 +1506,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScanParamSetupCompleted,

                               status, client_if);

}
@@ -1524,7 +1524,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj,

                               method_onScanFilterParamsConfigured, action,

                               status, client_if, avbl_space);
@@ -1604,7 +1604,7 @@ static void scan_filter_cfg_cb(uint8_t client_if, uint8_t filt_type, 
                               uint8_t status) {

  std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScanFilterConfig, action,

                               status, client_if, filt_type, avbl_space);

}
@@ -1755,7 +1755,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScanFilterEnableDisabled,

                               action, status, client_if);

}
@@ -1788,7 +1788,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(

      mCallbacksObj, method_onBatchScanStorageConfigured, status, client_if);

}
@@ -1806,7 +1806,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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onBatchScanStartStopped,

                               0 /* unused */, status, client_if);

}
@@ -1881,7 +1881,7 @@ 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;

  if (!sCallbackEnv.valid() || !mCallbacksObj) return;



  ScopedLocalRef<jstring> address(sCallbackEnv.get(),

                                  bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -2162,7 +2162,7 @@ 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;

  if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,

                               method_onAdvertisingSetStarted, reg_id,

                               advertiser_id, tx_power, status);
@@ -2172,7 +2172,7 @@ 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;

  if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,

                               method_onAdvertisingEnabled, advertiser_id,

                               false, status);
@@ -2224,7 +2224,7 @@ 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;

  if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) return;



  ScopedLocalRef<jstring> addr(sCallbackEnv.get(),

                               bdaddr2newjstr(sCallbackEnv.get(), &address));
@@ -2243,7 +2243,7 @@ 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;

  if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method, advertiser_id,

                               status);

}
@@ -2251,7 +2251,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;

  if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,

                               method_onAdvertisingEnabled, advertiser_id,

                               enable, status);
@@ -2291,7 +2291,7 @@ 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;

  if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,

                               method_onAdvertisingParametersUpdated,

                               advertiser_id, tx_power, status);
@@ -2336,7 +2336,7 @@ 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;

  if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) return;

  sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,

                               method_onPeriodicAdvertisingEnabled,

                               advertiser_id, enable, status);