Restructure inquiry shim API am: 56a709bcdc am: c060a36690 (7a993f09) · Commits · e / os / android_packages_modules_Bluetooth

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