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

Commit 83c60c8f authored by Omair Kamil's avatar Omair Kamil Committed by Automerger Merge Worker
Browse files

Merge "Remove legacy scanning callbacks." into main am: 817ba73a 

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



Change-Id: I89a50c6d9f861baf30313b8b957dda086f9cbfc1
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents dfc3fc84 817ba73a

android/app/jni/com_android_bluetooth_gatt.cpp

+0 −89
Original line number Diff line number Diff line
@@ -247,28 +247,6 @@ void btgattc_register_app_cb(int status, int clientIf, const Uuid& app_uuid) { 
                               UUID_PARAMS(app_uuid));

}



void btgattc_scan_result_cb(uint16_t event_type, uint8_t addr_type, RawAddress* bda,

                            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, RawAddress* original_bda) {

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

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid() || !mScanCallbacksObj) {

    return;

  }



  ScopedLocalRef<jstring> address(sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), bda));

  ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(), sCallbackEnv->NewByteArray(adv_data.size()));

  sCallbackEnv->SetByteArrayRegion(jb.get(), 0, adv_data.size(), (jbyte*)adv_data.data());



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

                                           bdaddr2newjstr(sCallbackEnv.get(), original_bda));



  sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onScanResult, event_type, addr_type,

                               address.get(), primary_phy, secondary_phy, advertising_sid, tx_power,

                               rssi, periodic_adv_int, jb.get(), original_address.get());

}



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__);
@@ -442,65 +420,6 @@ void btgattc_congestion_cb(int conn_id, bool congested) { 
  sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientCongestion, conn_id, 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() || !mScanCallbacksObj) {

    return;

  }

  ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(), sCallbackEnv->NewByteArray(data.size()));

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



  sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onBatchScanReports, status, client_if,

                               report_format, num_records, jb.get());

}



void btgattc_batchscan_threshold_cb(int client_if) {

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

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid() || !mScanCallbacksObj) {

    return;

  }

  sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onBatchScanThresholdCrossed, 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() || !mScanCallbacksObj) {

    return;

  }



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

                                  bdaddr2newjstr(sCallbackEnv.get(), &p_adv_track_info->bd_addr));



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

                                        sCallbackEnv->NewByteArray(p_adv_track_info->adv_pkt_len));

  ScopedLocalRef<jbyteArray> jb_scan_rsp(

          sCallbackEnv.get(), sCallbackEnv->NewByteArray(p_adv_track_info->scan_rsp_len));



  sCallbackEnv->SetByteArrayRegion(jb_adv_pkt.get(), 0, p_adv_track_info->adv_pkt_len,

                                   (jbyte*)p_adv_track_info->p_adv_pkt_data);



  sCallbackEnv->SetByteArrayRegion(jb_scan_rsp.get(), 0, p_adv_track_info->scan_rsp_len,

                                   (jbyte*)p_adv_track_info->p_scan_rsp_data);



  ScopedLocalRef<jobject> trackadv_obj(

          sCallbackEnv.get(),

          sCallbackEnv->CallObjectMethod(

                  mScanCallbacksObj, method_createOnTrackAdvFoundLostObject,

                  p_adv_track_info->client_if, p_adv_track_info->adv_pkt_len, jb_adv_pkt.get(),

                  p_adv_track_info->scan_rsp_len, jb_scan_rsp.get(), p_adv_track_info->filt_index,

                  p_adv_track_info->advertiser_state, p_adv_track_info->advertiser_info_present,

                  address.get(), p_adv_track_info->addr_type, p_adv_track_info->tx_power,

                  p_adv_track_info->rssi_value, p_adv_track_info->time_stamp));



  if (NULL != trackadv_obj.get()) {

    sCallbackEnv->CallVoidMethod(mScanCallbacksObj, method_onTrackAdvFoundLost, trackadv_obj.get());

  }

}



void fillGattDbElementArray(JNIEnv* env, jobject* array, const btgatt_db_element_t* db, int count) {

  // Because JNI uses a different class loader in the callback context, we

  // cannot simply get the class.
@@ -628,13 +547,6 @@ void btgattc_subrate_change_cb(int conn_id, uint16_t subrate_factor, uint16_t la 
                               latency, cont_num, timeout, status);

}



static const btgatt_scanner_callbacks_t sGattScannerCallbacks = {

        btgattc_scan_result_cb,

        btgattc_batchscan_reports_cb,

        btgattc_batchscan_threshold_cb,

        btgattc_track_adv_event_cb,

};



