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

Commit 56a709bc authored by Chris Manton's avatar Chris Manton
Browse files

Restructure inquiry shim API 

Bug: 142061208
Test: Verified inquiry on crosshatch settings

Change-Id: I22bb4c9acba3f7dc43e3cdbf62ec051da0919bee
parent 0101aa06

system/gd/shim/iinquiry.h

+11 −16
Original line number Diff line number Diff line
@@ -29,19 +29,25 @@ using InquiryResultCallback = std::function<void(std::vector<const uint8_t> data 
using InquiryResultWithRssiCallback = std::function<void(std::vector<const uint8_t> data)>;

using ExtendedInquiryResultCallback = std::function<void(std::vector<const uint8_t> data)>;

using InquiryCompleteCallback = std::function<void(uint16_t status)>;

using InquiryCancelCompleteCallback = std::function<void(uint8_t mode)>;



struct LegacyInquiryCallbacks {

  InquiryResultCallback result_callback;

  InquiryResultWithRssiCallback result_with_rssi_callback;

  ExtendedInquiryResultCallback extended_result_callback;

  InquiryCompleteCallback complete_callback;

};



struct IInquiry {

  virtual void StartGeneralInquiry(uint8_t duration, uint8_t max_responses) = 0;

  virtual void StartLimitedInquiry(uint8_t duration, uint8_t max_responses) = 0;

  virtual void StartGeneralInquiry(uint8_t duration, uint8_t max_responses, LegacyInquiryCallbacks callbacks) = 0;

  virtual void StartLimitedInquiry(uint8_t duration, uint8_t max_responses, LegacyInquiryCallbacks callbacks) = 0;

  virtual void StopInquiry() = 0;

  virtual bool IsGeneralInquiryActive() const = 0;

  virtual bool IsLimitedInquiryActive() const = 0;



  virtual void StartGeneralPeriodicInquiry(uint8_t duration, uint8_t max_responses, uint16_t max_delay,

                                           uint16_t min_delay) = 0;

                                           uint16_t min_delay, LegacyInquiryCallbacks callbacks) = 0;

  virtual void StartLimitedPeriodicInquiry(uint8_t duration, uint8_t max_responses, uint16_t max_delay,

                                           uint16_t min_delay) = 0;

                                           uint16_t min_delay, LegacyInquiryCallbacks callbacks) = 0;

  virtual void StopPeriodicInquiry() = 0;

  virtual bool IsGeneralPeriodicInquiryActive() const = 0;

  virtual bool IsLimitedPeriodicInquiryActive() const = 0;
@@ -56,17 +62,6 @@ struct IInquiry { 
  virtual void SetInquiryWithRssiResultMode() = 0;

  virtual void SetExtendedInquiryResultMode() = 0;



  virtual void RegisterInquiryResult(InquiryResultCallback callback) = 0;

  virtual void UnregisterInquiryResult() = 0;

  virtual void RegisterInquiryResultWithRssi(InquiryResultWithRssiCallback callback) = 0;

  virtual void UnregisterInquiryResultWithRssi() = 0;

  virtual void RegisterExtendedInquiryResult(ExtendedInquiryResultCallback callback) = 0;

  virtual void UnregisterExtendedInquiryResult() = 0;

  virtual void RegisterInquiryComplete(InquiryCompleteCallback callback) = 0;

  virtual void UnregisterInquiryComplete() = 0;

  virtual void RegisterInquiryCancelComplete(InquiryCancelCompleteCallback callback) = 0;

  virtual void UnregisterInquiryCancelComplete() = 0;



  virtual ~IInquiry() {}

};

system/gd/shim/inquiry.cc

