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

Commit 583d945e authored by Chris Manton's avatar Chris Manton
Browse files

Conditional entry between legacy Gd stack 

Bug: 141963466
Test: Inquiry/Discoverable operational in Gd mode
Change-Id: If88cfd69d4eb60e615c1f84e8972676e27364c73
parent a9de43ca

system/main/shim/btm.cc

+246 −101
Original line number Diff line number Diff line
@@ -16,172 +16,317 @@ 


#define LOG_TAG "bt_shim_btm"



#include <algorithm>



#include "main/shim/btm.h"

#include "main/shim/entry.h"

#include "main/shim/shim.h"

#include "osi/include/log.h"



bluetooth::shim::Btm::Btm() {}



void bluetooth::shim::Btm::SetLeDiscoverabilityOff() {

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

  le_.mode = kDiscoverableModeOff;

static constexpr size_t kMaxInquiryResultSize = 4096;

static uint8_t inquiry_result_buf[kMaxInquiryResultSize];



static int inquiry_type_ = 0;



extern void btm_process_cancel_complete(uint8_t status, uint8_t mode);

extern void btm_process_inq_complete(uint8_t status, uint8_t result_type);



/**

 * Inquiry

 */

void bluetooth::shim::Btm::OnInquiryResult(std::vector<const uint8_t> result) {

  CHECK(result.size() < kMaxInquiryResultSize);



  std::copy(result.begin(), result.end(), inquiry_result_buf);

  // TODO(cmanton) Process result packets

}



void bluetooth::shim::Btm::SetLeLimitedDiscoverability() {

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

  le_.mode = kLimitedDiscoverableMode;

void bluetooth::shim::Btm::OnInquiryResultWithRssi(

    std::vector<const uint8_t> result) {

  CHECK(result.size() < kMaxInquiryResultSize);



  std::copy(result.begin(), result.end(), inquiry_result_buf);

  // TODO(cmanton) Process result packets

}



void bluetooth::shim::Btm::SetLeGeneralDiscoverability() {

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

  le_.mode = kGeneralDiscoverableMode;

  return DoSetDiscoverability();

void bluetooth::shim::Btm::OnExtendedInquiryResult(

    std::vector<const uint8_t> result) {

  CHECK(result.size() < kMaxInquiryResultSize);



  std::copy(result.begin(), result.end(), inquiry_result_buf);

  // TODO(cmanton) Process result packets

}



// private

void bluetooth::shim::Btm::DoSetDiscoverability() {

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

  // TODO(cmanton) actually set discoverability here

void bluetooth::shim::Btm::OnInquiryComplete(uint16_t status) {

  btm_process_inq_complete(status, inquiry_type_);

}



DiscoverabilityState bluetooth::shim::Btm::GetLeDiscoverabilityState() const {

  return le_;

bool bluetooth::shim::Btm::SetInquiryFilter(uint8_t mode, uint8_t type,

                                            tBTM_INQ_FILT_COND data) {

  switch (mode) {

    case kInquiryModeOff:

      break;

    case kLimitedInquiryMode:

      LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

      break;

    case kGeneralInquiryMode:

      LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

      break;

    default:

      LOG_WARN(LOG_TAG, "%s Unknown inquiry mode:%d", __func__, mode);

      return false;

  }

  return true;

}



void bluetooth::shim::Btm::SetClassicDiscoverabilityOff() {

  classic_.mode = kDiscoverableModeOff;

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

void bluetooth::shim::Btm::SetFilterInquiryOnAddress() {

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

}



void bluetooth::shim::Btm::SetClassicLimitedDiscoverability(uint16_t window,

                                                            uint16_t interval) {

  classic_.mode = kLimitedDiscoverableMode;

  classic_.window = window;

  classic_.interval = interval;

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

void bluetooth::shim::Btm::SetFilterInquiryOnDevice() {

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

}



void bluetooth::shim::Btm::SetClassicGeneralDiscoverability(uint16_t window,

                                                            uint16_t interval) {

  classic_.mode = kGeneralDiscoverableMode;

  classic_.window = window;

  classic_.interval = interval;

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

void bluetooth::shim::Btm::ClearInquiryFilter() {

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

}



DiscoverabilityState bluetooth::shim::Btm::GetClassicDiscoverabilityState()

    const {

  return classic_;

bool bluetooth::shim::Btm::SetStandardInquiryResultMode() {

  bluetooth::shim::GetInquiry()->SetStandardInquiryResultMode();

  return true;

}



bool bluetooth::shim::Btm::SetInquiryWithRssiResultMode() {

  bluetooth::shim::GetInquiry()->SetInquiryWithRssiResultMode();

  return true;

}



bool bluetooth::shim::Btm::SetExtendedInquiryResultMode() {

  bluetooth::shim::GetInquiry()->SetExtendedInquiryResultMode();

  return true;

}



void bluetooth::shim::Btm::SetInterlacedInquiryScan() {

  bluetooth::shim::GetInquiry()->SetInterlacedScan();

}



void bluetooth::shim::Btm::SetStandardInquiryScan() {

  bluetooth::shim::GetInquiry()->SetStandardScan();

}



bool bluetooth::shim::Btm::IsInterlacedScanSupported() const {

  // TODO(cmanton) Check controller to ensure interlaced scan is actually

  // supported

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

  // TODO(cmanton) This is a controller query

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

  return true;

}



bool bluetooth::shim::Btm::SetInterlacedInquiryScan() {

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

  return false;

/**

 * One shot inquiry

 */

bool bluetooth::shim::Btm::StartInquiry(uint8_t mode, uint8_t duration,

                                        uint8_t max_responses) {

  switch (mode) {

    case kInquiryModeOff:

      LOG_DEBUG(LOG_TAG, "%s Stopping inquiry mode", __func__);

      bluetooth::shim::GetInquiry()->StopInquiry();

      bluetooth::shim::GetInquiry()->UnregisterInquiryResult();

      bluetooth::shim::GetInquiry()->UnregisterInquiryResultWithRssi();

      bluetooth::shim::GetInquiry()->UnregisterExtendedInquiryResult();

      bluetooth::shim::GetInquiry()->UnregisterInquiryComplete();

      break;



    case kLimitedInquiryMode:

    case kGeneralInquiryMode:

      bluetooth::shim::GetInquiry()->RegisterInquiryResult(

          std::bind(&Btm::OnInquiryResult, this, std::placeholders::_1));

      bluetooth::shim::GetInquiry()->RegisterInquiryResultWithRssi(std::bind(

          &Btm::OnInquiryResultWithRssi, this, std::placeholders::_1));

      bluetooth::shim::GetInquiry()->RegisterExtendedInquiryResult(std::bind(

          &Btm::OnExtendedInquiryResult, this, std::placeholders::_1));

      bluetooth::shim::GetInquiry()->RegisterInquiryComplete(

          std::bind(&Btm::OnInquiryComplete, this, std::placeholders::_1));



      if (mode == kLimitedInquiryMode) {

        LOG_DEBUG(

            LOG_TAG,

            "%s Starting limited inquiry mode duration:%hhd max responses:%hhd",

            __func__, duration, max_responses);

        bluetooth::shim::GetInquiry()->StartLimitedInquiry(duration,

                                                           max_responses);

      } else {

        LOG_DEBUG(

            LOG_TAG,

            "%s Starting general inquiry mode duration:%hhd max responses:%hhd",

            __func__, duration, max_responses);

        bluetooth::shim::GetInquiry()->StartGeneralInquiry(duration,

                                                           max_responses);

      }

      break;



bool bluetooth::shim::Btm::SetStandardInquiryScan() {

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

    default:

      LOG_WARN(LOG_TAG, "%s Unknown inquiry mode:%d", __func__, mode);

      return false;

  }

  return true;

}



bool bluetooth::shim::Btm::SetInterlacedPageScan() {

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

  return false;

void bluetooth::shim::Btm::CancelInquiry() {

  bluetooth::shim::GetInquiry()->StopInquiry();

}



bool bluetooth::shim::Btm::SetStandardPageScan() {

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

  return false;

bool bluetooth::shim::Btm::IsInquiryActive() const {

  return IsGeneralInquiryActive() || IsLimitedInquiryActive();

}



bool bluetooth::shim::Btm::SetStandardInquiryMode() {

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

  return DoSetInquiryMode();

bool bluetooth::shim::Btm::IsGeneralInquiryActive() const {

  return bluetooth::shim::GetInquiry()->IsGeneralInquiryActive();

}



bool bluetooth::shim::Btm::SetInquiryModeWithRssi() {

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

  return DoSetInquiryMode();

bool bluetooth::shim::Btm::IsLimitedInquiryActive() const {

  return bluetooth::shim::GetInquiry()->IsLimitedInquiryActive();

}



bool bluetooth::shim::Btm::SetExtendedInquiryMode() {

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

  return DoSetInquiryMode();

/**

 * Periodic Inquiry

 */

bool bluetooth::shim::Btm::StartPeriodicInquiry(

    uint8_t mode, uint8_t duration, uint8_t max_responses, uint16_t max_delay,

    uint16_t min_delay, tBTM_INQ_RESULTS_CB* p_results_cb) {

  switch (mode) {

    case kInquiryModeOff:

      bluetooth::shim::GetInquiry()->StopPeriodicInquiry();

      break;



    case kLimitedInquiryMode:

    case kGeneralInquiryMode:

      if (mode == kLimitedInquiryMode) {

        LOG_DEBUG(LOG_TAG, "%s Starting limited periodic inquiry mode",

                  __func__);

        bluetooth::shim::GetInquiry()->StartLimitedPeriodicInquiry(

            duration, max_responses, max_delay, min_delay);

      } else {

        LOG_DEBUG(LOG_TAG, "%s Starting general periodic inquiry mode",

                  __func__);

        bluetooth::shim::GetInquiry()->StartGeneralPeriodicInquiry(

            duration, max_responses, max_delay, min_delay);

      }

      break;



// private

bool bluetooth::shim::Btm::DoSetInquiryMode() {

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

    default:

      LOG_WARN(LOG_TAG, "%s Unknown inquiry mode:%d", __func__, mode);

      return false;

  }

  return true;

}



bool bluetooth::shim::Btm::IsInquiryActive() const {

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

  return false;

void bluetooth::shim::Btm::CancelPeriodicInquiry() {

  bluetooth::shim::GetInquiry()->StopPeriodicInquiry();

}



bool bluetooth::shim::Btm::ClearInquiryFilter() {

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

  return DoSetEventFilter();

/**

 * Discoverability

 */

void bluetooth::shim::Btm::SetClassicGeneralDiscoverability(uint16_t window,

                                                            uint16_t interval) {

  bluetooth::shim::GetInquiry()->SetScanActivity(interval, window);

  bluetooth::shim::GetDiscoverability()->StartGeneralDiscoverability();

}



bool bluetooth::shim::Btm::SetFilterInquiryOnDevice() {

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

  return DoSetEventFilter();

void bluetooth::shim::Btm::SetClassicLimitedDiscoverability(uint16_t window,

                                                            uint16_t interval) {

  bluetooth::shim::GetInquiry()->SetScanActivity(interval, window);

  bluetooth::shim::GetDiscoverability()->StartLimitedDiscoverability();

}



bool bluetooth::shim::Btm::SetFilterInquiryOnAddress() {

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

  return DoSetEventFilter();

void bluetooth::shim::Btm::SetClassicDiscoverabilityOff() {

  bluetooth::shim::GetDiscoverability()->StopDiscoverability();

}



bool bluetooth::shim::Btm::CancelPeriodicInquiry() {

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

  return false;

DiscoverabilityState bluetooth::shim::Btm::GetClassicDiscoverabilityState()

    const {

  DiscoverabilityState state{.mode = BTM_NON_DISCOVERABLE};

  bluetooth::shim::GetInquiry()->GetScanActivity(state.interval, state.window);



  if (bluetooth::shim::GetDiscoverability()

          ->IsGeneralDiscoverabilityEnabled()) {

    state.mode = BTM_GENERAL_DISCOVERABLE;

  } else if (bluetooth::shim::GetDiscoverability()

                 ->IsLimitedDiscoverabilityEnabled()) {

    state.mode = BTM_LIMITED_DISCOVERABLE;

  }

  return state;

}



// private

bool bluetooth::shim::Btm::DoSetEventFilter() {

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

  // TODO(cmanton) Actually set/clear event filter here

  return false;

void bluetooth::shim::Btm::SetLeGeneralDiscoverability() {

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

}



bool bluetooth::shim::Btm::SetClassicConnectibleOff() {

  return DoSetConnectible();

void bluetooth::shim::Btm::SetLeLimitedDiscoverability() {

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

}



bool bluetooth::shim::Btm::SetClassicConnectibleOn() {

  return DoSetConnectible();

void bluetooth::shim::Btm::SetLeDiscoverabilityOff() {

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

}



bool bluetooth::shim::Btm::SetLeConnectibleOff() { return DoSetConnectible(); }

DiscoverabilityState bluetooth::shim::Btm::GetLeDiscoverabilityState() const {

  DiscoverabilityState state{

      .mode = kDiscoverableModeOff,

      .interval = 0,

      .window = 0,

  };

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

  return state;

}



/**

 * Connectability

 */

void bluetooth::shim::Btm::SetClassicConnectibleOn() {

  bluetooth::shim::GetConnectability()->StartConnectability();

}



bool bluetooth::shim::Btm::SetLeConnectibleOn() { return DoSetConnectible(); }

void bluetooth::shim::Btm::SetClassicConnectibleOff() {

  bluetooth::shim::GetConnectability()->StopConnectability();

}



ConnectibilityState bluetooth::shim::Btm::GetClassicConnectibilityState()

ConnectabilityState bluetooth::shim::Btm::GetClassicConnectabilityState()

    const {

  return le_connectibility_state_;

  ConnectabilityState state;

  bluetooth::shim::GetPage()->GetScanActivity(state.interval, state.window);



  if (bluetooth::shim::GetConnectability()->IsConnectable()) {

    state.mode = BTM_CONNECTABLE;

  } else {

    state.mode = BTM_NON_CONNECTABLE;

  }

  return state;

}



ConnectibilityState bluetooth::shim::Btm::GetLeConnectibilityState() const {

  return classic_connectibility_state_;

void bluetooth::shim::Btm::SetInterlacedPageScan() {

  bluetooth::shim::GetPage()->SetInterlacedScan();

}



bool bluetooth::shim::Btm::StartInquiry() {

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

  return false;

void bluetooth::shim::Btm::SetStandardPageScan() {

  bluetooth::shim::GetPage()->SetStandardScan();

}



// private

bool bluetooth::shim::Btm::DoSetConnectible() {

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

  // TODO(cmanton) Actually set/clear connectibility here

  return false;

void bluetooth::shim::Btm::SetLeConnectibleOn() {

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

}



void bluetooth::shim::Btm::SetLeConnectibleOff() {

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

}



ConnectabilityState bluetooth::shim::Btm::GetLeConnectabilityState() const {

  ConnectabilityState state{

      .mode = kConnectibleModeOff,

      .interval = 0,

      .window = 0,

  };

  LOG_WARN(LOG_TAG, "UNIMPLEMENTED %s", __func__);

  return state;

}

system/main/shim/btm.h

+59 −39
Original line number Diff line number Diff line
@@ -18,14 +18,22 @@ 


#include <cstdint>

#include <unordered_map>

#include <vector>



#include "stack/include/l2c_api.h"

#include "stack/include/btm_api_types.h"



/* Discoverable modes */

static constexpr int kDiscoverableModeOff = 0;

static constexpr int kLimitedDiscoverableMode = 1;

static constexpr int kGeneralDiscoverableMode = 2;



/* Inquiry modes */

// NOTE: The inquiry general/limited are reversed from the discoverability

// constants

static constexpr int kInquiryModeOff = 0;

static constexpr int kGeneralInquiryMode = 1;

static constexpr int kLimitedInquiryMode = 2;



/* Connectable modes */

static constexpr int kConnectibleModeOff = 0;

static constexpr int kConnectibleModeOn = 1;
@@ -46,10 +54,10 @@ static constexpr int kFilterOnAddress = 2; 


using DiscoverabilityState = struct {

  int mode;

  uint16_t window;

  uint16_t interval;

  uint16_t window;

};

using ConnectibilityState = DiscoverabilityState;

using ConnectabilityState = DiscoverabilityState;



namespace bluetooth {

namespace shim {
@@ -58,56 +66,68 @@ class Btm { 
 public:

  Btm();



  void SetLeDiscoverabilityOff();

  void SetLeLimitedDiscoverability();

  void SetLeGeneralDiscoverability();



  void SetClassicDiscoverabilityOff();

  void SetClassicLimitedDiscoverability(uint16_t window, uint16_t interval);

  void SetClassicGeneralDiscoverability(uint16_t window, uint16_t interval);



  bool IsInterlacedScanSupported() const;

  // Callbacks

  void OnInquiryResult(std::vector<const uint8_t> result);

  void OnInquiryResultWithRssi(std::vector<const uint8_t> result);

  void OnExtendedInquiryResult(std::vector<const uint8_t> result);

  void OnInquiryComplete(uint16_t status);



  bool SetInterlacedInquiryScan();

  bool SetStandardInquiryScan();

  // Inquiry API

  bool SetInquiryFilter(uint8_t mode, uint8_t type, tBTM_INQ_FILT_COND data);

  void SetFilterInquiryOnAddress();

  void SetFilterInquiryOnDevice();

  void ClearInquiryFilter();



  bool SetInterlacedPageScan();

  bool SetStandardPageScan();

  bool SetStandardInquiryResultMode();

  bool SetInquiryWithRssiResultMode();

  bool SetExtendedInquiryResultMode();



  bool SetStandardInquiryMode();

  bool SetInquiryModeWithRssi();

  bool SetExtendedInquiryMode();

  void SetInterlacedInquiryScan();

  void SetStandardInquiryScan();

  bool IsInterlacedScanSupported() const;



  bool StartInquiry(uint8_t mode, uint8_t duration, uint8_t max_responses);

  void CancelInquiry();

  bool IsInquiryActive() const;

  bool CancelPeriodicInquiry();

  bool ClearInquiryFilter();

  bool SetFilterInquiryOnDevice();

  bool SetFilterInquiryOnAddress();

  bool IsGeneralInquiryActive() const;

  bool IsLimitedInquiryActive() const;



  bool StartPeriodicInquiry(uint8_t mode, uint8_t duration,

                            uint8_t max_responses, uint16_t max_delay,

                            uint16_t min_delay,

                            tBTM_INQ_RESULTS_CB* p_results_cb);

  void CancelPeriodicInquiry();



  void SetClassicGeneralDiscoverability(uint16_t window, uint16_t interval);

  void SetClassicLimitedDiscoverability(uint16_t window, uint16_t interval);

  void SetClassicDiscoverabilityOff();

  DiscoverabilityState GetClassicDiscoverabilityState() const;

  DiscoverabilityState GetLeDiscoverabilityState() const;



  ConnectibilityState GetClassicConnectibilityState() const;

  ConnectibilityState GetLeConnectibilityState() const;

  void SetLeGeneralDiscoverability();

  void SetLeLimitedDiscoverability();

  void SetLeDiscoverabilityOff();

  DiscoverabilityState GetLeDiscoverabilityState() const;



  bool SetClassicConnectibleOff();

  bool SetClassicConnectibleOn();

  bool SetLeConnectibleOff();

  bool SetLeConnectibleOn();

  void SetClassicConnectibleOn();

  void SetClassicConnectibleOff();

  ConnectabilityState GetClassicConnectabilityState() const;

  void SetInterlacedPageScan();

  void SetStandardPageScan();



  bool StartInquiry();

  void SetLeConnectibleOn();

  void SetLeConnectibleOff();

  ConnectabilityState GetLeConnectabilityState() const;



 private:

  DiscoverabilityState classic_;

  DiscoverabilityState le_;

  //  DiscoverabilityState classic_;

  //  DiscoverabilityState le_;



  ConnectibilityState classic_connectibility_state_;

  ConnectibilityState le_connectibility_state_;

  //  ConnectabilityState classic_connectibility_state_;

  //  ConnectabilityState le_connectibility_state_;



  bool DoSetEventFilter();

  bool DoSetConnectible();

  void DoSetDiscoverability();

  bool DoSetInquiryMode();

  //  bool DoSetEventFilter();

  //  void DoSetDiscoverability();

  //  bool DoSetInquiryMode();

};



}  // namespace shim

system/main/shim/btm_api.cc

+237 −155

File changed.

Preview size limit exceeded, changes collapsed.

system/main/shim/btm_api.h

+31 −0
Original line number Diff line number Diff line
@@ -2750,5 +2750,36 @@ tBTM_STATUS BTM_BleSetDefaultPhy(uint8_t all_phys, uint8_t tx_phys, 
void BTM_BleSetPhy(const RawAddress& bd_addr, uint8_t tx_phys, uint8_t rx_phys,

                   uint16_t phy_options);



void BTM_LE_PF_local_name(tBTM_BLE_SCAN_COND_OP action,

                          tBTM_BLE_PF_FILT_INDEX filt_index,

                          std::vector<uint8_t> name, tBTM_BLE_PF_CFG_CBACK cb);



void BTM_LE_PF_srvc_data(tBTM_BLE_SCAN_COND_OP action,

                         tBTM_BLE_PF_FILT_INDEX filt_index);



void BTM_LE_PF_manu_data(tBTM_BLE_SCAN_COND_OP action,

                         tBTM_BLE_PF_FILT_INDEX filt_index, uint16_t company_id,

                         uint16_t company_id_mask, std::vector<uint8_t> data,

                         std::vector<uint8_t> data_mask,

                         tBTM_BLE_PF_CFG_CBACK cb);



void BTM_LE_PF_srvc_data_pattern(tBTM_BLE_SCAN_COND_OP action,

                                 tBTM_BLE_PF_FILT_INDEX filt_index,

                                 std::vector<uint8_t> data,

                                 std::vector<uint8_t> data_mask,

                                 tBTM_BLE_PF_CFG_CBACK cb);



void BTM_LE_PF_addr_filter(tBTM_BLE_SCAN_COND_OP action,

                           tBTM_BLE_PF_FILT_INDEX filt_index, tBLE_BD_ADDR addr,

                           tBTM_BLE_PF_CFG_CBACK cb);



void BTM_LE_PF_uuid_filter(tBTM_BLE_SCAN_COND_OP action,

                           tBTM_BLE_PF_FILT_INDEX filt_index,

                           tBTM_BLE_PF_COND_TYPE filter_type,

                           const bluetooth::Uuid& uuid,

                           tBTM_BLE_PF_LOGIC_TYPE cond_logic,

                           const bluetooth::Uuid& uuid_mask,

                           tBTM_BLE_PF_CFG_CBACK cb);



}  // namespace shim

}  // namespace bluetooth

system/main/shim/entry.cc

+16 −0
Original line number Diff line number Diff line
@@ -34,6 +34,22 @@ bluetooth::shim::IController* bluetooth::shim::GetController() { 
  return GetGabeldorscheStack()->GetController();

}



bluetooth::shim::IConnectability* bluetooth::shim::GetConnectability() {

  return GetGabeldorscheStack()->GetConnectability();

}



bluetooth::shim::IDiscoverability* bluetooth::shim::GetDiscoverability() {

  return GetGabeldorscheStack()->GetDiscoverability();

}



bluetooth::shim::IInquiry* bluetooth::shim::GetInquiry() {

  return GetGabeldorscheStack()->GetInquiry();

}



bluetooth::shim::IHciLayer* bluetooth::shim::GetHciLayer() {

  return GetGabeldorscheStack()->GetHciLayer();

}



bluetooth::shim::IPage* bluetooth::shim::GetPage() {

  return GetGabeldorscheStack()->GetPage();

}