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

Commit 6adb5eb2 authored by Chris Manton's avatar Chris Manton Committed by Automerger Merge Worker
Browse files

Remove unused main::shim code am: 2c8fd40e 

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



Change-Id: I75ffc9079409b4e43461d55e5ad4854cc8ba3b3c
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 7d60616e 2c8fd40e

system/main/shim/btm_api.cc

+0 −505
Original line number Diff line number Diff line
@@ -48,516 +48,11 @@ 
#include "types/bluetooth/uuid.h"

#include "types/raw_address.h"



using bluetooth::common::MetricIdAllocator;



#define BTIF_DM_DEFAULT_INQ_MAX_RESULTS 0

#define BTIF_DM_DEFAULT_INQ_MAX_DURATION 10



/**

 * Legacy bluetooth module global control block state

 *

 * Mutex is used to synchronize access from the shim

 * layer into the global control block.  This is used

 * by the shim despite potentially arbitrary

 * unsynchronized access by the legacy stack.

 */

extern tBTM_CB btm_cb;

std::mutex btm_cb_mutex_;



bool btm_inq_find_bdaddr(const RawAddress& p_bda);

extern tINQ_DB_ENT* btm_inq_db_find(const RawAddress& raw_address);

extern tINQ_DB_ENT* btm_inq_db_new(const RawAddress& p_bda, bool is_ble);



/**

 * Legacy bluetooth btm stack entry points

 */

void btm_acl_update_inquiry_status(uint8_t status);

void btm_clear_all_pending_le_entry(void);

void btm_clr_inq_result_flt(void);

void btm_set_eir_uuid(const uint8_t* p_eir, tBTM_INQ_RESULTS* p_results);

void btm_sort_inq_result(void);

void btm_process_inq_complete(tHCI_STATUS status, uint8_t result_type);



namespace {

std::unordered_map<bluetooth::hci::AddressWithType, bt_bdname_t>

    address_name_map_;



std::unordered_map<bluetooth::hci::IoCapability, int> gd_legacy_io_caps_map_ = {

    {bluetooth::hci::IoCapability::DISPLAY_ONLY, BTM_IO_CAP_OUT},

    {bluetooth::hci::IoCapability::DISPLAY_YES_NO, BTM_IO_CAP_IO},

    {bluetooth::hci::IoCapability::KEYBOARD_ONLY, BTM_IO_CAP_IN},

    {bluetooth::hci::IoCapability::NO_INPUT_NO_OUTPUT, BTM_IO_CAP_NONE},

};



std::unordered_map<bluetooth::hci::AuthenticationRequirements, int>

    gd_legacy_auth_reqs_map_ = {

        {bluetooth::hci::AuthenticationRequirements::NO_BONDING,

         BTM_AUTH_SP_NO},

        {bluetooth::hci::AuthenticationRequirements::NO_BONDING_MITM_PROTECTION,

         BTM_AUTH_SP_YES},

        {bluetooth::hci::AuthenticationRequirements::DEDICATED_BONDING,

         BTM_AUTH_AP_NO},

        {bluetooth::hci::AuthenticationRequirements::

             DEDICATED_BONDING_MITM_PROTECTION,

         BTM_AUTH_AP_YES},

        {bluetooth::hci::AuthenticationRequirements::GENERAL_BONDING,

         BTM_AUTH_SPGB_NO},

        {bluetooth::hci::AuthenticationRequirements::

             GENERAL_BONDING_MITM_PROTECTION,

         BTM_AUTH_SPGB_YES},

};

}



class ShimUi : public bluetooth::security::UI {

 public:

  static ShimUi* GetInstance() {

    static ShimUi instance;

    return &instance;

  }



  ShimUi(const ShimUi&) = delete;

  ShimUi& operator=(const ShimUi&) = delete;



  void SetBtaCallbacks(const tBTM_APPL_INFO* bta_callbacks) {

    bta_callbacks_ = bta_callbacks;

    if (bta_callbacks->p_pin_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s pin_callback", __func__);

    }



    if (bta_callbacks->p_link_key_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s link_key_callback", __func__);

    }



    if (bta_callbacks->p_auth_complete_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s auth_complete_callback", __func__);

    }



    if (bta_callbacks->p_bond_cancel_cmpl_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s bond_cancel_complete_callback", __func__);

    }



    if (bta_callbacks->p_le_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s le_callback", __func__);

    }



    if (bta_callbacks->p_le_key_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s le_key_callback", __func__);

    }



    if (bta_callbacks->p_sirk_verification_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s sirk_verification_callback", __func__);

    }

  }



