gd: Implement vendor specific event manager (12a83e67) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/Android.bp

+1 −0

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

system/gd/hci/BUILD.gn

+1 −0

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

	include_dirs = [ "//bt/gd" ]		include_dirs = [ "//bt/gd" ]

system/gd/hci/hci_layer.cc

+9 −5

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

system/gd/hci/le_scanning_manager.cc

+20 −10

Original line number	Original line	Diff line number	Diff line
	@@ -23,6 +23,7 @@
	#include "hci/hci_packets.h"		#include "hci/hci_packets.h"
	#include "hci/le_scanning_interface.h"		#include "hci/le_scanning_interface.h"
	#include "hci/le_scanning_manager.h"		#include "hci/le_scanning_manager.h"
			#include "hci/vendor_specific_event_manager.h"
	#include "module.h"		#include "module.h"
	#include "os/handler.h"		#include "os/handler.h"
	#include "os/log.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,		void start(
	hci::AclManager* acl_manager) {		os::Handler* handler,
			hci::HciLayer* hci_layer,
			hci::Controller* controller,
			hci::AclManager* acl_manager,
			hci::VendorSpecificEventManager* vendor_specific_event_manager) {
	module_handler_ = handler;		module_handler_ = handler;
	hci_layer_ = hci_layer;		hci_layer_ = hci_layer;
	controller_ = controller;		controller_ = controller;
			vendor_specific_event_manager_ = vendor_specific_event_manager;
	le_address_manager_ = acl_manager->GetLeAddressManager();		le_address_manager_ = acl_manager->GetLeAddressManager();
	le_scanning_interface_ = hci_layer_->GetLeScanningInterface(		le_scanning_interface_ = hci_layer_->GetLeScanningInterface(
	module_handler_->BindOn(this, &LeScanningManager::impl::handle_scan_results));		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_filter_support_ = controller_->IsSupported(OpCode::LE_ADV_FILTER);
	is_batch_scan_support_ = controller->IsSupported(OpCode::LE_BATCH_SCAN);		is_batch_scan_support_ = controller->IsSupported(OpCode::LE_BATCH_SCAN);
	if (is_batch_scan_support_) {		if (is_batch_scan_support_) {
	// TODO implement vse module		vendor_specific_event_manager_->RegisterEventHandler(
	// hci_layer_->RegisterVesEventHandler(		VseSubeventCode::BLE_THRESHOLD, handler->BindOn(this, &LeScanningManager::impl::on_storage_threshold_breach));
	// VseSubeventCode::BLE_THRESHOLD, handler->BindOn(this,		vendor_specific_event_manager_->RegisterEventHandler(
	// &LeScanningManager::impl::on_storage_threshold_breach));		VseSubeventCode::BLE_TRACKING, handler->BindOn(this, &LeScanningManager::impl::on_advertisement_tracking));
	// hci_layer_->RegisterVesEventHandler(
	// VseSubeventCode::BLE_TRACKING, handler->BindOn(this, &LeScanningManager::impl::on_advertisement_tracking));
	}		}
	scanners_ = std::vector<Scanner>(kMaxAppNum + 1);		scanners_ = std::vector<Scanner>(kMaxAppNum + 1);
	for (size_t i = 0; i < scanners_.size(); i++) {		for (size_t i = 0; i < scanners_.size(); i++) {
	@@ -1211,6 +1215,7 @@ struct LeScanningManager::impl : public bluetooth::hci::LeAddressManagerCallback
	os::Handler* module_handler_;		os::Handler* module_handler_;
	hci::HciLayer* hci_layer_;		hci::HciLayer* hci_layer_;
	hci::Controller* controller_;		hci::Controller* controller_;
			hci::VendorSpecificEventManager* vendor_specific_event_manager_;
	hci::LeScanningInterface* le_scanning_interface_;		hci::LeScanningInterface* le_scanning_interface_;
	hci::LeAddressManager* le_address_manager_;		hci::LeAddressManager* le_address_manager_;
	bool address_manager_registered_ = false;		bool address_manager_registered_ = false;
	@@ -1272,13 +1277,18 @@ LeScanningManager::LeScanningManager() {

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

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

	void LeScanningManager::Stop() {		void LeScanningManager::Stop() {

system/gd/hci/vendor_specific_event_manager.cc

0 → 100644

+132 −0

Original line number	Original line	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