Merge "Read APCF extended features" into tm-qpr-dev (1575f43a) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/csis/csis_client.cc

+9 −2

Original line number	Diff line number	Diff line
		@@ -1169,9 +1169,16 @@ class CsisClientImpl : public CsisClient {
		}

		void CsisActiveObserverSet(bool enable) {
		LOG(INFO) << __func__ << " CSIS Discovery SET: " << enable;

		bool is_ad_type_filter_supported =
		bluetooth::shim::is_ad_type_filter_supported();
		LOG_INFO("CSIS Discovery SET: %d, is_ad_type_filter_supported: %d", enable,
		is_ad_type_filter_supported);
		if (is_ad_type_filter_supported) {
		bluetooth::shim::set_ad_type_rsi_filter(enable);
		} else {
		bluetooth::shim::set_empty_filter(enable);
		}

		BTA_DmBleCsisObserve(
		enable, [](tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH* p_data) {
		/* If there's no instance we are most likely shutting

system/gd/hci/hci_packets.pdl

+17 −0

Original line number	Diff line number	Diff line
		@@ -4840,6 +4840,7 @@ enum ApcfOpcode : 8 {
		MANUFACTURER_DATA = 0x06,
		SERVICE_DATA = 0x07,
		AD_TYPE = 0x08,
		READ_EXTENDED_FEATURES = 0xFF,
		}

		// https://source.android.com/devices/bluetooth/hci_requirements#advertising-packet-content-filter
		@@ -5007,6 +5008,22 @@ packet LeAdvFilterADTypeComplete : LeAdvFilterComplete (apcf_opcode = AD_TYPE) {
		apcf_available_spaces : 8,
		}

		packet LeAdvFilterReadExtendedFeatures : LeAdvFilter (apcf_opcode = READ_EXTENDED_FEATURES) {
		}

		test LeAdvFilterReadExtendedFeatures {
		"\x57\xfd\x01\xff",
		}

		packet LeAdvFilterReadExtendedFeaturesComplete : LeAdvFilterComplete (apcf_opcode = READ_EXTENDED_FEATURES) {
		ad_type_filter : 1,
		_reserved_ : 15,
		}

		test LeAdvFilterReadExtendedFeaturesComplete {
		"\x0e\x07\x01\x57\xfd\x00\xff\x01\x00",
		}

		packet LeEnergyInfo : VendorCommand (op_code = LE_ENERGY_INFO) {
		}

system/gd/hci/le_scanning_manager.cc

+102 −62

Original line number	Diff line number	Diff line
		@@ -136,7 +136,7 @@ class AdvertisingCache {
		};

		class NullScanningCallback : public ScanningCallback {
		void OnScannerRegistered(const bluetooth::hci::Uuid app_uuid, ScannerId scanner_id, ScanningStatus status) override {
		void OnScannerRegistered(const Uuid app_uuid, ScannerId scanner_id, ScanningStatus status) override {
		LOG_INFO("OnScannerRegistered in NullScanningCallback");
		}
		void OnSetScannerParameterComplete(ScannerId scanner_id, ScanningStatus status) override {
		@@ -222,7 +222,7 @@ struct BatchScanConfig {
		ScannerId ref_value;
		};

		struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback {
		struct LeScanningManager::impl : public LeAddressManagerCallback {
		impl(Module* module) : module_(module), le_scanning_interface_(nullptr) {}

		~impl() {
		@@ -233,10 +233,10 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback

		void start(
		os::Handler* handler,
		hci::HciLayer* hci_layer,
		hci::Controller* controller,
		hci::AclManager* acl_manager,
		hci::VendorSpecificEventManager* vendor_specific_event_manager,
		HciLayer* hci_layer,
		Controller* controller,
		AclManager* acl_manager,
		VendorSpecificEventManager* vendor_specific_event_manager,
		storage::StorageModule* storage_module) {
		module_handler_ = handler;
		hci_layer_ = hci_layer;
		@@ -259,12 +259,17 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		} else {
		api_type_ = ScanApiType::LEGACY;
		}
		is_filter_support_ = controller_->IsSupported(OpCode::LE_ADV_FILTER);
		is_batch_scan_support_ = controller->IsSupported(OpCode::LE_BATCH_SCAN);
		is_periodic_advertising_sync_transfer_sender_support_ =
		is_filter_supported_ = controller_->IsSupported(OpCode::LE_ADV_FILTER);
		if (is_filter_supported_) {
		le_scanning_interface_->EnqueueCommand(
		LeAdvFilterReadExtendedFeaturesBuilder::Create(),
		module_handler_->BindOnceOn(this, &impl::on_apcf_read_extended_features_complete));
		}
		is_batch_scan_supported_ = controller->IsSupported(OpCode::LE_BATCH_SCAN);
		is_periodic_advertising_sync_transfer_sender_supported_ =
		controller_->SupportsBlePeriodicAdvertisingSyncTransferSender();
		total_num_of_advt_tracked_ = controller->GetVendorCapabilities().total_num_of_advt_tracked_;
		if (is_batch_scan_support_) {
		if (is_batch_scan_supported_) {
		vendor_specific_event_manager_->RegisterEventHandler(
		VseSubeventCode::BLE_THRESHOLD, handler->BindOn(this, &LeScanningManager::impl::on_storage_threshold_breach));
		vendor_specific_event_manager_->RegisterEventHandler(
		@@ -284,7 +289,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		for (auto subevent_code : LeScanningEvents) {
		hci_layer_->UnregisterLeEventHandler(subevent_code);
		}
		if (is_batch_scan_support_) {
		if (is_batch_scan_supported_) {
		// TODO implete vse module
		// hci_layer_->UnregisterVesEventHandler(VseSubeventCode::BLE_THRESHOLD);
		// hci_layer_->UnregisterVesEventHandler(VseSubeventCode::BLE_TRACKING);
		@@ -297,35 +302,35 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback

		void handle_scan_results(LeMetaEventView event) {
		switch (event.GetSubeventCode()) {
		case hci::SubeventCode::ADVERTISING_REPORT:
		case SubeventCode::ADVERTISING_REPORT:
		handle_advertising_report(LeAdvertisingReportView::Create(event));
		break;
		case hci::SubeventCode::DIRECTED_ADVERTISING_REPORT:
		case SubeventCode::DIRECTED_ADVERTISING_REPORT:
		handle_directed_advertising_report(LeDirectedAdvertisingReportView::Create(event));
		break;
		case hci::SubeventCode::EXTENDED_ADVERTISING_REPORT:
		case SubeventCode::EXTENDED_ADVERTISING_REPORT:
		handle_extended_advertising_report(LeExtendedAdvertisingReportView::Create(event));
		break;
		case hci::SubeventCode::PERIODIC_ADVERTISING_SYNC_ESTABLISHED:
		case SubeventCode::PERIODIC_ADVERTISING_SYNC_ESTABLISHED:
		LePeriodicAdvertisingSyncEstablishedView::Create(event);
		periodic_sync_manager_.HandleLePeriodicAdvertisingSyncEstablished(
		LePeriodicAdvertisingSyncEstablishedView::Create(event));
		break;
		case hci::SubeventCode::PERIODIC_ADVERTISING_REPORT:
		case SubeventCode::PERIODIC_ADVERTISING_REPORT:
		periodic_sync_manager_.HandleLePeriodicAdvertisingReport(LePeriodicAdvertisingReportView::Create(event));
		break;
		case hci::SubeventCode::PERIODIC_ADVERTISING_SYNC_LOST:
		case SubeventCode::PERIODIC_ADVERTISING_SYNC_LOST:
		periodic_sync_manager_.HandleLePeriodicAdvertisingSyncLost(LePeriodicAdvertisingSyncLostView::Create(event));
		break;
		case hci::SubeventCode::PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED:
		case SubeventCode::PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED:
		periodic_sync_manager_.HandleLePeriodicAdvertisingSyncTransferReceived(
		LePeriodicAdvertisingSyncTransferReceivedView::Create(event));
		break;
		case hci::SubeventCode::SCAN_TIMEOUT:
		case SubeventCode::SCAN_TIMEOUT:
		scanning_callbacks_->OnTimeout();
		break;
		default:
		LOG_ALWAYS_FATAL("Unknown advertising subevent %s", hci::SubeventCodeText(event.GetSubeventCode()).c_str());
		LOG_ALWAYS_FATAL("Unknown advertising subevent %s", SubeventCodeText(event.GetSubeventCode()).c_str());
		}
		}

		@@ -361,21 +366,21 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		for (LeAdvertisingResponse report : reports) {
		uint16_t extended_event_type = 0;
		switch (report.event_type_) {
		case hci::AdvertisingEventType::ADV_IND:
		case AdvertisingEventType::ADV_IND:
		transform_to_extended_event_type(
		&extended_event_type, {.connectable = true, .scannable = true, .legacy = true});
		break;
		case hci::AdvertisingEventType::ADV_DIRECT_IND:
		case AdvertisingEventType::ADV_DIRECT_IND:
		transform_to_extended_event_type(
		&extended_event_type, {.connectable = true, .directed = true, .legacy = true});
		break;
		case hci::AdvertisingEventType::ADV_SCAN_IND:
		case AdvertisingEventType::ADV_SCAN_IND:
		transform_to_extended_event_type(&extended_event_type, {.scannable = true, .legacy = true});
		break;
		case hci::AdvertisingEventType::ADV_NONCONN_IND:
		case AdvertisingEventType::ADV_NONCONN_IND:
		transform_to_extended_event_type(&extended_event_type, {.legacy = true});
		break;
		case hci::AdvertisingEventType::SCAN_RESPONSE:
		case AdvertisingEventType::SCAN_RESPONSE:
		transform_to_extended_event_type(
		&extended_event_type, {.connectable = true, .scannable = true, .scan_response = true, .legacy = true});
		break;
		@@ -452,7 +457,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		int8_t tx_power,
		int8_t rssi,
		uint16_t periodic_advertising_interval,
		std::vector<bluetooth::hci::LengthAndData> advertising_data) {
		std::vector<LengthAndData> advertising_data) {
		bool is_scannable = event_type & (1 << kScannableBit);
		bool is_scan_response = event_type & (1 << kScanResponseBit);
		bool is_legacy = event_type & (1 << kLegacyBit);
		@@ -549,20 +554,21 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		switch (api_type_) {
		case ScanApiType::EXTENDED:
		le_scanning_interface_->EnqueueCommand(
		hci::LeSetExtendedScanParametersBuilder::Create(
		LeSetExtendedScanParametersBuilder::Create(
		own_address_type_, filter_policy_, phys_in_use, parameter_vector),
		module_handler_->BindOnceOn(this, &impl::on_set_scan_parameter_complete));
		break;
		case ScanApiType::ANDROID_HCI:
		le_scanning_interface_->EnqueueCommand(
		hci::LeExtendedScanParamsBuilder::Create(
		LeExtendedScanParamsBuilder::Create(
		le_scan_type_, interval_ms_, window_ms_, own_address_type_, filter_policy_),
		module_handler_->BindOnceOn(this, &impl::on_set_scan_parameter_complete));

		break;
		case ScanApiType::LEGACY:
		le_scanning_interface_->EnqueueCommand(
		hci::LeSetScanParametersBuilder::Create(

		LeSetScanParametersBuilder::Create(
		le_scan_type_, interval_ms_, window_ms_, own_address_type_, filter_policy_),
		module_handler_->BindOnceOn(this, &impl::on_set_scan_parameter_complete));
		break;
		@@ -635,14 +641,14 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		switch (api_type_) {
		case ScanApiType::EXTENDED:
		le_scanning_interface_->EnqueueCommand(
		hci::LeSetExtendedScanEnableBuilder::Create(
		LeSetExtendedScanEnableBuilder::Create(
		Enable::ENABLED, FilterDuplicates::DISABLED /* filter duplicates */, 0, 0),
		module_handler_->BindOnce(impl::check_status));
		break;
		case ScanApiType::ANDROID_HCI:
		case ScanApiType::LEGACY:
		le_scanning_interface_->EnqueueCommand(
		hci::LeSetScanEnableBuilder::Create(Enable::ENABLED, Enable::DISABLED /* filter duplicates */),
		LeSetScanEnableBuilder::Create(Enable::ENABLED, Enable::DISABLED /* filter duplicates */),
		module_handler_->BindOnce(impl::check_status));
		break;
		}
		@@ -658,14 +664,14 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		switch (api_type_) {
		case ScanApiType::EXTENDED:
		le_scanning_interface_->EnqueueCommand(
		hci::LeSetExtendedScanEnableBuilder::Create(
		LeSetExtendedScanEnableBuilder::Create(
		Enable::DISABLED, FilterDuplicates::DISABLED /* filter duplicates */, 0, 0),
		module_handler_->BindOnce(impl::check_status));
		break;
		case ScanApiType::ANDROID_HCI:
		case ScanApiType::LEGACY:
		le_scanning_interface_->EnqueueCommand(
		hci::LeSetScanEnableBuilder::Create(Enable::DISABLED, Enable::DISABLED /* filter duplicates */),
		LeSetScanEnableBuilder::Create(Enable::DISABLED, Enable::DISABLED /* filter duplicates */),
		module_handler_->BindOnce(impl::check_status));
		break;
		}
		@@ -704,7 +710,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}

		void scan_filter_enable(bool enable) {
		if (!is_filter_support_) {
		if (!is_filter_supported_) {
		LOG_WARN("Advertising filter is not supported");
		return;
		}
		@@ -728,7 +734,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback

		void scan_filter_parameter_setup(
		ApcfAction action, uint8_t filter_index, AdvertisingFilterParameter advertising_filter_parameter) {
		if (!is_filter_support_) {
		if (!is_filter_supported_) {
		LOG_WARN("Advertising filter is not supported");
		return;
		}
		@@ -791,7 +797,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}

		void scan_filter_add(uint8_t filter_index, std::vector<AdvertisingPacketContentFilterCommand> filters) {
		if (!is_filter_support_) {
		if (!is_filter_supported_) {
		LOG_WARN("Advertising filter is not supported");
		return;
		}
		@@ -1027,6 +1033,11 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		uint8_t ad_type,
		std::vector<uint8_t> data,
		std::vector<uint8_t> data_mask) {
		if (!is_ad_type_filter_supported_) {
		LOG_ERROR("AD type filter isn't supported");
		return;
		}

		if (data.size() != data_mask.size()) {
		LOG_ERROR("ad type mask should have the same length as ad type data");
		return;
		@@ -1051,7 +1062,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		uint8_t batch_scan_truncated_max,
		uint8_t batch_scan_notify_threshold,
		ScannerId scanner_id) {
		if (!is_batch_scan_support_) {
		if (!is_batch_scan_supported_) {
		LOG_WARN("Batch scan is not supported");
		return;
		}
		@@ -1078,7 +1089,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		uint32_t duty_cycle_scan_window_slots,
		uint32_t duty_cycle_scan_interval_slots,
		BatchScanDiscardRule batch_scan_discard_rule) {
		if (!is_batch_scan_support_) {
		if (!is_batch_scan_supported_) {
		LOG_WARN("Batch scan is not supported");
		return;
		}
		@@ -1102,7 +1113,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}

		void batch_scan_disable() {
		if (!is_batch_scan_support_) {
		if (!is_batch_scan_supported_) {
		LOG_WARN("Batch scan is not supported");
		return;
		}
		@@ -1119,7 +1130,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		uint32_t duty_cycle_scan_window_slots,
		uint32_t duty_cycle_scan_interval_slots,
		BatchScanDiscardRule batch_scan_discard_rule) {
		if (!is_batch_scan_support_) {
		if (!is_batch_scan_supported_) {
		LOG_WARN("Batch scan is not supported");
		return;
		}
		@@ -1161,7 +1172,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}

		void batch_scan_read_results(ScannerId scanner_id, uint16_t total_num_of_records, BatchScanMode scan_mode) {
		if (!is_batch_scan_support_) {
		if (!is_batch_scan_supported_) {
		LOG_WARN("Batch scan is not supported");
		int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE);
		scanning_callbacks_->OnBatchScanReports(scanner_id, status, 0, 0, {});
		@@ -1187,7 +1198,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback

		void start_sync(
		uint8_t sid, const AddressWithType& address_with_type, uint16_t skip, uint16_t timeout, int request_id) {
		if (!is_periodic_advertising_sync_transfer_sender_support_) {
		if (!is_periodic_advertising_sync_transfer_sender_supported_) {
		LOG_WARN("PAST sender not supported on this device");
		int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE);
		scanning_callbacks_->OnPeriodicSyncStarted(request_id, status, -1, sid, address_with_type, 0, 0);
		@@ -1204,7 +1215,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}

		void stop_sync(uint16_t handle) {
		if (!is_periodic_advertising_sync_transfer_sender_support_) {
		if (!is_periodic_advertising_sync_transfer_sender_supported_) {
		LOG_WARN("PAST sender not supported on this device");
		return;
		}
		@@ -1212,7 +1223,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}

		void cancel_create_sync(uint8_t sid, const Address& address) {
		if (!is_periodic_advertising_sync_transfer_sender_support_) {
		if (!is_periodic_advertising_sync_transfer_sender_supported_) {
		LOG_WARN("PAST sender not supported on this device");
		return;
		}
		@@ -1220,7 +1231,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}

		void transfer_sync(const Address& address, uint16_t service_data, uint16_t sync_handle, int pa_source) {
		if (!is_periodic_advertising_sync_transfer_sender_support_) {
		if (!is_periodic_advertising_sync_transfer_sender_supported_) {
		LOG_WARN("PAST sender not supported on this device");
		int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE);
		scanning_callbacks_->OnPeriodicSyncTransferred(pa_source, status, address);
		@@ -1237,7 +1248,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}

		void transfer_set_info(const Address& address, uint16_t service_data, uint8_t adv_handle, int pa_source) {
		if (!is_periodic_advertising_sync_transfer_sender_support_) {
		if (!is_periodic_advertising_sync_transfer_sender_supported_) {
		LOG_WARN("PAST sender not supported on this device");
		int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE);
		scanning_callbacks_->OnPeriodicSyncTransferred(pa_source, status, address);
		@@ -1254,7 +1265,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}

		void sync_tx_parameters(const Address& address, uint8_t mode, uint16_t skip, uint16_t timeout, int reg_id) {
		if (!is_periodic_advertising_sync_transfer_sender_support_) {
		if (!is_periodic_advertising_sync_transfer_sender_supported_) {
		LOG_WARN("PAST sender not supported on this device");
		int status = static_cast<int>(ErrorCode::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE);
		AddressWithType address_with_type(address, AddressType::RANDOM_DEVICE_ADDRESS);
		@@ -1288,6 +1299,10 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		periodic_sync_manager_.SetScanningCallback(scanning_callbacks_);
		}

		bool is_ad_type_filter_supported() {
		return is_ad_type_filter_supported_;
		}

		void on_set_scan_parameter_complete(CommandCompleteView view) {
		switch (view.GetCommandOpCode()) {
		case (OpCode::LE_SET_SCAN_PARAMETERS): {
		@@ -1413,6 +1428,26 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}
		}

		void on_apcf_read_extended_features_complete(CommandCompleteView view) {
		ASSERT(view.IsValid());
		auto status_view = LeAdvFilterCompleteView::Create(view);
		if (!status_view.IsValid()) {
		LOG_WARN("Can not get valid LeAdvFilterCompleteView, return");
		return;
		}
		if (status_view.GetStatus() != ErrorCode::SUCCESS) {
		LOG_WARN(
		"Got a Command complete %s, status %s",
		OpCodeText(view.GetCommandOpCode()).c_str(),
		ErrorCodeText(status_view.GetStatus()).c_str());
		return;
		}
		auto complete_view = LeAdvFilterReadExtendedFeaturesCompleteView::Create(status_view);
		ASSERT(complete_view.IsValid());
		is_ad_type_filter_supported_ = complete_view.GetAdTypeFilter() == 1;
		LOG_INFO("set is_ad_type_filter_supported_ to %d", is_ad_type_filter_supported_);
		}

		void on_batch_scan_complete(CommandCompleteView view) {
		ASSERT(view.IsValid());
		auto status_view = LeBatchScanCompleteView::Create(view);
		@@ -1539,13 +1574,13 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback

		Module* module_;
		os::Handler* module_handler_;
		hci::HciLayer* hci_layer_;
		hci::Controller* controller_;
		hci::AclManager* acl_manager_;
		hci::VendorSpecificEventManager* vendor_specific_event_manager_;
		HciLayer* hci_layer_;
		Controller* controller_;
		AclManager* acl_manager_;
		VendorSpecificEventManager* vendor_specific_event_manager_;
		storage::StorageModule* storage_module_;
		hci::LeScanningInterface* le_scanning_interface_;
		hci::LeAddressManager* le_address_manager_;
		LeScanningInterface* le_scanning_interface_;
		LeAddressManager* le_address_manager_;
		bool address_manager_registered_ = false;
		NullScanningCallback null_scanning_callback_;
		ScanningCallback* scanning_callbacks_ = &null_scanning_callback_;
		@@ -1555,9 +1590,10 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		bool scan_on_resume_ = false;
		bool paused_ = false;
		AdvertisingCache advertising_cache_;
		bool is_filter_support_ = false;
		bool is_batch_scan_support_ = false;
		bool is_periodic_advertising_sync_transfer_sender_support_ = false;
		bool is_filter_supported_ = false;
		bool is_ad_type_filter_supported_ = false;
		bool is_batch_scan_supported_ = false;
		bool is_periodic_advertising_sync_transfer_sender_supported_ = false;

		LeScanType le_scan_type_ = LeScanType::ACTIVE;
		uint32_t interval_ms_{1000};
		@@ -1598,18 +1634,18 @@ LeScanningManager::LeScanningManager() {
		}

		void LeScanningManager::ListDependencies(ModuleList* list) const {
		list->add<hci::HciLayer>();
		list->add<hci::VendorSpecificEventManager>();
		list->add<hci::Controller>();
		list->add<hci::AclManager>();
		list->add<HciLayer>();
		list->add<VendorSpecificEventManager>();
		list->add<Controller>();
		list->add<AclManager>();
		list->add<storage::StorageModule>();
		}

		void LeScanningManager::Start() {
		pimpl_->start(
		GetHandler(),
		GetDependency<hci::HciLayer>(),
		GetDependency<hci::Controller>(),
		GetDependency<HciLayer>(),
		GetDependency<Controller>(),
		GetDependency<AclManager>(),
		GetDependency<VendorSpecificEventManager>(),
		GetDependency<storage::StorageModule>());
		@@ -1727,5 +1763,9 @@ void LeScanningManager::RegisterScanningCallback(ScanningCallback* scanning_call
		CallOn(pimpl_.get(), &impl::register_scanning_callback, scanning_callback);
		}

		bool LeScanningManager::IsAdTypeFilterSupported() const {
		return pimpl_->is_ad_type_filter_supported();
		}

		} // namespace hci
		} // namespace bluetooth

system/gd/hci/le_scanning_manager.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -92,6 +92,8 @@ class LeScanningManager : public bluetooth::Module {

		virtual void RegisterScanningCallback(ScanningCallback* scanning_callback);

		virtual bool IsAdTypeFilterSupported() const;

		static const ModuleFactory Factory;

		protected:

system/gd/hci/le_scanning_manager_test.cc

+40 −18

Original line number	Diff line number	Diff line
		@@ -74,6 +74,7 @@ class TestHciLayer : public HciLayer {
		void EnqueueCommand(
		std::unique_ptr<CommandBuilder> command,
		common::ContextualOnceCallback<void(CommandStatusView)> on_status) override {
		std::lock_guard<std::mutex> lock(mutex_);
		command_queue_.push(std::move(command));
		command_status_callbacks.push_back(std::move(on_status));
		command_count_--;
		@@ -86,6 +87,7 @@ class TestHciLayer : public HciLayer {
		void EnqueueCommand(
		std::unique_ptr<CommandBuilder> command,
		common::ContextualOnceCallback<void(CommandCompleteView)> on_complete) override {
		std::lock_guard<std::mutex> lock(mutex_);
		command_queue_.push(std::move(command));
		command_complete_callbacks.push_back(std::move(on_complete));
		command_count_--;
		@@ -103,31 +105,21 @@ class TestHciLayer : public HciLayer {
		command_future_ = std::make_unique<std::future<void>>(command_promise_->get_future());
		}

		CommandView GetLastCommand() {
		if (command_queue_.size() == 0) {
		return empty_command_view_;
		}
		auto last = std::move(command_queue_.front());
		command_queue_.pop();
		return CommandView::Create(GetPacketView(std::move(last)));
		}

		CommandView GetCommand() {
		if (!command_queue_.empty()) {
		std::lock_guard<std::mutex> lock(mutex_);
		if (command_future_ != nullptr) {
		command_future_.reset();
		command_promise_.reset();
		}
		} else if (command_future_ != nullptr) {
		// Wait for EnqueueCommand if command_queue_ is empty
		if (command_queue_.empty() && command_future_ != nullptr) {
		command_future_->wait_for(std::chrono::milliseconds(1000));
		}

		std::lock_guard<std::mutex> lock(mutex_);
		if (command_queue_.empty()) {
		LOG_ERROR("Command queue is empty");
		return empty_command_view_;
		}
		CommandView command_packet_view = GetLastCommand();

		auto last = std::move(command_queue_.front());
		command_queue_.pop();
		CommandView command_packet_view = CommandView::Create(GetPacketView(std::move(last)));
		if (!command_packet_view.IsValid()) {
		LOG_ERROR("Got invalid command");
		return empty_command_view_;
		@@ -283,7 +275,12 @@ class LeScanningManagerTest : public ::testing::Test {
		fake_registry_.InjectTestModule(&AclManager::Factory, test_acl_manager_);
		client_handler_ = fake_registry_.GetTestModuleHandler(&HciLayer::Factory);
		ASSERT_NE(client_handler_, nullptr);
		if (is_filter_support_) {
		// Will send APCF read extended features command if APCF supported
		test_hci_layer_->SetCommandFuture(2);
		} else {
		test_hci_layer_->SetCommandFuture(1);
		}
		// configure_scan will be trigger by impl.start() and enqueue set scan parameter command
		fake_registry_.Start<LeScanningManager>(&thread_);
		le_scanning_manager =
		@@ -293,6 +290,7 @@ class LeScanningManagerTest : public ::testing::Test {
		}

		void TearDown() override {
		sync_client_handler();
		fake_registry_.SynchronizeModuleHandler(&LeScanningManager::Factory, std::chrono::milliseconds(20));
		fake_registry_.StopAll();
		}
		@@ -378,9 +376,13 @@ class LeAndroidHciScanningManagerTest : public LeScanningManagerTest {
		is_filter_support_ = true;
		is_batch_scan_support_ = true;
		LeScanningManagerTest::SetUp();
		sync_client_handler();
		}

		void HandleConfiguration() override {
		ASSERT_EQ(OpCode::LE_ADV_FILTER, test_hci_layer_->GetCommand().GetOpCode());
		test_hci_layer_->IncomingEvent(LeAdvFilterReadExtendedFeaturesCompleteBuilder::Create(1, ErrorCode::SUCCESS, 0x01));
		sync_client_handler();
		ASSERT_EQ(param_opcode_, test_hci_layer_->GetCommand().GetOpCode());
		test_hci_layer_->IncomingEvent(LeExtendedScanParamsCompleteBuilder::Create(1, ErrorCode::SUCCESS));
		}
		@@ -432,6 +434,22 @@ TEST_F(LeScanningManagerTest, start_scan_test) {
		test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({report}));
		}

		TEST_F(LeScanningManagerTest, is_ad_type_filter_supported_false_test) {
		ASSERT_FALSE(le_scanning_manager->IsAdTypeFilterSupported());
		}

		TEST_F(LeScanningManagerTest, scan_filter_add_ad_type_not_supported_test) {
		test_hci_layer_->SetCommandFuture(1);
		std::vector<AdvertisingPacketContentFilterCommand> filters = {};
		AdvertisingPacketContentFilterCommand filter{};
		filter.filter_type = ApcfFilterType::AD_TYPE;
		filter.ad_type = 0x09;
		filter.data = {0x12, 0x34, 0x56, 0x78};
		filter.data_mask = {0xff, 0xff, 0xff, 0xff};
		filters.push_back(filter);
		le_scanning_manager->ScanFilterAdd(0x01, filters);
		}

		TEST_F(LeAndroidHciScanningManagerTest, startup_teardown) {}

		TEST_F(LeAndroidHciScanningManagerTest, start_scan_test) {
		@@ -464,6 +482,10 @@ TEST_F(LeAndroidHciScanningManagerTest, start_scan_test) {
		test_hci_layer_->IncomingLeMetaEvent(LeAdvertisingReportBuilder::Create({report}));
		}

		TEST_F(LeAndroidHciScanningManagerTest, is_ad_type_filter_supported_true_test) {
		ASSERT_TRUE(le_scanning_manager->IsAdTypeFilterSupported());
		}

		TEST_F(LeAndroidHciScanningManagerTest, scan_filter_enable_test) {
		test_hci_layer_->SetCommandFuture(1);
		le_scanning_manager->ScanFilterEnable(true);