  void DisplayPairingPrompt(const bluetooth::hci::AddressWithType& address,

                            std::string name) {

    waiting_for_pairing_prompt_ = true;

    bt_bdname_t legacy_name{0};

    memcpy(legacy_name.name, name.data(), name.length());

    // TODO(optedoblivion): Handle callback to BTA for BLE

  }



  void Cancel(const bluetooth::hci::AddressWithType& address) {

    LOG(WARNING) << " ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ " << __func__;

  }



  void HandleConfirm(bluetooth::security::ConfirmationData data) {

    const bluetooth::hci::AddressWithType& address = data.GetAddressWithType();

    uint32_t numeric_value = data.GetNumericValue();

    bt_bdname_t legacy_name{0};

    memcpy(legacy_name.name, data.GetName().data(), data.GetName().length());



    if (bta_callbacks_->p_sp_callback) {

      // Call sp_cback for IO_REQ

      tBTM_SP_IO_REQ io_req_evt_data;

      io_req_evt_data.bd_addr = bluetooth::ToRawAddress(address.GetAddress());

      // Local IO Caps (Phone is always DisplayYesNo)

      io_req_evt_data.io_cap = BTM_IO_CAP_IO;

      // Local Auth Reqs (Phone is always DEDICATED_BONDING)

      io_req_evt_data.auth_req = BTM_AUTH_AP_NO;

      io_req_evt_data.oob_data = BTM_OOB_NONE;

      (*bta_callbacks_->p_sp_callback)(BTM_SP_IO_REQ_EVT,

                                       (tBTM_SP_EVT_DATA*)&io_req_evt_data);



      // Call sp_cback for IO_RSP

      tBTM_SP_IO_RSP io_rsp_evt_data;

      io_rsp_evt_data.bd_addr = bluetooth::ToRawAddress(address.GetAddress());

      io_rsp_evt_data.io_cap = static_cast<tBTM_IO_CAP>(

          gd_legacy_io_caps_map_[data.GetRemoteIoCaps()]);

      io_rsp_evt_data.auth_req =

          gd_legacy_auth_reqs_map_[data.GetRemoteAuthReqs()];

      io_rsp_evt_data.auth_req = BTM_AUTH_AP_YES;

      io_rsp_evt_data.oob_data = BTM_OOB_NONE;

      (*bta_callbacks_->p_sp_callback)(BTM_SP_IO_RSP_EVT,

                                       (tBTM_SP_EVT_DATA*)&io_rsp_evt_data);



      // Call sp_cback for USER_CONFIRMATION

      tBTM_SP_EVT_DATA user_cfm_req_evt_data;

      user_cfm_req_evt_data.cfm_req.bd_addr =

          bluetooth::ToRawAddress(address.GetAddress());

      user_cfm_req_evt_data.cfm_req.num_val = numeric_value;

      // If we pop a dialog then it isn't just_works

      user_cfm_req_evt_data.cfm_req.just_works = data.IsJustWorks();



      address_name_map_.emplace(address, legacy_name);

      memcpy((char*)user_cfm_req_evt_data.cfm_req.bd_name, legacy_name.name,

             BD_NAME_LEN);



      (*bta_callbacks_->p_sp_callback)(BTM_SP_CFM_REQ_EVT,

                                       &user_cfm_req_evt_data);

    }

  }



  void DisplayConfirmValue(bluetooth::security::ConfirmationData data) {

    waiting_for_pairing_prompt_ = false;

    data.SetJustWorks(false);

    HandleConfirm(data);

  }



  void DisplayYesNoDialog(bluetooth::security::ConfirmationData data) {

    waiting_for_pairing_prompt_ = false;

    data.SetJustWorks(true);

    HandleConfirm(data);

  }



