Merge changes I4184f82e,If7223eaf (51fad0a7) · Commits · e / os / android_packages_modules_Bluetooth

system/main/shim/Android.bp

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -9,6 +9,7 @@ filegroup {
	"l2c_api.cc",		"l2c_api.cc",
	"l2cap.cc",		"l2cap.cc",
	"shim.cc",		"shim.cc",
			"timer.cc",
	]		]
	}		}

	@@ -16,6 +17,7 @@ filegroup {
	name: "LibBluetoothShimTestSources",		name: "LibBluetoothShimTestSources",
	srcs: [		srcs: [
	"l2cap_test.cc",		"l2cap_test.cc",
			"timer_test.cc",
	]		]
	}		}

system/main/shim/btm.cc

+46 −17

Original line number	Original line	Diff line number	Diff line
	@@ -69,6 +69,22 @@ extern void btm_api_process_extended_inquiry_result(
	uint16_t clock_offset, int8_t rssi, const uint8_t* eir_data,		uint16_t clock_offset, int8_t rssi, const uint8_t* eir_data,
	size_t eir_len);		size_t eir_len);

			void bluetooth::shim::Btm::StartUp(bluetooth::shim::Btm* btm) {
			CHECK(btm != nullptr);
			CHECK(btm->observing_timer_ == nullptr);
			CHECK(btm->scanning_timer_ == nullptr);
			btm->observing_timer_ = new bluetooth::shim::Timer("observing_timer");
			btm->scanning_timer_ = new bluetooth::shim::Timer("scanning_timer");
			}

			void bluetooth::shim::Btm::ShutDown(bluetooth::shim::Btm* btm) {
			CHECK(btm != nullptr);
			CHECK(btm->observing_timer_ != nullptr);
			CHECK(btm->scanning_timer_ != nullptr);
			delete btm->scanning_timer_;
			delete btm->observing_timer_;
			}

	void bluetooth::shim::Btm::OnInquiryResult(std::string string_address,		void bluetooth::shim::Btm::OnInquiryResult(std::string string_address,
	uint8_t page_scan_rep_mode,		uint8_t page_scan_rep_mode,
	std::string string_class_of_device,		std::string string_class_of_device,
	@@ -109,14 +125,15 @@ void bluetooth::shim::Btm::OnExtendedInquiryResult(
	}		}

	void bluetooth::shim::Btm::OnInquiryComplete(uint16_t status) {		void bluetooth::shim::Btm::OnInquiryComplete(uint16_t status) {
	LOG_DEBUG(LOG_TAG, "%s status:%hu mode:%d", __func__, status, inquiry_mode_);		legacy_inquiry_complete_callback_(
	btm_process_inq_complete((status == 0) ? (BTM_SUCCESS) : (BTM_ERR_PROCESSING),		(status == 0) ? (BTM_SUCCESS) : (BTM_ERR_PROCESSING),
	static_cast<uint8_t>(inquiry_mode_));		active_inquiry_mode_);
			active_inquiry_mode_ = kInquiryModeOff;
	}		}

	bool bluetooth::shim::Btm::SetInquiryFilter(uint8_t mode, uint8_t type,		bool bluetooth::shim::Btm::SetInquiryFilter(uint8_t mode, uint8_t type,
	tBTM_INQ_FILT_COND data) {		tBTM_INQ_FILT_COND data) {
	switch (static_cast<int>(mode)) {		switch (mode) {
	case kInquiryModeOff:		case kInquiryModeOff:
	break;		break;
	case kLimitedInquiryMode:		case kLimitedInquiryMode:
	@@ -171,12 +188,14 @@ bool bluetooth::shim::Btm::IsInterlacedScanSupported() const {
	/**		/**
	* One shot inquiry		* One shot inquiry
	*/		*/
	bool bluetooth::shim::Btm::StartInquiry(uint8_t mode, uint8_t duration,		bool bluetooth::shim::Btm::StartInquiry(
	uint8_t max_responses) {		uint8_t mode, uint8_t duration, uint8_t max_responses,
	switch (static_cast<int>(mode)) {		LegacyInquiryCompleteCallback legacy_inquiry_complete_callback) {
			switch (mode) {
	case kInquiryModeOff:		case kInquiryModeOff:
	LOG_DEBUG(LOG_TAG, "%s Stopping inquiry mode", __func__);		LOG_DEBUG(LOG_TAG, "%s Stopping inquiry mode", __func__);
	bluetooth::shim::GetInquiry()->StopInquiry();		bluetooth::shim::GetInquiry()->StopInquiry();
			active_inquiry_mode_ = kInquiryModeOff;
	break;		break;

	case kLimitedInquiryMode:		case kLimitedInquiryMode:
	@@ -206,6 +225,7 @@ bool bluetooth::shim::Btm::StartInquiry(uint8_t mode, uint8_t duration,
	__func__, duration, max_responses);		__func__, duration, max_responses);
	bluetooth::shim::GetInquiry()->StartLimitedInquiry(		bluetooth::shim::GetInquiry()->StartLimitedInquiry(
	duration, max_responses, legacy_inquiry_callbacks);		duration, max_responses, legacy_inquiry_callbacks);
			active_inquiry_mode_ = kLimitedInquiryMode;
	} else {		} else {
	LOG_DEBUG(		LOG_DEBUG(
	LOG_TAG,		LOG_TAG,
	@@ -213,6 +233,7 @@ bool bluetooth::shim::Btm::StartInquiry(uint8_t mode, uint8_t duration,
	__func__, duration, max_responses);		__func__, duration, max_responses);
	bluetooth::shim::GetInquiry()->StartGeneralInquiry(		bluetooth::shim::GetInquiry()->StartGeneralInquiry(
	duration, max_responses, legacy_inquiry_callbacks);		duration, max_responses, legacy_inquiry_callbacks);
			legacy_inquiry_complete_callback_ = legacy_inquiry_complete_callback;
	}		}
	} break;		} break;

	@@ -220,7 +241,6 @@ bool bluetooth::shim::Btm::StartInquiry(uint8_t mode, uint8_t duration,
	LOG_WARN(LOG_TAG, "%s Unknown inquiry mode:%d", __func__, mode);		LOG_WARN(LOG_TAG, "%s Unknown inquiry mode:%d", __func__, mode);
	return false;		return false;
	}		}
	inquiry_mode_ = static_cast<int>(mode);
	return true;		return true;
	}		}

	@@ -487,7 +507,7 @@ bluetooth::shim::Btm::CancelAllReadRemoteDeviceName() {
	}		}
	return bluetooth::shim::BTM_UNKNOWN_ADDR;		return bluetooth::shim::BTM_UNKNOWN_ADDR;
	}		}
	LOG_INFO(LOG_TAG,		LOG_WARN(LOG_TAG,
	"%s Cancelling classic remote device name without one in progress",		"%s Cancelling classic remote device name without one in progress",
	__func__);		__func__);
	return bluetooth::shim::BTM_WRONG_MODE;		return bluetooth::shim::BTM_WRONG_MODE;
	@@ -517,18 +537,30 @@ void bluetooth::shim::Btm::StopActiveScanning() {
	bluetooth::shim::GetScanning()->StopScanning();		bluetooth::shim::GetScanning()->StopScanning();
	}		}

			void bluetooth::shim::Btm::SetScanningTimer(uint64_t duration_ms,
			std::function<void()> func) {
			scanning_timer_->Set(duration_ms, func);
			}

			void bluetooth::shim::Btm::CancelScanningTimer() { scanning_timer_->Cancel(); }

	void bluetooth::shim::Btm::StartObserving() { StartScanning(kPassiveScanning); }		void bluetooth::shim::Btm::StartObserving() { StartScanning(kPassiveScanning); }

	void bluetooth::shim::Btm::StopObserving() {		void bluetooth::shim::Btm::StopObserving() { StopActiveScanning(); }
	bluetooth::shim::GetScanning()->StopScanning();
			void bluetooth::shim::Btm::SetObservingTimer(uint64_t duration_ms,
			std::function<void()> func) {
			observing_timer_->Set(duration_ms, func);
			}

			void bluetooth::shim::Btm::CancelObservingTimer() {
			observing_timer_->Cancel();
	}		}

	void bluetooth::shim::Btm::StartScanning(bool use_active_scanning) {		void bluetooth::shim::Btm::StartScanning(bool use_active_scanning) {
	bluetooth::shim::GetScanning()->StartScanning(		bluetooth::shim::GetScanning()->StartScanning(
	use_active_scanning,		use_active_scanning,
	[](AdvertisingReport report) {		[](AdvertisingReport report) {
	LOG_INFO(LOG_TAG, "%s Received advertising report from device:%s",
	__func__, report.string_address.c_str());
	RawAddress raw_address;		RawAddress raw_address;
	RawAddress::FromString(report.string_address, raw_address);		RawAddress::FromString(report.string_address, raw_address);

	@@ -545,9 +577,6 @@ void bluetooth::shim::Btm::StartScanning(bool use_active_scanning) {
	__func__, report.string_address.c_str());		__func__, report.string_address.c_str());
	},		},
	[](ExtendedAdvertisingReport report) {		[](ExtendedAdvertisingReport report) {
	LOG_INFO(LOG_TAG,
	"%s Received extended advertising report from device:%s",
	__func__, report.string_address.c_str());
	RawAddress raw_address;		RawAddress raw_address;
	RawAddress::FromString(report.string_address, raw_address);		RawAddress::FromString(report.string_address, raw_address);
	if (report.address_type != BLE_ADDR_ANONYMOUS) {		if (report.address_type != BLE_ADDR_ANONYMOUS) {
	@@ -559,7 +588,7 @@ void bluetooth::shim::Btm::StartScanning(bool use_active_scanning) {
	kTxPowerInformationNotPresent, report.rssi,		kTxPowerInformationNotPresent, report.rssi,
	kNotPeriodicAdvertisement, report.len, report.data);		kNotPeriodicAdvertisement, report.len, report.data);
	},		},
	[]() { LOG_INFO(LOG_TAG, "%s Scanning timeout", __func__); });		[]() { LOG_WARN(LOG_TAG, "%s Scanning timeout", __func__); });
	}		}

	size_t bluetooth::shim::Btm::GetNumberOfAdvertisingInstances() const {		size_t bluetooth::shim::Btm::GetNumberOfAdvertisingInstances() const {

system/main/shim/btm.h

+29 −6

Original line number	Original line	Diff line number	Diff line
	@@ -18,10 +18,14 @@

	#include <cstddef>		#include <cstddef>
	#include <cstdint>		#include <cstdint>
			#include <functional>
	#include <mutex>		#include <mutex>
	#include <unordered_map>		#include <unordered_map>
	#include <vector>		#include <vector>

			#include "main/shim/timer.h"
			#include "osi/include/alarm.h"
			#include "osi/include/future.h"
	#include "stack/include/btm_api_types.h"		#include "stack/include/btm_api_types.h"

	//		//
	@@ -34,9 +38,9 @@ static constexpr int kLimitedDiscoverableMode = 1; // BTM_LIMITED_DISCOVERABLE
	static constexpr int kGeneralDiscoverableMode = 2; // BTM_GENERAL_DISCOVERABLE		static constexpr int kGeneralDiscoverableMode = 2; // BTM_GENERAL_DISCOVERABLE

	/* Inquiry modes */		/* Inquiry modes */
	static constexpr int kInquiryModeOff = 0; // BTM_INQUIRY_NONE		static constexpr uint8_t kInquiryModeOff = 0; // BTM_INQUIRY_NONE
	static constexpr int kGeneralInquiryMode = 1; // BTM_GENERAL_INQUIRY		static constexpr uint8_t kGeneralInquiryMode = 1; // BTM_GENERAL_INQUIRY
	static constexpr int kLimitedInquiryMode = 2; // BTM_LIMITED_INQUIRY		static constexpr uint8_t kLimitedInquiryMode = 2; // BTM_LIMITED_INQUIRY

	/* Connectable modes */		/* Connectable modes */
	static constexpr int kConnectibleModeOff = 0; // BTM_NON_CONNECTABLE		static constexpr int kConnectibleModeOff = 0; // BTM_NON_CONNECTABLE
	@@ -61,6 +65,9 @@ static constexpr uint8_t kPhyConnectionLe1M = 0x01;
	static constexpr uint8_t kPhyConnectionLe2M = 0x02;		static constexpr uint8_t kPhyConnectionLe2M = 0x02;
	static constexpr uint8_t kPhyConnectionLeCoded = 0x03;		static constexpr uint8_t kPhyConnectionLeCoded = 0x03;

			using LegacyInquiryCompleteCallback =
			std::function<void(uint16_t status, uint8_t inquiry_mode)>;

	using DiscoverabilityState = struct {		using DiscoverabilityState = struct {
	int mode;		int mode;
	uint16_t interval;		uint16_t interval;
	@@ -161,7 +168,8 @@ class Btm {
	void SetStandardInquiryScan();		void SetStandardInquiryScan();
	bool IsInterlacedScanSupported() const;		bool IsInterlacedScanSupported() const;

	bool StartInquiry(uint8_t mode, uint8_t duration, uint8_t max_responses);		bool StartInquiry(uint8_t mode, uint8_t duration, uint8_t max_responses,
			LegacyInquiryCompleteCallback inquiry_complete_callback);
	void CancelInquiry();		void CancelInquiry();
	bool IsInquiryActive() const;		bool IsInquiryActive() const;
	bool IsGeneralInquiryActive() const;		bool IsGeneralInquiryActive() const;
	@@ -219,15 +227,30 @@ class Btm {

	size_t GetNumberOfAdvertisingInstances() const;		size_t GetNumberOfAdvertisingInstances() const;

			void SetObservingTimer(uint64_t duration_ms, std::function<void()>);
			void CancelObservingTimer();
			void SetScanningTimer(uint64_t duration_ms, std::function<void()>);
			void CancelScanningTimer();

			// Lifecycle
			static void StartUp(Btm* btm);
			static void ShutDown(Btm* btm);

	private:		private:
	ReadRemoteName le_read_remote_name_;		ReadRemoteName le_read_remote_name_;
	ReadRemoteName classic_read_remote_name_;		ReadRemoteName classic_read_remote_name_;

			Timer* observing_timer_{nullptr};
			Timer* scanning_timer_{nullptr};

			LegacyInquiryCompleteCallback legacy_inquiry_complete_callback_{};

			uint8_t active_inquiry_mode_ = 0;

	// TODO(cmanton) abort if there is no classic acl link up		// TODO(cmanton) abort if there is no classic acl link up
	bool CheckClassicAclLink(const RawAddress& raw_address) { return true; }		bool CheckClassicAclLink(const RawAddress& raw_address) { return true; }
	bool CheckLeAclLink(const RawAddress& raw_address) { return true; }		bool CheckLeAclLink(const RawAddress& raw_address) { return true; }
	void StartScanning(bool use_active_scanning);		void StartScanning(bool use_active_scanning);

	int inquiry_mode_ = 0;
	};		};

	} // namespace shim		} // namespace shim

system/main/shim/btm_api.cc

+175 −2

Original line number	Original line	Diff line number	Diff line
	@@ -18,10 +18,15 @@

	#include <base/callback.h>		#include <base/callback.h>

			#include <mutex>

	#include "common/time_util.h"		#include "common/time_util.h"
	#include "device/include/controller.h"		#include "device/include/controller.h"
	#include "main/shim/btm.h"		#include "main/shim/btm.h"
	#include "main/shim/btm_api.h"		#include "main/shim/btm_api.h"
			#include "main/shim/controller.h"
			#include "main/shim/shim.h"
			#include "main/shim/timer.h"
	#include "osi/include/log.h"		#include "osi/include/log.h"
	#include "stack/btm/btm_int_types.h"		#include "stack/btm/btm_int_types.h"
	#include "types/class_of_device.h"		#include "types/class_of_device.h"
	@@ -31,17 +36,46 @@ static bluetooth::shim::Btm shim_btm;

	/**		/**
	* Legacy bluetooth module global control block state		* 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;		extern tBTM_CB btm_cb;
			std::mutex btm_cb_mutex_;

	extern bool btm_inq_find_bdaddr(const RawAddress& p_bda);		extern 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_find(const RawAddress& raw_address);
	extern tINQ_DB_ENT* btm_inq_db_new(const RawAddress& p_bda);		extern tINQ_DB_ENT* btm_inq_db_new(const RawAddress& p_bda);

			/**
			* Legacy bluetooth btm stack entry points
			*/
	extern void btm_acl_update_busy_level(tBTM_BLI_EVENT event);		extern void btm_acl_update_busy_level(tBTM_BLI_EVENT event);
	extern void btm_clear_all_pending_le_entry(void);		extern void btm_clear_all_pending_le_entry(void);
	extern void btm_clr_inq_result_flt(void);		extern void btm_clr_inq_result_flt(void);
	extern void btm_set_eir_uuid(uint8_t* p_eir, tBTM_INQ_RESULTS* p_results);		extern void btm_set_eir_uuid(uint8_t* p_eir, tBTM_INQ_RESULTS* p_results);
	extern void btm_sort_inq_result(void);		extern void btm_sort_inq_result(void);
			extern void btm_process_inq_complete(uint8_t status, uint8_t result_type);

			static future_t* btm_module_start_up(void) {
			bluetooth::shim::Btm::StartUp(&shim_btm);
			return kReturnImmediate;
			}

			static future_t* btm_module_shut_down(void) {
			bluetooth::shim::Btm::ShutDown(&shim_btm);
			return kReturnImmediate;
			}

			EXPORT_SYMBOL extern const module_t gd_shim_btm_module = {
			.name = GD_SHIM_BTM_MODULE,
			.init = kUnusedModuleApi,
			.start_up = btm_module_start_up,
			.shut_down = btm_module_shut_down,
			.clean_up = kUnusedModuleApi,
			.dependencies = {kUnusedModuleDependencies}};

	static bool max_responses_reached() {		static bool max_responses_reached() {
	return (btm_cb.btm_inq_vars.inqparms.max_resps &&		return (btm_cb.btm_inq_vars.inqparms.max_resps &&
	@@ -271,7 +305,19 @@ tBTM_STATUS bluetooth::shim::BTM_StartInquiry(tBTM_INQ_PARMS* p_inqparms,
	CHECK(p_results_cb != nullptr);		CHECK(p_results_cb != nullptr);
	CHECK(p_cmpl_cb != nullptr);		CHECK(p_cmpl_cb != nullptr);

			std::lock_guard<std::mutex> lock(btm_cb_mutex_);

	btm_cb.btm_inq_vars.inq_cmpl_info.num_resp = 0;		btm_cb.btm_inq_vars.inq_cmpl_info.num_resp = 0;
			btm_cb.btm_inq_vars.scan_type = INQ_GENERAL;

			shim_btm.StartActiveScanning();
			if (p_inqparms->duration != 0) {
			shim_btm.SetScanningTimer(p_inqparms->duration * 1000, []() {
			LOG_INFO(LOG_TAG, "%s scanning timeout popped", __func__);
			std::lock_guard<std::mutex> lock(btm_cb_mutex_);
			shim_btm.StopActiveScanning();
			});
			}

	shim_btm.StartActiveScanning();		shim_btm.StartActiveScanning();

	@@ -282,8 +328,49 @@ tBTM_STATUS bluetooth::shim::BTM_StartInquiry(tBTM_INQ_PARMS* p_inqparms,
	return BTM_ERR_PROCESSING;		return BTM_ERR_PROCESSING;
	}		}

	if (!shim_btm.StartInquiry(classic_mode, p_inqparms->duration,		if (!shim_btm.StartInquiry(
	p_inqparms->max_resps)) {		classic_mode, p_inqparms->duration, p_inqparms->max_resps,
			[](uint16_t status, uint8_t inquiry_mode) {
			LOG_DEBUG(LOG_TAG,
			"%s Inquiry is complete status:%hd inquiry_mode:%hhd",
			__func__, status, inquiry_mode);
			btm_cb.btm_inq_vars.inqparms.mode &= ~(inquiry_mode);

			btm_acl_update_busy_level(BTM_BLI_INQ_DONE_EVT);
			if (btm_cb.btm_inq_vars.inq_active) {
			btm_cb.btm_inq_vars.inq_cmpl_info.status = status;
			btm_clear_all_pending_le_entry();
			btm_cb.btm_inq_vars.state = BTM_INQ_INACTIVE_STATE;

			/* Increment so the start of a next inquiry has a new count */
			btm_cb.btm_inq_vars.inq_counter++;

			btm_clr_inq_result_flt();

			if ((status == BTM_SUCCESS) &&
			controller_get_interface()
			->supports_rssi_with_inquiry_results()) {
			btm_sort_inq_result();
			}

			btm_cb.btm_inq_vars.inq_active = BTM_INQUIRY_INACTIVE;
			btm_cb.btm_inq_vars.p_inq_results_cb = nullptr;
			btm_cb.btm_inq_vars.p_inq_cmpl_cb = nullptr;

			if (btm_cb.btm_inq_vars.p_inq_cmpl_cb != nullptr) {
			LOG_DEBUG(LOG_TAG,
			"%s Sending inquiry completion to upper layer",
			__func__);
			(btm_cb.btm_inq_vars.p_inq_cmpl_cb)(
			(tBTM_INQUIRY_CMPL*)&btm_cb.btm_inq_vars.inq_cmpl_info);
			btm_cb.btm_inq_vars.p_inq_cmpl_cb = nullptr;
			}
			}
			if (btm_cb.btm_inq_vars.inqparms.mode == BTM_INQUIRY_NONE &&
			btm_cb.btm_inq_vars.scan_type == INQ_GENERAL) {
			btm_cb.btm_inq_vars.scan_type = INQ_NONE;
			}
			})) {
	LOG_WARN(LOG_TAG, "%s Unable to start inquiry", __func__);		LOG_WARN(LOG_TAG, "%s Unable to start inquiry", __func__);
	return BTM_ERR_PROCESSING;		return BTM_ERR_PROCESSING;
	}		}
	@@ -398,6 +485,8 @@ tBTM_STATUS bluetooth::shim::BTM_BleObserve(bool start, uint8_t duration_sec,
	CHECK(p_results_cb != nullptr);		CHECK(p_results_cb != nullptr);
	CHECK(p_cmpl_cb != nullptr);		CHECK(p_cmpl_cb != nullptr);

			std::lock_guard<std::mutex> lock(btm_cb_mutex_);

	if (btm_cb.ble_ctr_cb.scan_activity & BTM_LE_OBSERVE_ACTIVE) {		if (btm_cb.ble_ctr_cb.scan_activity & BTM_LE_OBSERVE_ACTIVE) {
	LOG_WARN(LOG_TAG, "%s Observing already active", __func__);		LOG_WARN(LOG_TAG, "%s Observing already active", __func__);
	return BTM_WRONG_MODE;		return BTM_WRONG_MODE;
	@@ -407,10 +496,54 @@ tBTM_STATUS bluetooth::shim::BTM_BleObserve(bool start, uint8_t duration_sec,
	btm_cb.ble_ctr_cb.p_obs_cmpl_cb = p_cmpl_cb;		btm_cb.ble_ctr_cb.p_obs_cmpl_cb = p_cmpl_cb;
	shim_btm.StartObserving();		shim_btm.StartObserving();
	btm_cb.ble_ctr_cb.scan_activity \|= BTM_LE_OBSERVE_ACTIVE;		btm_cb.ble_ctr_cb.scan_activity \|= BTM_LE_OBSERVE_ACTIVE;

			if (duration_sec != 0) {
			shim_btm.SetObservingTimer(duration_sec * 1000, []() {
			LOG_DEBUG(LOG_TAG, "%s observing timeout popped", __func__);

			shim_btm.CancelObservingTimer();
			shim_btm.StopObserving();

			std::lock_guard<std::mutex> lock(btm_cb_mutex_);
			btm_cb.ble_ctr_cb.scan_activity &= ~BTM_LE_OBSERVE_ACTIVE;

			if (btm_cb.ble_ctr_cb.p_obs_cmpl_cb) {
			(btm_cb.ble_ctr_cb.p_obs_cmpl_cb)(&btm_cb.btm_inq_vars.inq_cmpl_info);
			}
			btm_cb.ble_ctr_cb.p_obs_results_cb = nullptr;
			btm_cb.ble_ctr_cb.p_obs_cmpl_cb = nullptr;

			btm_cb.btm_inq_vars.inqparms.mode &= ~(BTM_BLE_INQUIRY_MASK);
			btm_cb.btm_inq_vars.scan_type = INQ_NONE;

			btm_acl_update_busy_level(BTM_BLI_INQ_DONE_EVT);

			btm_clear_all_pending_le_entry();
			btm_cb.btm_inq_vars.state = BTM_INQ_INACTIVE_STATE;

			btm_cb.btm_inq_vars.inq_counter++;
			btm_clr_inq_result_flt();
			btm_sort_inq_result();

			btm_cb.btm_inq_vars.inq_active = BTM_INQUIRY_INACTIVE;
			btm_cb.btm_inq_vars.p_inq_results_cb = NULL;
			btm_cb.btm_inq_vars.p_inq_cmpl_cb = NULL;

			if (btm_cb.btm_inq_vars.p_inq_cmpl_cb) {
			(btm_cb.btm_inq_vars.p_inq_cmpl_cb)(
			(tBTM_INQUIRY_CMPL*)&btm_cb.btm_inq_vars.inq_cmpl_info);
			btm_cb.btm_inq_vars.p_inq_cmpl_cb = nullptr;
			}
			});
			}
	} else {		} else {
			std::lock_guard<std::mutex> lock(btm_cb_mutex_);

	if (!(btm_cb.ble_ctr_cb.scan_activity & BTM_LE_OBSERVE_ACTIVE)) {		if (!(btm_cb.ble_ctr_cb.scan_activity & BTM_LE_OBSERVE_ACTIVE)) {
	LOG_WARN(LOG_TAG, "%s Observing already inactive", __func__);		LOG_WARN(LOG_TAG, "%s Observing already inactive", __func__);
	}		}
			shim_btm.CancelObservingTimer();
			shim_btm.StopObserving();
	btm_cb.ble_ctr_cb.scan_activity &= ~BTM_LE_OBSERVE_ACTIVE;		btm_cb.ble_ctr_cb.scan_activity &= ~BTM_LE_OBSERVE_ACTIVE;
	shim_btm.StopObserving();		shim_btm.StopObserving();
	if (btm_cb.ble_ctr_cb.p_obs_cmpl_cb) {		if (btm_cb.ble_ctr_cb.p_obs_cmpl_cb) {
	@@ -531,7 +664,47 @@ uint16_t bluetooth::shim::BTM_IsInquiryActive(void) {
	}		}

	tBTM_STATUS bluetooth::shim::BTM_CancelInquiry(void) {		tBTM_STATUS bluetooth::shim::BTM_CancelInquiry(void) {
			LOG_DEBUG(LOG_TAG, "%s Cancel inquiry", __func__);
	shim_btm.CancelInquiry();		shim_btm.CancelInquiry();

			btm_cb.btm_inq_vars.state = BTM_INQ_INACTIVE_STATE;
			btm_clr_inq_result_flt();

			shim_btm.CancelScanningTimer();
			shim_btm.StopActiveScanning();

			btm_cb.ble_ctr_cb.scan_activity &= ~BTM_BLE_INQUIRY_MASK;

			btm_cb.btm_inq_vars.inqparms.mode &=
			~(btm_cb.btm_inq_vars.inqparms.mode & BTM_BLE_INQUIRY_MASK);

			btm_acl_update_busy_level(BTM_BLI_INQ_DONE_EVT);
			/* Ignore any stray or late complete messages if the inquiry is not active */
			if (btm_cb.btm_inq_vars.inq_active) {
			btm_cb.btm_inq_vars.inq_cmpl_info.status = BTM_SUCCESS;
			btm_clear_all_pending_le_entry();

			if (controller_get_interface()->supports_rssi_with_inquiry_results()) {
			btm_sort_inq_result();
			}

			btm_cb.btm_inq_vars.inq_active = BTM_INQUIRY_INACTIVE;
			btm_cb.btm_inq_vars.p_inq_results_cb = nullptr;
			btm_cb.btm_inq_vars.p_inq_cmpl_cb = nullptr;
			btm_cb.btm_inq_vars.inq_counter++;

			if (btm_cb.btm_inq_vars.p_inq_cmpl_cb != nullptr) {
			LOG_DEBUG(LOG_TAG, "%s Sending cancel inquiry completion to upper layer",
			__func__);
			(btm_cb.btm_inq_vars.p_inq_cmpl_cb)(
			(tBTM_INQUIRY_CMPL*)&btm_cb.btm_inq_vars.inq_cmpl_info);
			btm_cb.btm_inq_vars.p_inq_cmpl_cb = nullptr;
			}
			}
			if (btm_cb.btm_inq_vars.inqparms.mode == BTM_INQUIRY_NONE &&
			btm_cb.btm_inq_vars.scan_type == INQ_GENERAL) {
			btm_cb.btm_inq_vars.scan_type = INQ_NONE;
			}
	return BTM_SUCCESS;		return BTM_SUCCESS;
	}		}

system/main/shim/shim.cc

+7 −5

Original line number	Original line	Diff line number	Diff line
	@@ -35,23 +35,25 @@ future_t* ShimModuleStartUp() {
	bt_shim_thread.StartUp();		bt_shim_thread.StartUp();
	CHECK(bt_shim_thread.IsRunning())		CHECK(bt_shim_thread.IsRunning())
	<< "Unable to start bt shim message loop thread.";		<< "Unable to start bt shim message loop thread.";
			module_start_up(get_module(GD_SHIM_BTM_MODULE));
	bluetooth::shim::StartGabeldorscheStack();		bluetooth::shim::StartGabeldorscheStack();
	return nullptr;		return kReturnImmediate;
	}		}

	future_t* ShimModuleShutDown() {		future_t* ShimModuleShutDown() {
	bluetooth::shim::StopGabeldorscheStack();		bluetooth::shim::StopGabeldorscheStack();
			module_shut_down(get_module(GD_SHIM_BTM_MODULE));
	bt_shim_thread.ShutDown();		bt_shim_thread.ShutDown();
	return nullptr;		return kReturnImmediate;
	}		}

	EXPORT_SYMBOL extern const module_t gd_shim_module = {		EXPORT_SYMBOL extern const module_t gd_shim_module = {
	.name = GD_SHIM_MODULE,		.name = GD_SHIM_MODULE,
	.init = nullptr,		.init = kUnusedModuleApi,
	.start_up = ShimModuleStartUp,		.start_up = ShimModuleStartUp,
	.shut_down = ShimModuleShutDown,		.shut_down = ShimModuleShutDown,
	.clean_up = NULL,		.clean_up = kUnusedModuleApi,
	.dependencies = {NULL}};		.dependencies = {kUnusedModuleDependencies}};

	void bluetooth::shim::Post(base::OnceClosure task) {		void bluetooth::shim::Post(base::OnceClosure task) {
	bt_shim_thread.DoInThread(FROM_HERE, std::move(task));		bt_shim_thread.DoInThread(FROM_HERE, std::move(task));