+30 −138
Original line number Diff line number Diff line
@@ -38,22 +38,10 @@ struct Inquiry::impl { 
  void ExtendedResult(hci::ExtendedInquiryResultView view);

  void Complete(hci::ErrorCode status);



  void RegisterInquiryResult(InquiryResultCallback callback);

  void UnregisterInquiryResult();

  void RegisterInquiryResultWithRssi(InquiryResultWithRssiCallback callback);

  void UnregisterInquiryResultWithRssi();

  void RegisterExtendedInquiryResult(ExtendedInquiryResultCallback callback);

  void UnregisterExtendedInquiryResult();

  void RegisterInquiryComplete(InquiryCompleteCallback callback);

  void UnregisterInquiryComplete();

  void RegisterInquiryCancelComplete(InquiryCancelCompleteCallback callback);

  void UnregisterInquiryCancelComplete();



  InquiryResultCallback shim_result_callback_;

  InquiryResultWithRssiCallback shim_result_with_rssi_callback_;

  ExtendedInquiryResultCallback shim_extended_result_callback_;

  InquiryCompleteCallback shim_complete_callback_;

  InquiryCancelCompleteCallback shim_cancel_complete_callback_;

  void RegisterInquiryCallbacks(LegacyInquiryCallbacks callbacks);

  void UnregisterInquiryCallbacks();



  LegacyInquiryCallbacks callbacks_;



  neighbor::InquiryModule* module_{nullptr};
@@ -74,98 +62,36 @@ const ModuleFactory Inquiry::Factory = ModuleFactory([]() { return new Inquiry() 


void Inquiry::impl::Result(hci::InquiryResultView view) {

  ASSERT(view.size() >= sizeof(uint16_t));

  ASSERT(shim_result_callback_ != nullptr);

  ASSERT(callbacks_.result_callback != nullptr);

  std::vector<const uint8_t> v(view.begin() + sizeof(uint16_t), view.end());

  shim_result_callback_(v);

  callbacks_.result_callback(v);

}



void Inquiry::impl::ResultWithRssi(hci::InquiryResultWithRssiView view) {

  ASSERT(view.size() >= sizeof(uint16_t));

  ASSERT(shim_result_with_rssi_callback_ != nullptr);

  ASSERT(callbacks_.result_with_rssi_callback != nullptr);

  std::vector<const uint8_t> v(view.begin() + sizeof(uint16_t), view.end());

  shim_result_with_rssi_callback_(v);

  callbacks_.result_with_rssi_callback(v);

}



void Inquiry::impl::ExtendedResult(hci::ExtendedInquiryResultView view) {

  ASSERT(view.size() >= sizeof(uint16_t));

  ASSERT(shim_extended_result_callback_ != nullptr);

  ASSERT(callbacks_.extended_result_callback != nullptr);

  std::vector<const uint8_t> v(view.begin() + sizeof(uint16_t), view.end());

  shim_extended_result_callback_(v);

  callbacks_.extended_result_callback(v);

}



void Inquiry::impl::Complete(hci::ErrorCode status) {

  ASSERT(shim_complete_callback_ != nullptr);

  shim_complete_callback_(static_cast<uint16_t>(status));

}



void Inquiry::impl::RegisterInquiryResult(shim::InquiryResultCallback callback) {

  if (shim_result_callback_ != nullptr) {

    LOG_WARN("Registering inquiry result without unregistering");

  }

  shim_result_callback_ = callback;

}



void Inquiry::impl::UnregisterInquiryResult() {

  if (shim_result_callback_ == nullptr) {

    LOG_WARN("Unregistering inquiry result without registering");

  }

  shim_result_callback_ = nullptr;

}



void Inquiry::impl::RegisterInquiryResultWithRssi(shim::InquiryResultWithRssiCallback callback) {

  if (shim_result_with_rssi_callback_ != nullptr) {

    LOG_WARN("Registering inquiry result with rssi without unregistering");

  }

  shim_result_with_rssi_callback_ = callback;

}



void Inquiry::impl::UnregisterInquiryResultWithRssi() {

  if (shim_result_with_rssi_callback_ == nullptr) {

    LOG_WARN("Unregistering inquiry result with rssi without registering");

  }

  shim_result_with_rssi_callback_ = nullptr;

}



void Inquiry::impl::RegisterExtendedInquiryResult(shim::ExtendedInquiryResultCallback callback) {

  if (shim_result_with_rssi_callback_ != nullptr) {

    LOG_WARN("Registering extended inquiry result without unregistering");

  }

  shim_extended_result_callback_ = callback;

}



void Inquiry::impl::UnregisterExtendedInquiryResult() {

  if (shim_extended_result_callback_ == nullptr) {

    LOG_WARN("Unregistering extended inquiry result without registering");

  }

  shim_extended_result_callback_ = nullptr;

}



void Inquiry::impl::RegisterInquiryComplete(shim::InquiryCompleteCallback callback) {

  if (shim_result_with_rssi_callback_ != nullptr) {

    LOG_WARN("Registering inquiry complete without unregistering");

  }

  shim_complete_callback_ = callback;

  ASSERT(callbacks_.complete_callback != nullptr);

  callbacks_.complete_callback(static_cast<uint16_t>(status));

}



void Inquiry::impl::UnregisterInquiryComplete() {

  if (shim_result_with_rssi_callback_ == nullptr) {

    LOG_WARN("Unregistering inquiry complete without registering");

  }

  shim_complete_callback_ = nullptr;

void Inquiry::impl::RegisterInquiryCallbacks(LegacyInquiryCallbacks callbacks) {

  callbacks_ = callbacks;

}



void Inquiry::impl::RegisterInquiryCancelComplete(shim::InquiryCancelCompleteCallback callback) {

  if (shim_cancel_complete_callback_ != nullptr) {

    LOG_WARN("Registering inquiry cancel complete without unregistering");

  }

  shim_cancel_complete_callback_ = callback;

}



void Inquiry::impl::UnregisterInquiryCancelComplete() {

  if (shim_cancel_complete_callback_ == nullptr) {

    LOG_WARN("Unregistering inquiry cancel complete without registering");

  }

  shim_cancel_complete_callback_ = nullptr;

void Inquiry::impl::UnregisterInquiryCallbacks() {

  callbacks_ = {{}, {}, {}, {}};

}



Inquiry::impl::impl(neighbor::InquiryModule* inquiry_module) : module_(inquiry_module) {
@@ -182,12 +108,14 @@ Inquiry::impl::~impl() { 
  module_->UnregisterCallbacks();

}



void Inquiry::StartGeneralInquiry(uint8_t inquiry_length, uint8_t num_responses) {

void Inquiry::StartGeneralInquiry(uint8_t inquiry_length, uint8_t num_responses, LegacyInquiryCallbacks callbacks) {

  pimpl_->RegisterInquiryCallbacks(callbacks);

  pimpl_->general_inquiry_active_ = true;

  return pimpl_->module_->StartGeneralInquiry(inquiry_length, num_responses);

  pimpl_->module_->StartGeneralInquiry(inquiry_length, num_responses);

}



void Inquiry::StartLimitedInquiry(uint8_t inquiry_length, uint8_t num_responses) {

void Inquiry::StartLimitedInquiry(uint8_t inquiry_length, uint8_t num_responses, LegacyInquiryCallbacks callbacks) {

  pimpl_->RegisterInquiryCallbacks(callbacks);

  pimpl_->limited_inquiry_active_ = true;

  return pimpl_->module_->StartLimitedInquiry(inquiry_length, num_responses);

}
@@ -199,7 +127,8 @@ void Inquiry::StopInquiry() { 
  }

  pimpl_->limited_inquiry_active_ = false;

  pimpl_->general_inquiry_active_ = false;

  return pimpl_->module_->StopInquiry();

  pimpl_->module_->StopInquiry();

  pimpl_->UnregisterInquiryCallbacks();

}



bool Inquiry::IsGeneralInquiryActive() const {
@@ -211,13 +140,15 @@ bool Inquiry::IsLimitedInquiryActive() const { 
}



void Inquiry::StartGeneralPeriodicInquiry(uint8_t inquiry_length, uint8_t num_responses, uint16_t max_delay,

                                          uint16_t min_delay) {

                                          uint16_t min_delay, LegacyInquiryCallbacks callbacks) {

  pimpl_->RegisterInquiryCallbacks(callbacks);

  pimpl_->general_periodic_inquiry_active_ = true;

  return pimpl_->module_->StartGeneralPeriodicInquiry(inquiry_length, num_responses, max_delay, min_delay);

  pimpl_->module_->StartGeneralPeriodicInquiry(inquiry_length, num_responses, max_delay, min_delay);

}



void Inquiry::StartLimitedPeriodicInquiry(uint8_t inquiry_length, uint8_t num_responses, uint16_t max_delay,

                                          uint16_t min_delay) {

                                          uint16_t min_delay, LegacyInquiryCallbacks callbacks) {

  pimpl_->RegisterInquiryCallbacks(callbacks);

  pimpl_->limited_periodic_inquiry_active_ = true;

  return pimpl_->module_->StartLimitedPeriodicInquiry(inquiry_length, num_responses, max_delay, min_delay);

}
@@ -225,7 +156,8 @@ void Inquiry::StartLimitedPeriodicInquiry(uint8_t inquiry_length, uint8_t num_re 
void Inquiry::StopPeriodicInquiry() {

  pimpl_->limited_periodic_inquiry_active_ = false;

  pimpl_->general_periodic_inquiry_active_ = false;

  return pimpl_->module_->StopPeriodicInquiry();

  pimpl_->module_->StopPeriodicInquiry();

  pimpl_->UnregisterInquiryCallbacks();

}



bool Inquiry::IsGeneralPeriodicInquiryActive() const {
@@ -267,46 +199,6 @@ void Inquiry::SetExtendedInquiryResultMode() { 
  pimpl_->module_->SetExtendedInquiryResultMode();

}



void Inquiry::RegisterInquiryResult(shim::InquiryResultCallback callback) {

  pimpl_->RegisterInquiryResult(callback);

}



void Inquiry::UnregisterInquiryResult() {

  pimpl_->UnregisterInquiryResult();

}



void Inquiry::RegisterInquiryResultWithRssi(shim::InquiryResultWithRssiCallback callback) {

  pimpl_->RegisterInquiryResultWithRssi(callback);

}



void Inquiry::UnregisterInquiryResultWithRssi() {

  pimpl_->UnregisterInquiryResultWithRssi();

}



void Inquiry::RegisterExtendedInquiryResult(shim::ExtendedInquiryResultCallback callback) {

  pimpl_->RegisterExtendedInquiryResult(callback);

}



void Inquiry::UnregisterExtendedInquiryResult() {

  pimpl_->UnregisterExtendedInquiryResult();

}



void Inquiry::RegisterInquiryComplete(InquiryCompleteCallback callback) {

  pimpl_->RegisterInquiryComplete(callback);

}



void Inquiry::UnregisterInquiryComplete() {

  pimpl_->UnregisterInquiryComplete();

}



void Inquiry::RegisterInquiryCancelComplete(InquiryCancelCompleteCallback callback) {

  pimpl_->RegisterInquiryCancelComplete(callback);

}



void Inquiry::UnregisterInquiryCancelComplete() {

  pimpl_->UnregisterInquiryCancelComplete();

}



/**

 * Module methods

 */

system/gd/shim/inquiry.h

+6 −17
Original line number Diff line number Diff line
@@ -26,16 +26,16 @@ namespace shim { 


class Inquiry : public bluetooth::Module, public bluetooth::shim::IInquiry {

 public:

  void StartGeneralInquiry(uint8_t duration, uint8_t max_responses) override;

  void StartLimitedInquiry(uint8_t duration, uint8_t max_responses) override;

  void StartGeneralInquiry(uint8_t duration, uint8_t max_responses, LegacyInquiryCallbacks callbacks) override;

  void StartLimitedInquiry(uint8_t duration, uint8_t max_responses, LegacyInquiryCallbacks callbacks) override;

  void StopInquiry() override;

  bool IsGeneralInquiryActive() const override;

  bool IsLimitedInquiryActive() const override;



  void StartGeneralPeriodicInquiry(uint8_t duration, uint8_t max_responses, uint16_t max_delay,

                                   uint16_t min_delay) override;

  void StartLimitedPeriodicInquiry(uint8_t duration, uint8_t max_responses, uint16_t max_delay,

                                   uint16_t min_delay) override;

  void StartGeneralPeriodicInquiry(uint8_t duration, uint8_t max_responses, uint16_t max_delay, uint16_t min_delay,

                                   LegacyInquiryCallbacks callbacks) override;

  void StartLimitedPeriodicInquiry(uint8_t duration, uint8_t max_responses, uint16_t max_delay, uint16_t min_delay,

                                   LegacyInquiryCallbacks callbacks) override;

  void StopPeriodicInquiry() override;

  bool IsGeneralPeriodicInquiryActive() const override;

  bool IsLimitedPeriodicInquiryActive() const override;
@@ -50,17 +50,6 @@ class Inquiry : public bluetooth::Module, public bluetooth::shim::IInquiry { 
  void SetInquiryWithRssiResultMode() override;

  void SetExtendedInquiryResultMode() override;



  void RegisterInquiryResult(InquiryResultCallback callback) override;

  void UnregisterInquiryResult() override;

  void RegisterInquiryResultWithRssi(InquiryResultWithRssiCallback callback) override;

  void UnregisterInquiryResultWithRssi() override;

  void RegisterExtendedInquiryResult(ExtendedInquiryResultCallback callback) override;

  void UnregisterExtendedInquiryResult() override;

  void RegisterInquiryComplete(InquiryCompleteCallback callback) override;

  void UnregisterInquiryComplete() override;

  void RegisterInquiryCancelComplete(InquiryCancelCompleteCallback callback) override;

  void UnregisterInquiryCancelComplete() override;



  Inquiry() = default;

  ~Inquiry() = default;

system/main/shim/btm.cc

+33 −22
Original line number Diff line number Diff line
@@ -85,6 +85,7 @@ void bluetooth::shim::Btm::OnExtendedInquiryResult( 
}



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

  LOG_DEBUG(LOG_TAG, "%s status:%hu mode:%d", __func__, status, inquiry_mode_);

  btm_process_inq_complete((status == 0) ? (BTM_SUCCESS) : (BTM_ERR_PROCESSING),

                           static_cast<uint8_t>(inquiry_mode_));

}
@@ -152,39 +153,37 @@ bool bluetooth::shim::Btm::StartInquiry(uint8_t mode, uint8_t duration, 
    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));

    case kGeneralInquiryMode: {

      LegacyInquiryCallbacks legacy_inquiry_callbacks{

          .result_callback =

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

          .result_with_rssi_callback = std::bind(&Btm::OnInquiryResultWithRssi,

                                                 this, std::placeholders::_1),

          .extended_result_callback = std::bind(&Btm::OnExtendedInquiryResult,

                                                this, std::placeholders::_1),

          .complete_callback =

              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);

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

            duration, max_responses, legacy_inquiry_callbacks);

      } 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);

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

            duration, max_responses, legacy_inquiry_callbacks);

      }

      break;

    } break;



    default:

      LOG_WARN(LOG_TAG, "%s Unknown inquiry mode:%d", __func__, mode);
@@ -222,19 +221,31 @@ bool bluetooth::shim::Btm::StartPeriodicInquiry( 
      break;



    case kLimitedInquiryMode:

    case kGeneralInquiryMode:

    case kGeneralInquiryMode: {

      LegacyInquiryCallbacks legacy_inquiry_callbacks{

          .result_callback =

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

          .result_with_rssi_callback = std::bind(&Btm::OnInquiryResultWithRssi,

                                                 this, std::placeholders::_1),

          .extended_result_callback = std::bind(&Btm::OnExtendedInquiryResult,

                                                this, std::placeholders::_1),

          .complete_callback =

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

      };

      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);

            duration, max_responses, max_delay, min_delay,

            legacy_inquiry_callbacks);

      } else {

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

                  __func__);

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

            duration, max_responses, max_delay, min_delay);

            duration, max_responses, max_delay, min_delay,

            legacy_inquiry_callbacks);

      }

      break;

    } break;



    default:

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