  void DisplayEnterPasskeyDialog(bluetooth::security::ConfirmationData data) {

    waiting_for_pairing_prompt_ = false;

    LOG_WARN("UNIMPLEMENTED, Passkey not supported in GD");

  }



  void DisplayPasskey(bluetooth::security::ConfirmationData data) {

    waiting_for_pairing_prompt_ = false;

    LOG_WARN("UNIMPLEMENTED, Passkey not supported in GD");

  }



  void DisplayEnterPinDialog(bluetooth::security::ConfirmationData data) {

    waiting_for_pairing_prompt_ = false;

    LOG_WARN("UNIMPLEMENTED, PIN not supported in GD");

  }



  bool waiting_for_pairing_prompt_ = false;



 private:

  ShimUi() : bta_callbacks_(nullptr) {}

  ~ShimUi() {}

  const tBTM_APPL_INFO* bta_callbacks_;

};



ShimUi* shim_ui_ = nullptr;



class ShimBondListener : public bluetooth::security::ISecurityManagerListener {

 public:

  static ShimBondListener* GetInstance() {

    static ShimBondListener instance;

    return &instance;

  }



  ShimBondListener(const ShimBondListener&) = delete;

  ShimBondListener& operator=(const ShimBondListener&) = delete;



  void SetBtaCallbacks(const tBTM_APPL_INFO* bta_callbacks) {

    bta_callbacks_ = bta_callbacks;

    if (bta_callbacks->p_pin_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s pin_callback", __func__);

    }



    if (bta_callbacks->p_link_key_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s link_key_callback", __func__);

    }



    if (bta_callbacks->p_auth_complete_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s auth_complete_callback", __func__);

    }



    if (bta_callbacks->p_bond_cancel_cmpl_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s bond_cancel_complete_callback", __func__);

    }



    if (bta_callbacks->p_le_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s le_callback", __func__);

    }



    if (bta_callbacks->p_le_key_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s le_key_callback", __func__);

    }



    if (bta_callbacks->p_sirk_verification_callback == nullptr) {

      LOG_INFO("UNIMPLEMENTED %s sirk_verification_callback", __func__);

    }

  }



  void OnDeviceBonded(bluetooth::hci::AddressWithType device) override {

    // Call sp_cback for LINK_KEY_NOTIFICATION

    // Call AUTHENTICATION_COMPLETE callback

    if (device.GetAddressType() ==

        bluetooth::hci::AddressType::PUBLIC_DEVICE_ADDRESS) {

      auto it = address_name_map_.find(device);

      bt_bdname_t tmp_name;

      if (it != address_name_map_.end()) {

        tmp_name = it->second;

      }

      BD_NAME name;

      memcpy((char*)name, tmp_name.name, BD_NAME_LEN);



      if (*bta_callbacks_->p_link_key_callback) {

        LinkKey key;  // Never want to send the key to the stack

        (*bta_callbacks_->p_link_key_callback)(

            bluetooth::ToRawAddress(device.GetAddress()), 0, name, key,

            BTM_LKEY_TYPE_COMBINATION, false /* is_ctkd */);

      }

      if (*bta_callbacks_->p_auth_complete_callback) {

        (*bta_callbacks_->p_auth_complete_callback)(

            bluetooth::ToRawAddress(device.GetAddress()), 0, name, HCI_SUCCESS);

      }

    }

    bluetooth::shim::AllocateIdFromMetricIdAllocator(

        bluetooth::ToRawAddress(device.GetAddress()));

    bool is_saving_successful = bluetooth::shim::SaveDeviceOnMetricIdAllocator(

        bluetooth::ToRawAddress(device.GetAddress()));

    if (!is_saving_successful) {

      LOG(FATAL) << __func__ << ": Fail to save metric id for device "

                 << bluetooth::ToRawAddress(device.GetAddress());

    }

  }



  void OnDeviceUnbonded(bluetooth::hci::AddressWithType device) override {

    if (bta_callbacks_->p_bond_cancel_cmpl_callback) {

      (*bta_callbacks_->p_bond_cancel_cmpl_callback)(BTM_SUCCESS);

    }

    bluetooth::shim::ForgetDeviceFromMetricIdAllocator(

        bluetooth::ToRawAddress(device.GetAddress()));

  }



