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
Loading
Loading
Loading
Loading
+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;
}
+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
+237 −155

File changed.

Preview size limit exceeded, changes collapsed.

+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
+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();
}
Loading