static const btgatt_client_callbacks_t sGattClientCallbacks = {

        btgattc_register_app_cb,

        btgattc_open_cb,
@@ -919,7 +831,6 @@ static const btgatt_callbacks_t sGattCallbacks = { 
        sizeof(btgatt_callbacks_t),

        &sGattClientCallbacks,

        &sGattServerCallbacks,

        &sGattScannerCallbacks,

};



class JniAdvertisingCallbacks : AdvertisingCallbacks {

system/gd/rust/topshim/src/profiles/gatt.rs

+2 −13
Original line number Diff line number Diff line
@@ -2,8 +2,8 @@ use crate::bindings::root as bindings; 
use crate::btif::{ptr_to_vec, BluetoothInterface, BtStatus, RawAddress, SupportedProfiles, Uuid};

use crate::profiles::gatt::bindings::{

    btgatt_callbacks_t, btgatt_client_callbacks_t, btgatt_client_interface_t, btgatt_interface_t,

    btgatt_scanner_callbacks_t, btgatt_server_callbacks_t, btgatt_server_interface_t,

    BleAdvertiserInterface, BleScannerInterface,

    btgatt_server_callbacks_t, btgatt_server_interface_t, BleAdvertiserInterface,

    BleScannerInterface,

};

use crate::topstack::get_dispatchers;

use crate::utils::LTCheckedPtr;
@@ -1723,7 +1723,6 @@ pub struct Gatt { 
    callbacks: Option<Box<bindings::btgatt_callbacks_t>>,

    gatt_client_callbacks: Option<Box<bindings::btgatt_client_callbacks_t>>,

    gatt_server_callbacks: Option<Box<bindings::btgatt_server_callbacks_t>>,

    gatt_scanner_callbacks: Option<Box<bindings::btgatt_scanner_callbacks_t>>,

}



impl Gatt {
@@ -1759,7 +1758,6 @@ impl Gatt { 
            callbacks: None,

            gatt_client_callbacks: None,

            gatt_server_callbacks: None,

            gatt_scanner_callbacks: None,

        }

    }
@@ -1869,18 +1867,10 @@ impl Gatt { 
            subrate_chg_cb: Some(gs_subrate_chg_cb),

        });



        let gatt_scanner_callbacks = Box::new(btgatt_scanner_callbacks_t {

            scan_result_cb: None,

            batchscan_reports_cb: None,

            batchscan_threshold_cb: None,

            track_adv_event_cb: None,

        });



        let callbacks = Box::new(btgatt_callbacks_t {

            size: std::mem::size_of::<btgatt_callbacks_t>(),

            client: &*gatt_client_callbacks,

            server: &*gatt_server_callbacks,

            scanner: &*gatt_scanner_callbacks,

        });



        let cb_ptr = LTCheckedPtr::from(&callbacks);
@@ -1890,7 +1880,6 @@ impl Gatt { 
        self.callbacks = Some(callbacks);

        self.gatt_client_callbacks = Some(gatt_client_callbacks);

        self.gatt_server_callbacks = Some(gatt_server_callbacks);

        self.gatt_scanner_callbacks = Some(gatt_scanner_callbacks);



        // Register callbacks for gatt scanner and advertiser

        mutcxxcall!(self.scanner, RegisterCallbacks);

system/include/hardware/ble_scanner.h

+0 −24
Original line number Diff line number Diff line
@@ -28,30 +28,6 @@ 
#include "types/bluetooth/uuid.h"

#include "types/raw_address.h"



/** Callback invoked when batchscan reports are obtained */

typedef void (*batchscan_reports_callback)(int client_if, int status, int report_format,

                                           int num_records, std::vector<uint8_t> data);



/** Callback invoked when batchscan storage threshold limit is crossed */

typedef void (*batchscan_threshold_callback)(int client_if);



/** Track ADV VSE callback invoked when tracked device is found or lost */

typedef void (*track_adv_event_callback)(btgatt_track_adv_info_t* p_track_adv_info);



/** Callback for scan results */

typedef void (*scan_result_callback)(uint16_t event_type, uint8_t addr_type, RawAddress* bda,

                                     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,

                                     RawAddress* original_bda);



typedef struct {

  scan_result_callback scan_result_cb;

  batchscan_reports_callback batchscan_reports_cb;

  batchscan_threshold_callback batchscan_threshold_cb;

  track_adv_event_callback track_adv_event_cb;

} btgatt_scanner_callbacks_t;



class AdvertisingTrackInfo {

public:

  // For MSFT-based advertisement monitor.

system/include/hardware/bt_gatt.h

+0 −3
Original line number Diff line number Diff line
@@ -37,9 +37,6 @@ typedef struct { 


  /** GATT Server callbacks */

  const btgatt_server_callbacks_t* server;



  /** LE scanner callbacks */

  const btgatt_scanner_callbacks_t* scanner;

} btgatt_callbacks_t;



/** Represents the standard Bluetooth GATT interface. */

system/test/suite/gatt/gatt_test.cc

+0 −13
Original line number Diff line number Diff line
@@ -32,14 +32,6 @@ void RegisterClientCallback(int status, int clientIf, const bluetooth::Uuid& /*a 
  semaphore_post(instance->register_client_callback_sem_);

}



void ScanResultCallback(uint16_t /*ble_evt_type*/, uint8_t /*addr_type*/, RawAddress* /*bda*/,

                        uint8_t /*ble_primary_phy*/, uint8_t /*ble_secondary_phy*/,

                        uint8_t /*ble_advertising_sid*/, int8_t /*ble_tx_power*/, int8_t /*rssi*/,

                        uint16_t /*ble_periodic_adv_int*/, std::vector<uint8_t> /*adv_data*/,

                        RawAddress* /*original_bda*/) {

  semaphore_post(instance->scan_result_callback_sem_);

}



// GATT server callbacks

void RegisterServerCallback(int status, int server_if, const bluetooth::Uuid& /*uuid*/) {

  instance->status_ = status;
@@ -69,10 +61,6 @@ void ServiceDeletedCallback(int status, int server_if, int srvc_handle) { 
  semaphore_post(instance->service_deleted_callback_sem_);

}



static const btgatt_scanner_callbacks_t scanner_callbacks = {

        .scan_result_cb = ScanResultCallback,

};



static const btgatt_client_callbacks_t client_callbacks = {

        .register_client_cb = RegisterClientCallback,

};
@@ -88,7 +76,6 @@ static const btgatt_callbacks_t callbacks = { 
        sizeof(btgatt_callbacks_t),

        &client_callbacks,

        &server_callbacks,

        &scanner_callbacks,

};



void GattTest::SetUp() {