  void OnDeviceBondFailed(bluetooth::hci::AddressWithType device,

                          bluetooth::security::PairingFailure status) override {

    auto it = address_name_map_.find(device);

    bt_bdname_t tmp_name;

    if (it != address_name_map_.end()) {

      tmp_name = it->second;

    }

    BD_NAME name;

    memcpy((char*)name, tmp_name.name, BD_NAME_LEN);



    if (bta_callbacks_->p_auth_complete_callback) {

      (*bta_callbacks_->p_auth_complete_callback)(

          bluetooth::ToRawAddress(device.GetAddress()), 0, name,

          HCI_ERR_AUTH_FAILURE);

    }

  }



  void OnEncryptionStateChanged(

      bluetooth::hci::EncryptionChangeView encryption_change_view) override {

    // TODO(optedoblivion): Find BTA callback for this to call

  }



 private:

  ShimBondListener() : bta_callbacks_(nullptr) {}

  ~ShimBondListener() {}

  const tBTM_APPL_INFO* bta_callbacks_;

};



tBTM_STATUS bluetooth::shim::BTM_CancelRemoteDeviceName(void) {

  return Stack::GetInstance()->GetBtm()->CancelAllReadRemoteDeviceName();

}



tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbRead(const RawAddress& p_bda) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  return nullptr;

}



tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbFirst(void) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  return nullptr;

}



tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbNext(tBTM_INQ_INFO* p_cur) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_cur != nullptr);

  return nullptr;

}



tBTM_STATUS bluetooth::shim::BTM_ClearInqDb(const RawAddress* p_bda) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  if (p_bda == nullptr) {

    // clear all entries

  } else {

    // clear specific entry

  }

  return BTM_NO_RESOURCES;

}



bool bluetooth::shim::BTM_HasEirService(const uint32_t* p_eir_uuid,

                                        uint16_t uuid16) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_eir_uuid != nullptr);

  return false;

}



void bluetooth::shim::BTM_AddEirService(uint32_t* p_eir_uuid, uint16_t uuid16) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_eir_uuid != nullptr);

}



void bluetooth::shim::BTM_ReadConnectionAddr(const RawAddress& remote_bda,

                                             RawAddress& local_conn_addr,

                                             tBLE_ADDR_TYPE* p_addr_type) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_addr_type != nullptr);

}



bool bluetooth::shim::BTM_ReadRemoteConnectionAddr(

    const RawAddress& pseudo_addr, RawAddress& conn_addr,

    tBLE_ADDR_TYPE* p_addr_type) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_addr_type != nullptr);

  return false;

}



void bluetooth::shim::BTM_BleSetConnScanParams(uint32_t scan_interval,

                                               uint32_t scan_window) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

}



void bluetooth::shim::BTM_ReadDevInfo(const RawAddress& remote_bda,

                                      tBT_DEVICE_TYPE* p_dev_type,

                                      tBLE_ADDR_TYPE* p_addr_type) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_dev_type != nullptr);

  CHECK(p_addr_type != nullptr);

}



bool bluetooth::shim::BTM_ReadConnectedTransportAddress(

    RawAddress* remote_bda, tBT_TRANSPORT transport) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(remote_bda != nullptr);

  return false;

}



void bluetooth::shim::BTM_BleReceiverTest(uint8_t rx_freq,

                                          tBTM_CMPL_CB* p_cmd_cmpl_cback) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_cmd_cmpl_cback != nullptr);

}



void bluetooth::shim::BTM_BleTransmitterTest(uint8_t tx_freq,

                                             uint8_t test_data_len,

                                             uint8_t packet_payload,

                                             tBTM_CMPL_CB* p_cmd_cmpl_cback) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_cmd_cmpl_cback != nullptr);

}



void bluetooth::shim::BTM_BleTestEnd(tBTM_CMPL_CB* p_cmd_cmpl_cback) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_cmd_cmpl_cback != nullptr);

}



bool bluetooth::shim::BTM_GetLeSecurityState(const RawAddress& bd_addr,

                                             uint8_t* p_le_dev_sec_flags,

                                             uint8_t* p_le_key_size) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  CHECK(p_le_dev_sec_flags != nullptr);

  CHECK(p_le_key_size != nullptr);

  return false;

}



