Merge "gd: Implement vendor specific event manager" (059999ae) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@ filegroup {
		"le_scanning_manager.cc",
		"link_key.cc",
		"uuid.cc",
		"vendor_specific_event_manager.cc",
		],
		}

system/gd/hci/BUILD.gn

+1 −0

Original line number	Diff line number	Diff line
		@@ -31,6 +31,7 @@ source_set("BluetoothHciSources") {
		"le_scanning_manager.cc",
		"link_key.cc",
		"uuid.cc",
		"vendor_specific_event_manager.cc",
		]

		include_dirs = [ "//bt/gd" ]

system/gd/hci/hci_layer.cc

+9 −5

Original line number	Diff line number	Diff line
		@@ -301,13 +301,17 @@ struct HciLayer::impl {
		EventCode event_code = event.GetEventCode();
		// Root Inflamation is a special case, since it aborts here
		if (event_code == EventCode::VENDOR_SPECIFIC) {
		auto inflammation = BqrRootInflammationEventView::Create(
		BqrLinkQualityEventView::Create(BqrEventView::Create(VendorSpecificEventView::Create(event))));
		if (inflammation.IsValid()) {
		auto view = VendorSpecificEventView::Create(event);
		ASSERT(view.IsValid());
		if (view.GetSubeventCode() == VseSubeventCode::BQR_EVENT) {
		auto bqr_quality_view = BqrLinkQualityEventView::Create(BqrEventView::Create(view));
		auto inflammation = BqrRootInflammationEventView::Create(bqr_quality_view);
		if (bqr_quality_view.IsValid() && inflammation.IsValid()) {
		handle_root_inflammation(inflammation.GetVendorSpecificErrorCode());
		return;
		}
		}
		}
		if (event_handlers_.find(event_code) == event_handlers_.end()) {
		LOG_WARN("Unhandled event of type 0x%02hhx (%s)", event_code, EventCodeText(event_code).c_str());
		return;

system/gd/hci/le_scanning_manager.cc

+20 −10

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include "hci/hci_packets.h"
		#include "hci/le_scanning_interface.h"
		#include "hci/le_scanning_manager.h"
		#include "hci/vendor_specific_event_manager.h"
		#include "module.h"
		#include "os/handler.h"
		#include "os/log.h"
		@@ -204,11 +205,16 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		}
		}

		void start(os::Handler* handler, hci::HciLayer* hci_layer, hci::Controller* controller,
		hci::AclManager* acl_manager) {
		void start(
		os::Handler* handler,
		hci::HciLayer* hci_layer,
		hci::Controller* controller,
		hci::AclManager* acl_manager,
		hci::VendorSpecificEventManager* vendor_specific_event_manager) {
		module_handler_ = handler;
		hci_layer_ = hci_layer;
		controller_ = controller;
		vendor_specific_event_manager_ = vendor_specific_event_manager;
		le_address_manager_ = acl_manager->GetLeAddressManager();
		le_scanning_interface_ = hci_layer_->GetLeScanningInterface(
		module_handler_->BindOn(this, &LeScanningManager::impl::handle_scan_results));
		@@ -224,12 +230,10 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		is_filter_support_ = controller_->IsSupported(OpCode::LE_ADV_FILTER);
		is_batch_scan_support_ = controller->IsSupported(OpCode::LE_BATCH_SCAN);
		if (is_batch_scan_support_) {
		// TODO implement vse module
		// hci_layer_->RegisterVesEventHandler(
		// VseSubeventCode::BLE_THRESHOLD, handler->BindOn(this,
		// &LeScanningManager::impl::on_storage_threshold_breach));
		// hci_layer_->RegisterVesEventHandler(
		// VseSubeventCode::BLE_TRACKING, handler->BindOn(this, &LeScanningManager::impl::on_advertisement_tracking));
		vendor_specific_event_manager_->RegisterEventHandler(
		VseSubeventCode::BLE_THRESHOLD, handler->BindOn(this, &LeScanningManager::impl::on_storage_threshold_breach));
		vendor_specific_event_manager_->RegisterEventHandler(
		VseSubeventCode::BLE_TRACKING, handler->BindOn(this, &LeScanningManager::impl::on_advertisement_tracking));
		}
		scanners_ = std::vector<Scanner>(kMaxAppNum + 1);
		for (size_t i = 0; i < scanners_.size(); i++) {
		@@ -1211,6 +1215,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
		os::Handler* module_handler_;
		hci::HciLayer* hci_layer_;
		hci::Controller* controller_;
		hci::VendorSpecificEventManager* vendor_specific_event_manager_;
		hci::LeScanningInterface* le_scanning_interface_;
		hci::LeAddressManager* le_address_manager_;
		bool address_manager_registered_ = false;
		@@ -1272,13 +1277,18 @@ LeScanningManager::LeScanningManager() {

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

		void LeScanningManager::Start() {
		pimpl_->start(GetHandler(), GetDependency<hci::HciLayer>(), GetDependency<hci::Controller>(),
		GetDependency<AclManager>());
		pimpl_->start(
		GetHandler(),
		GetDependency<hci::HciLayer>(),
		GetDependency<hci::Controller>(),
		GetDependency<AclManager>(),
		GetDependency<VendorSpecificEventManager>());
		}

		void LeScanningManager::Stop() {

system/gd/hci/vendor_specific_event_manager.cc

0 → 100644

+132 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/
		#include "hci/vendor_specific_event_manager.h"

		#include "hci/controller.h"
		#include "hci/hci_layer.h"
		#include "hci/hci_packets.h"

		namespace bluetooth {
		namespace hci {

		const ModuleFactory VendorSpecificEventManager::Factory =
		ModuleFactory([]() { return new VendorSpecificEventManager(); });

		struct VendorSpecificEventManager::impl {
		impl(Module* module) : module_(module){};

		~impl() {}

		void start(os::Handler* handler, hci::HciLayer* hci_layer, hci::Controller* controller) {
		module_handler_ = handler;
		hci_layer_ = hci_layer;
		controller_ = controller;
		hci_layer_->RegisterEventHandler(
		EventCode::VENDOR_SPECIFIC, handler->BindOn(this, &VendorSpecificEventManager::impl::on_vendor_specific_event));
		vendor_capabilities_ = controller->GetVendorCapabilities();
		}

		void stop() {}

		void register_event(VseSubeventCode event, common::ContextualCallback<void(VendorSpecificEventView)> handler) {
		ASSERT_LOG(
		subevent_handlers_.count(event) == 0,
		"Can not register a second handler for %02hhx (%s)",
		event,
		VseSubeventCodeText(event).c_str());
		subevent_handlers_[event] = handler;
		}

		void unregister_event(VseSubeventCode event) {
		subevent_handlers_.erase(subevent_handlers_.find(event));
		}

		bool check_event_supported(VseSubeventCode event) {
		switch (event) {
		case (VseSubeventCode::BLE_THRESHOLD): {
		if (vendor_capabilities_.total_scan_results_storage_ > 0) {
		return true;
		}
		} break;
		case (VseSubeventCode::BLE_TRACKING): {
		if (vendor_capabilities_.total_num_of_advt_tracked_ > 0) {
		return true;
		}
		} break;
		case (VseSubeventCode::DEBUG_INFO): {
		return vendor_capabilities_.debug_logging_supported_;
		} break;
		case (VseSubeventCode::BQR_EVENT): {
		return vendor_capabilities_.bluetooth_quality_report_support_;
		} break;
		default:
		LOG_WARN("Unhandled event %s", VseSubeventCodeText(event).c_str());
		}
		return false;
		}

		void on_vendor_specific_event(EventView event_view) {
		auto vendor_specific_event_view = VendorSpecificEventView::Create(event_view);
		ASSERT(vendor_specific_event_view.IsValid());
		VseSubeventCode vse_subevent_code = vendor_specific_event_view.GetSubeventCode();
		if (subevent_handlers_.find(vse_subevent_code) == subevent_handlers_.end()) {
		LOG_WARN("Unhandled vendor specific event of type 0x%02hhx", vse_subevent_code);
		return;
		}
		subevent_handlers_[vse_subevent_code].Invoke(vendor_specific_event_view);
		}

		Module* module_;
		os::Handler* module_handler_;
		hci::HciLayer* hci_layer_;
		hci::Controller* controller_;
		VendorCapabilities vendor_capabilities_;
		std::map<VseSubeventCode, common::ContextualCallback<void(VendorSpecificEventView)>> subevent_handlers_;
		};

		VendorSpecificEventManager::VendorSpecificEventManager() {
		pimpl_ = std::make_unique<impl>(this);
		}

		void VendorSpecificEventManager::ListDependencies(ModuleList* list) {
		list->add<hci::HciLayer>();
		list->add<hci::Controller>();
		}

		void VendorSpecificEventManager::Start() {
		pimpl_->start(GetHandler(), GetDependency<hci::HciLayer>(), GetDependency<hci::Controller>());
		}

		void VendorSpecificEventManager::Stop() {
		pimpl_->stop();
		pimpl_.reset();
		}

		std::string VendorSpecificEventManager::ToString() const {
		return "Vendor Specific Event Manager";
		}

		void VendorSpecificEventManager::RegisterEventHandler(
		VseSubeventCode event, common::ContextualCallback<void(VendorSpecificEventView)> handler) {
		CallOn(pimpl_.get(), &impl::register_event, event, handler);
		}

		void VendorSpecificEventManager::UnregisterEventHandler(VseSubeventCode event) {
		CallOn(pimpl_.get(), &impl::unregister_event, event);
		}

		} // namespace hci
		} // namespace bluetooth
		No newline at end of file