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

Commit 817ba73a authored by Omair Kamil's avatar Omair Kamil Committed by Gerrit Code Review
Browse files

Merge "Remove legacy scanning callbacks." into main

parents 5a131460 c9a3e848

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() {