bool bluetooth::shim::BTM_BleSecurityProcedureIsRunning(

    const RawAddress& bd_addr) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  return false;

}



uint8_t bluetooth::shim::BTM_BleGetSupportedKeySize(const RawAddress& bd_addr) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

  return 0;

}



void bluetooth::shim::BTM_BleAdvFilterParamSetup(

    tBTM_BLE_SCAN_COND_OP action, tBTM_BLE_PF_FILT_INDEX filt_index,

    std::unique_ptr<btgatt_filt_param_setup_t> p_filt_params,

    tBTM_BLE_PF_PARAM_CB cb) {

  LOG_INFO("UNIMPLEMENTED %s", __func__);

}



tBTM_STATUS bluetooth::shim::BTM_SecBond(const RawAddress& bd_addr,

                                         tBLE_ADDR_TYPE addr_type,

                                         tBT_TRANSPORT transport,

                                         tBT_DEVICE_TYPE device_type) {

  return Stack::GetInstance()->GetBtm()->CreateBond(bd_addr, addr_type,

                                                    transport, device_type);

}



bool bluetooth::shim::BTM_SecAddDevice(const RawAddress& bd_addr,

                                       DEV_CLASS dev_class,

                                       const BD_NAME& bd_name,

                                       uint8_t* features, LinkKey* link_key,

                                       uint8_t key_type, uint8_t pin_length) {

  // Check if GD has a security record for the device

  return BTM_SUCCESS;

}



void bluetooth::shim::BTM_ConfirmReqReply(tBTM_STATUS res,

                                          const RawAddress& bd_addr) {

  // Send for both Classic and LE until we can determine the type

  bool accept = res == BTM_SUCCESS;

  hci::AddressWithType address = ToAddressWithType(bd_addr, BLE_ADDR_PUBLIC);

  hci::AddressWithType address2 = ToAddressWithType(bd_addr, BLE_ADDR_RANDOM);

  auto security_manager =

      bluetooth::shim::GetSecurityModule()->GetSecurityManager();

  if (ShimUi::GetInstance()->waiting_for_pairing_prompt_) {

    LOG(INFO) << "interpreting confirmation as pairing accept " << address;

    security_manager->OnPairingPromptAccepted(address, accept);

    security_manager->OnPairingPromptAccepted(address2, accept);

    ShimUi::GetInstance()->waiting_for_pairing_prompt_ = false;

  } else {

    LOG(INFO) << "interpreting confirmation as yes/no confirmation " << address;

    security_manager->OnConfirmYesNo(address, accept);

    security_manager->OnConfirmYesNo(address2, accept);

  }

}



uint16_t bluetooth::shim::BTM_GetHCIConnHandle(const RawAddress& remote_bda,

                                               tBT_TRANSPORT transport) {

  return Stack::GetInstance()->GetBtm()->GetAclHandle(remote_bda, transport);

}



void bluetooth::shim::BTM_SecClearSecurityFlags(const RawAddress& bd_addr) {

  // TODO(optedoblivion): Call RemoveBond on device address

}



bool bluetooth::shim::BTM_SecAddRmtNameNotifyCallback(

    tBTM_RMT_NAME_CALLBACK* p_callback) {

  // TODO(optedoblivion): keep track of callback

  LOG_WARN("Unimplemented");

  return true;

}



bool bluetooth::shim::BTM_SecDeleteRmtNameNotifyCallback(

    tBTM_RMT_NAME_CALLBACK* p_callback) {

  // TODO(optedoblivion): stop keeping track of callback

  LOG_WARN("Unimplemented");

  return true;

}



void bluetooth::shim::BTM_PINCodeReply(const RawAddress& bd_addr,

                                       tBTM_STATUS res, uint8_t pin_len,

                                       uint8_t* p_pin) {

  ASSERT_LOG(!bluetooth::shim::is_gd_shim_enabled(), "Unreachable code path");

}



void bluetooth::shim::BTM_RemoteOobDataReply(tBTM_STATUS res,

                                             const RawAddress& bd_addr,

                                             const Octet16& c,

                                             const Octet16& r) {

  ASSERT_LOG(!bluetooth::shim::is_gd_shim_enabled(), "Unreachable code path");

}



