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

Commit 16f56d03 authored by Jack He's avatar Jack He Committed by Automerger Merge Worker
Browse files

PAST: Unify callback format to match GD am: d45bf09f am: 648f0f7a 

Original change: https://googleplex-android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/18281443



Change-Id: Ic815a495ae8eb55db579ad17cbbe9f5abbc4bc55
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents f90ce1da 648f0f7a

android/app/jni/com_android_bluetooth_gatt.cpp

+62 −63
Original line number Diff line number Diff line
@@ -992,6 +992,64 @@ class JniScanningCallbacks : ScanningCallbacks { 
    sCallbackEnv->CallVoidMethod(mCallbacksObj,

                                 method_onBatchScanThresholdCrossed, client_if);

  }



  void OnPeriodicSyncStarted(int reg_id, uint8_t status, uint16_t sync_handle,

                             uint8_t sid, uint8_t address_type,

                             RawAddress address, uint8_t phy,

                             uint16_t interval) override {

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid()) return;

    if (!mPeriodicScanCallbacksObj) {

      ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");

      return;

    }

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

                                 bdaddr2newjstr(sCallbackEnv.get(), &address));



    sCallbackEnv->CallVoidMethod(

        mPeriodicScanCallbacksObj, method_onSyncStarted, reg_id, sync_handle,

        sid, address_type, addr.get(), phy, interval, status);

  }



  void OnPeriodicSyncReport(uint16_t sync_handle, int8_t tx_power, int8_t rssi,

                            uint8_t data_status,

                            std::vector<uint8_t> data) override {

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid()) return;



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

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

    sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(),

                                     (jbyte*)data.data());



    sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncReport,

                                 sync_handle, tx_power, rssi, data_status,

                                 jb.get());

  }



  void OnPeriodicSyncLost(uint16_t sync_handle) override {

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid()) return;



    sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncLost,

                                 sync_handle);

  }



  void OnPeriodicSyncTransferred(int pa_source, uint8_t status,

                                 RawAddress address) override {

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid()) return;

    if (!mPeriodicScanCallbacksObj) {

      ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");

      return;

    }

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

                                 bdaddr2newjstr(sCallbackEnv.get(), &address));



    sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj,

                                 method_onSyncTransferredCallback, pa_source,

                                 status, addr.get());

  }

};