tBTM_STATUS bluetooth::shim::BTM_SetDeviceClass(DEV_CLASS dev_class) {

  // TODO(optedoblivion): see if we need this, I don't think we do

  LOG_WARN("Unimplemented");

  return BTM_SUCCESS;

}



tBTM_STATUS bluetooth::shim::BTM_ClearEventFilter() {

  controller_get_interface()->clear_event_filter();

  return BTM_SUCCESS;

system/stack/acl/btm_acl.cc

+0 −10
Original line number Diff line number Diff line
@@ -2387,11 +2387,6 @@ bool acl_peer_supports_ble_connection_subrating_host( 
void BTM_ReadConnectionAddr(const RawAddress& remote_bda,

                            RawAddress& local_conn_addr,

                            tBLE_ADDR_TYPE* p_addr_type) {

  if (bluetooth::shim::is_gd_shim_enabled()) {

    return bluetooth::shim::BTM_ReadConnectionAddr(remote_bda, local_conn_addr,

                                                   p_addr_type);

  }



  if (bluetooth::shim::is_gd_l2cap_enabled()) {

    bluetooth::shim::L2CA_ReadConnectionAddr(remote_bda, local_conn_addr,

                                             p_addr_type);
@@ -2495,11 +2490,6 @@ bool acl_is_switch_role_idle(const RawAddress& bd_addr, 
bool BTM_ReadRemoteConnectionAddr(const RawAddress& pseudo_addr,

                                  RawAddress& conn_addr,

                                  tBLE_ADDR_TYPE* p_addr_type) {

  if (bluetooth::shim::is_gd_shim_enabled()) {

    return bluetooth::shim::BTM_ReadRemoteConnectionAddr(pseudo_addr, conn_addr,

                                                         p_addr_type);

  }



  if (bluetooth::shim::is_gd_l2cap_enabled()) {

    return bluetooth::shim::L2CA_ReadRemoteConnectionAddr(

        pseudo_addr, conn_addr, p_addr_type);

system/stack/btm/btm_ble.cc

+0 −10
Original line number Diff line number Diff line
@@ -585,9 +585,6 @@ bool BTM_ReadConnectedTransportAddress(RawAddress* remote_bda, 
 *

 ******************************************************************************/

void BTM_BleReceiverTest(uint8_t rx_freq, tBTM_CMPL_CB* p_cmd_cmpl_cback) {

  if (bluetooth::shim::is_gd_shim_enabled()) {

    return bluetooth::shim::BTM_BleReceiverTest(rx_freq, p_cmd_cmpl_cback);

  }

  btm_cb.devcb.p_le_test_cmd_cmpl_cb = p_cmd_cmpl_cback;



  btsnd_hcic_ble_receiver_test(rx_freq);
@@ -609,10 +606,6 @@ void BTM_BleReceiverTest(uint8_t rx_freq, tBTM_CMPL_CB* p_cmd_cmpl_cback) { 
void BTM_BleTransmitterTest(uint8_t tx_freq, uint8_t test_data_len,

                            uint8_t packet_payload,

                            tBTM_CMPL_CB* p_cmd_cmpl_cback) {

  if (bluetooth::shim::is_gd_shim_enabled()) {

    return bluetooth::shim::BTM_BleTransmitterTest(

        tx_freq, test_data_len, packet_payload, p_cmd_cmpl_cback);

  }

  btm_cb.devcb.p_le_test_cmd_cmpl_cb = p_cmd_cmpl_cback;

  btsnd_hcic_ble_transmitter_test(tx_freq, test_data_len, packet_payload);

}
@@ -628,9 +621,6 @@ void BTM_BleTransmitterTest(uint8_t tx_freq, uint8_t test_data_len, 
 *

 ******************************************************************************/

void BTM_BleTestEnd(tBTM_CMPL_CB* p_cmd_cmpl_cback) {

  if (bluetooth::shim::is_gd_shim_enabled()) {

    return bluetooth::shim::BTM_BleTestEnd(p_cmd_cmpl_cback);

  }

  btm_cb.devcb.p_le_test_cmd_cmpl_cb = p_cmd_cmpl_cback;



  btsnd_hcic_ble_test_end();