/**
@@ -2249,54 +2307,12 @@ static void periodicScanCleanupNative(JNIEnv* env, jobject object) { 
  }

}



static void onSyncStarted(int reg_id, uint8_t status, uint16_t sync_handle,

                          uint8_t sid, uint8_t address_type, RawAddress address,

                          uint8_t phy, uint16_t interval) {

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;

  if (!mPeriodicScanCallbacksObj) {

    ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");

    return;

  }

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

                               bdaddr2newjstr(sCallbackEnv.get(), &address));



  sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncStarted,

                               reg_id, sync_handle, sid, address_type,

                               addr.get(), phy, interval, status);

}



static void onSyncReport(uint16_t sync_handle, int8_t tx_power, int8_t rssi,

                         uint8_t data_status, std::vector<uint8_t> data) {

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;



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

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

  sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(),

                                   (jbyte*)data.data());



  sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncReport,

                               sync_handle, tx_power, rssi, data_status,

                               jb.get());

}



static void onSyncLost(uint16_t sync_handle) {

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;



  sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncLost,

                               sync_handle);

}



static void startSyncNative(JNIEnv* env, jobject object, jint sid,

                            jstring address, jint skip, jint timeout,

                            jint reg_id) {

  if (!sGattIf) return;

  sGattIf->scanner->StartSync(sid, str2addr(env, address), skip, timeout,

                              base::Bind(&onSyncStarted, reg_id),

                              base::Bind(&onSyncReport),

                              base::Bind(&onSyncLost));

                              reg_id);

}



static void stopSyncNative(JNIEnv* env, jobject object, jint sync_handle) {
@@ -2310,37 +2326,20 @@ static void cancelSyncNative(JNIEnv* env, jobject object, jint sid, 
  sGattIf->scanner->CancelCreateSync(sid, str2addr(env, address));

}



static void onSyncTransferredCb(int pa_source, uint8_t status,

                                RawAddress address) {

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid()) return;

  if (!mPeriodicScanCallbacksObj) {

    ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");

    return;

  }

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

                               bdaddr2newjstr(sCallbackEnv.get(), &address));



  sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj,

                               method_onSyncTransferredCallback, pa_source,

                               status, addr.get());

}



static void syncTransferNative(JNIEnv* env, jobject object, jint pa_source,

                               jstring addr, jint service_data,

                               jint sync_handle) {

  if (!sGattIf) return;

  sGattIf->scanner->TransferSync(str2addr(env, addr), service_data, sync_handle,

                                 base::Bind(&onSyncTransferredCb, pa_source));

                                 pa_source);

}



static void transferSetInfoNative(JNIEnv* env, jobject object, jint pa_source,

                                  jstring addr, jint service_data,

                                  jint adv_handle) {

  if (!sGattIf) return;

  sGattIf->scanner->TransferSetInfo(

      str2addr(env, addr), service_data, adv_handle,

      base::Bind(&onSyncTransferredCb, pa_source));

  sGattIf->scanner->TransferSetInfo(str2addr(env, addr), service_data,

                                    adv_handle, pa_source);

}



static void gattTestNative(JNIEnv* env, jobject object, jint command,

system/btif/src/btif_ble_scanner.cc

+40 −18
Original line number Diff line number Diff line
@@ -335,19 +335,26 @@ class BleScannerInterfaceImpl : public BleScannerInterface { 
  }



  void StartSync(uint8_t sid, RawAddress address, uint16_t skip,

                 uint16_t timeout, StartSyncCb start_cb, SyncReportCb report_cb,

                 SyncLostCb lost_cb) override {

                 uint16_t timeout, int reg_id) override {

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      uint8_t status_no_resource = 2;

      start_cb.Run(status_no_resource, -1, sid, 1, address, 0, 0);

    }

      callbacks_->OnPeriodicSyncStarted(reg_id, status_no_resource, -1, sid, 1,

                                        address, 0, 0);

    }

    StartSyncCb start_sync_cb =

        base::Bind(&ScanningCallbacks::OnPeriodicSyncStarted,

                   base::Unretained(callbacks_), reg_id);

    SyncReportCb sync_report_cb = base::Bind(

        &ScanningCallbacks::OnPeriodicSyncReport, base::Unretained(callbacks_));

    SyncLostCb sync_lost_cb = base::Bind(&ScanningCallbacks::OnPeriodicSyncLost,

                                         base::Unretained(callbacks_));

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BleStartPeriodicSync, sid, address, skip, timeout,

                   jni_thread_wrapper(FROM_HERE, std::move(start_cb)),

                   jni_thread_wrapper(FROM_HERE, std::move(report_cb)),

                   jni_thread_wrapper(FROM_HERE, std::move(lost_cb))));

                   jni_thread_wrapper(FROM_HERE, std::move(start_sync_cb)),

                   jni_thread_wrapper(FROM_HERE, std::move(sync_report_cb)),

                   jni_thread_wrapper(FROM_HERE, std::move(sync_lost_cb))));

  }



  void StopSync(uint16_t handle) override {
@@ -359,8 +366,8 @@ class BleScannerInterfaceImpl : public BleScannerInterface { 
    do_in_main_thread(FROM_HERE, base::Bind(&BTM_BleStopPeriodicSync, handle));

  }



  void RegisterCallbacks(ScanningCallbacks* callbacks) {

    // For GD only

  void RegisterCallbacks(ScanningCallbacks* callbacks) override {

    callbacks_ = callbacks;

  }



  void CancelCreateSync(uint8_t sid, RawAddress address) override {
@@ -373,50 +380,65 @@ class BleScannerInterfaceImpl : public BleScannerInterface { 
  }



  void TransferSync(RawAddress address, uint16_t service_data,

                    uint16_t sync_handle, SyncTransferCb cb) override {

                    uint16_t sync_handle, int pa_source) override {

    LOG_DEBUG("address:%s", address.ToString().c_str());

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      uint8_t status_no_resource = 2;

      LOG_ERROR("PAST not supported by controller");

      cb.Run(status_no_resource, address);

      callbacks_->OnPeriodicSyncTransferred(pa_source, status_no_resource,

                                            address);

    }

    SyncTransferCb sync_transfer_cb =

        base::Bind(&ScanningCallbacks::OnPeriodicSyncTransferred,

                   base::Unretained(callbacks_), pa_source);

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BlePeriodicSyncTransfer, address, service_data,

                   sync_handle, jni_thread_wrapper(FROM_HERE, std::move(cb))));

                   sync_handle,

                   jni_thread_wrapper(FROM_HERE, std::move(sync_transfer_cb))));

  }



  void TransferSetInfo(RawAddress address, uint16_t service_data,

                       uint8_t adv_handle, SyncTransferCb cb) override {

                       uint8_t adv_handle, int pa_source) override {

    LOG_DEBUG("address: %s", address.ToString().c_str());

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      uint8_t status_no_resource = 2;

      LOG_ERROR(" PAST not supported by controller");

      cb.Run(status_no_resource, address);

      callbacks_->OnPeriodicSyncTransferred(pa_source, status_no_resource,

                                            address);

    }



    SyncTransferCb sync_transfer_cb =

        base::Bind(&ScanningCallbacks::OnPeriodicSyncTransferred,

                   base::Unretained(callbacks_), pa_source);

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BlePeriodicSyncSetInfo, address, service_data,

                   adv_handle, jni_thread_wrapper(FROM_HERE, std::move(cb))));

                   adv_handle,

                   jni_thread_wrapper(FROM_HERE, std::move(sync_transfer_cb))));

  }



  void SyncTxParameters(RawAddress addr, uint8_t mode, uint16_t skip,

                        uint16_t timeout, StartSyncCb cb) {

                        uint16_t timeout, int reg_id) override {

    LOG_DEBUG("address: %s", addr.ToString().c_str());

    const controller_t* controller = controller_get_interface();

    if (!controller->supports_ble_periodic_advertising_sync_transfer_sender()) {

      uint8_t status_no_resource = 2;

      LOG_ERROR(" PAST not supported by controller");

      cb.Run(status_no_resource, -1, -1, 1, addr, 0, 0);

      callbacks_->OnPeriodicSyncStarted(reg_id, status_no_resource, -1, -1, 1,

                                        addr, 0, 0);

    }

    StartSyncCb start_sync_cb =

        base::Bind(&ScanningCallbacks::OnPeriodicSyncStarted,

                   base::Unretained(callbacks_), reg_id);

    do_in_main_thread(

        FROM_HERE,

        base::Bind(&BTM_BlePeriodicSyncTxParameters, addr, mode, skip, timeout,

                   jni_thread_wrapper(FROM_HERE, std::move(cb))));

                   jni_thread_wrapper(FROM_HERE, std::move(start_sync_cb))));

  }



  ScanningCallbacks* callbacks_ = nullptr;

};



}  // namespace

system/gd/rust/topshim/gatt/gatt_ble_scanner_shim.cc

+9 −18
Original line number Diff line number Diff line
@@ -252,14 +252,7 @@ void BleScannerIntf::BatchscanReadReports(uint8_t scanner_id, int32_t scan_mode) 


void BleScannerIntf::StartSync(uint8_t sid, RustRawAddress address, uint16_t skip, uint16_t timeout) {

  RawAddress converted = rusty::CopyFromRustAddress(address);

  scanner_intf_->StartSync(

      sid,

      converted,

      skip,

      timeout,

      base::Bind(&BleScannerIntf::OnStartSyncCb, base::Unretained(this)),

      base::Bind(&BleScannerIntf::OnSyncReportCb, base::Unretained(this)),

      base::Bind(&BleScannerIntf::OnSyncLostCb, base::Unretained(this)));

  scanner_intf_->StartSync(sid, converted, skip, timeout, 0 /* place holder */);

}



void BleScannerIntf::StopSync(uint16_t handle) {
@@ -273,20 +266,17 @@ void BleScannerIntf::CancelCreateSync(uint8_t sid, RustRawAddress address) { 


void BleScannerIntf::TransferSync(RustRawAddress address, uint16_t service_data, uint16_t sync_handle) {

  RawAddress converted = rusty::CopyFromRustAddress(address);

  scanner_intf_->TransferSync(

      converted, service_data, sync_handle, base::Bind(&BleScannerIntf::OnSyncTransferCb, base::Unretained(this)));

  scanner_intf_->TransferSync(converted, service_data, sync_handle, 0 /* place holder */);

}



void BleScannerIntf::TransferSetInfo(RustRawAddress address, uint16_t service_data, uint8_t adv_handle) {

  RawAddress converted = rusty::CopyFromRustAddress(address);

  scanner_intf_->TransferSetInfo(

      converted, service_data, adv_handle, base::Bind(&BleScannerIntf::OnSyncTransferCb, base::Unretained(this)));

  scanner_intf_->TransferSetInfo(converted, service_data, adv_handle, 0 /* place holder */);

}



void BleScannerIntf::SyncTxParameters(RustRawAddress address, uint8_t mode, uint16_t skip, uint16_t timeout) {

  RawAddress converted = rusty::CopyFromRustAddress(address);

  scanner_intf_->SyncTxParameters(

      converted, mode, skip, timeout, base::Bind(&BleScannerIntf::OnStartSyncCb, base::Unretained(this)));

  scanner_intf_->SyncTxParameters(converted, mode, skip, timeout, 0 /* place holder */);

}



void BleScannerIntf::OnRegisterCallback(RustUuid uuid, uint8_t scanner_id, uint8_t btm_status) {
@@ -311,7 +301,8 @@ void BleScannerIntf::OnFilterConfigCallback( 
  rusty::gdscan_filter_config_callback(filter_index, filt_type, avbl_space, action, btm_status);

}



void BleScannerIntf::OnStartSyncCb(

void BleScannerIntf::OnPeriodicSyncStarted(

    int,

    uint8_t status,

    uint16_t sync_handle,

    uint8_t advertising_sid,
@@ -323,16 +314,16 @@ void BleScannerIntf::OnStartSyncCb( 
  rusty::gdscan_start_sync_callback(status, sync_handle, advertising_sid, address_type, &converted, phy, interval);

}



void BleScannerIntf::OnSyncReportCb(

void BleScannerIntf::OnPeriodicSyncReport(

    uint16_t sync_handle, int8_t tx_power, int8_t rssi, uint8_t status, std::vector<uint8_t> data) {

  rusty::gdscan_sync_report_callback(sync_handle, tx_power, rssi, status, data.data(), data.size());

}



void BleScannerIntf::OnSyncLostCb(uint16_t sync_handle) {

void BleScannerIntf::OnPeriodicSyncLost(uint16_t sync_handle) {

  rusty::gdscan_sync_lost_callback(sync_handle);

}



void BleScannerIntf::OnSyncTransferCb(uint8_t status, RawAddress address) {

void BleScannerIntf::OnPeriodicSyncTransferred(int, uint8_t status, RawAddress address) {

  RustRawAddress converted = rusty::CopyToRustAddress(address);

  rusty::gdscan_sync_transfer_callback(status, &converted);

}

system/gd/rust/topshim/gatt/gatt_ble_scanner_shim.h

+23 −12
Original line number Diff line number Diff line
@@ -60,6 +60,24 @@ class BleScannerIntf : public ScanningCallbacks { 


  void OnBatchScanThresholdCrossed(int client_if) override;



  void OnPeriodicSyncStarted(

      int reg_id,

      uint8_t status,

      uint16_t sync_handle,

      uint8_t advertising_sid,

      uint8_t address_type,

      RawAddress address,

      uint8_t phy,

      uint16_t interval) override;

  void OnPeriodicSyncReport(

      uint16_t sync_handle,

      int8_t tx_power,

      int8_t rssi,

      uint8_t status,

      std::vector<uint8_t> data) override;

  void OnPeriodicSyncLost(uint16_t sync_handle) override;

  void OnPeriodicSyncTransferred(int pa_source, uint8_t status, RawAddress address) override;



  // Implementations of BleScannerInterface. These don't inherit from

  // BleScannerInterface because the Rust FFI boundary requires some clever

  // modifications.
@@ -147,18 +165,11 @@ class BleScannerIntf : public ScanningCallbacks { 
  void OnEnableCallback(uint8_t action, uint8_t btm_status);

  void OnFilterParamSetupCallback(uint8_t scanner_id, uint8_t avbl_space, uint8_t action_type, uint8_t btm_status);

  void OnFilterConfigCallback(

      uint8_t filt_index, uint8_t filt_type, uint8_t avbl_space, uint8_t action, uint8_t btm_status);

  void OnStartSyncCb(

      uint8_t status,

      uint16_t sync_handle,

      uint8_t advertising_sid,

      uint8_t address_type,

      RawAddress address,

      uint8_t phy,

      uint16_t interval);

  void OnSyncReportCb(uint16_t sync_handle, int8_t tx_power, int8_t rssi, uint8_t status, std::vector<uint8_t> data);

  void OnSyncLostCb(uint16_t sync_handle);

  void OnSyncTransferCb(uint8_t status, RawAddress address);

      uint8_t filt_index,

      uint8_t filt_type,

      uint8_t avbl_space,

      uint8_t action,

      uint8_t btm_status);



  BleScannerInterface* scanner_intf_;

};

system/include/hardware/ble_scanner.h

+15 −15
Original line number Diff line number Diff line
@@ -96,6 +96,17 @@ class ScanningCallbacks { 
                                  int num_records,

                                  std::vector<uint8_t> data) = 0;

  virtual void OnBatchScanThresholdCrossed(int client_if) = 0;

  virtual void OnPeriodicSyncStarted(int reg_id, uint8_t status,

                                     uint16_t sync_handle,

                                     uint8_t advertising_sid,

                                     uint8_t address_type, RawAddress address,

                                     uint8_t phy, uint16_t interval) = 0;

  virtual void OnPeriodicSyncReport(uint16_t sync_handle, int8_t tx_power,

                                    int8_t rssi, uint8_t status,

                                    std::vector<uint8_t> data) = 0;

  virtual void OnPeriodicSyncLost(uint16_t sync_handle) = 0;

  virtual void OnPeriodicSyncTransferred(int pa_source, uint8_t status,

                                         RawAddress address) = 0;

};



class BleScannerInterface {
@@ -165,31 +176,20 @@ class BleScannerInterface { 
  /* Read out batchscan reports */

  virtual void BatchscanReadReports(int client_if, int scan_mode) = 0;



  using StartSyncCb =

      base::Callback<void(uint8_t status, uint16_t sync_handle,

                          uint8_t advertising_sid, uint8_t address_type,

                          RawAddress address, uint8_t phy, uint16_t interval)>;

  using SyncReportCb =

      base::Callback<void(uint16_t sync_handle, int8_t tx_power, int8_t rssi,

                          uint8_t status, std::vector<uint8_t> data)>;

  using SyncLostCb = base::Callback<void(uint16_t sync_handle)>;

  virtual void StartSync(uint8_t sid, RawAddress address, uint16_t skip,

                         uint16_t timeout, StartSyncCb start_cb,

                         SyncReportCb report_cb, SyncLostCb lost_cb) = 0;

                         uint16_t timeout, int reg_id) = 0;

  virtual void StopSync(uint16_t handle) = 0;



  virtual void RegisterCallbacks(ScanningCallbacks* callbacks) = 0;



  virtual void CancelCreateSync(uint8_t sid, RawAddress address) = 0;

  using SyncTransferCb =

      base::Callback<void(uint8_t /*status*/, RawAddress /*addr*/)>;



  virtual void TransferSync(RawAddress address, uint16_t service_data,

                            uint16_t sync_handle, SyncTransferCb cb) = 0;

                            uint16_t sync_handle, int pa_source) = 0;

  virtual void TransferSetInfo(RawAddress address, uint16_t service_data,

                               uint8_t adv_handle, SyncTransferCb cb) = 0;

                               uint8_t adv_handle, int pa_source) = 0;

  virtual void SyncTxParameters(RawAddress addr, uint8_t mode, uint16_t skip,

                                uint16_t timeout, StartSyncCb start_cb) = 0;

                                uint16_t timeout, int reg_id) = 0;

};



#endif /* ANDROID_INCLUDE_BLE_SCANNER_H */