Merge "HCI: Add connection management interfaces" am: 8150918dd1 am: ec0569279f (e85ecb4a) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/acl_connection_interface.h

0 → 100644

+60 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 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.
		*/

		#pragma once

		#include "common/callback.h"
		#include "hci/hci_packets.h"
		#include "os/utils.h"

		namespace bluetooth {
		namespace hci {

		class AclConnectionInterface {
		public:
		AclConnectionInterface() = default;
		virtual ~AclConnectionInterface() = default;
		DISALLOW_COPY_AND_ASSIGN(AclConnectionInterface);

		virtual void EnqueueCommand(std::unique_ptr<ConnectionManagementCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) = 0;

		virtual void EnqueueCommand(std::unique_ptr<ConnectionManagementCommandBuilder> command,
		common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) = 0;

		static constexpr EventCode AclConnectionEvents[] = {
		EventCode::CONNECTION_PACKET_TYPE_CHANGED,
		EventCode::ROLE_CHANGE,
		EventCode::CONNECTION_COMPLETE,
		EventCode::DISCONNECTION_COMPLETE,
		EventCode::CONNECTION_REQUEST,
		EventCode::CONNECTION_PACKET_TYPE_CHANGED,
		EventCode::AUTHENTICATION_COMPLETE,
		EventCode::READ_CLOCK_OFFSET_COMPLETE,
		EventCode::MODE_CHANGE,
		EventCode::QOS_SETUP_COMPLETE,
		EventCode::ROLE_CHANGE,
		EventCode::FLOW_SPECIFICATION_COMPLETE,
		EventCode::FLUSH_OCCURRED,
		EventCode::READ_REMOTE_SUPPORTED_FEATURES_COMPLETE,
		EventCode::READ_REMOTE_EXTENDED_FEATURES_COMPLETE,
		EventCode::READ_REMOTE_VERSION_INFORMATION_COMPLETE,
		EventCode::ENCRYPTION_CHANGE,
		EventCode::LINK_SUPERVISION_TIMEOUT_CHANGED,
		};
		};
		} // namespace hci
		} // namespace bluetooth

system/gd/hci/hci_layer.cc

+80 −32

Original line number	Diff line number	Diff line
		@@ -97,18 +97,51 @@ void on_hci_timeout(OpCode op_code) {
		}
		} // namespace

		class AclConnectionManagerInterfaceImpl : public AclConnectionInterface {
		public:
		explicit AclConnectionManagerInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		~AclConnectionManagerInterfaceImpl() override = default;

		void EnqueueCommand(std::unique_ptr<ConnectionManagementCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_complete), handler);
		}

		void EnqueueCommand(std::unique_ptr<ConnectionManagementCommandBuilder> command,
		common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_status), handler);
		}
		HciLayer& hci_;
		};

		class SecurityInterfaceImpl : public SecurityInterface {
		public:
		SecurityInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		virtual ~SecurityInterfaceImpl() = default;
		explicit SecurityInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		~SecurityInterfaceImpl() override = default;

		virtual void EnqueueCommand(std::unique_ptr<SecurityCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete,
		os::Handler* handler) override {
		void EnqueueCommand(std::unique_ptr<SecurityCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_complete), handler);
		}

		virtual void EnqueueCommand(std::unique_ptr<SecurityCommandBuilder> command,
		void EnqueueCommand(std::unique_ptr<SecurityCommandBuilder> command,
		common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_status), handler);
		}
		HciLayer& hci_;
		};

		class LeAclConnectionManagerInterfaceImpl : public LeAclConnectionInterface {
		public:
		explicit LeAclConnectionManagerInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		~LeAclConnectionManagerInterfaceImpl() override = default;

		void EnqueueCommand(std::unique_ptr<LeConnectionManagementCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_complete), handler);
		}

		void EnqueueCommand(std::unique_ptr<LeConnectionManagementCommandBuilder> command,
		common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_status), handler);
		}
		@@ -117,16 +150,15 @@ class SecurityInterfaceImpl : public SecurityInterface {

		class LeSecurityInterfaceImpl : public LeSecurityInterface {
		public:
		LeSecurityInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		virtual ~LeSecurityInterfaceImpl() = default;
		explicit LeSecurityInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		~LeSecurityInterfaceImpl() override = default;

		virtual void EnqueueCommand(std::unique_ptr<LeSecurityCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete,
		os::Handler* handler) override {
		void EnqueueCommand(std::unique_ptr<LeSecurityCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_complete), handler);
		}

		virtual void EnqueueCommand(std::unique_ptr<LeSecurityCommandBuilder> command,
		void EnqueueCommand(std::unique_ptr<LeSecurityCommandBuilder> command,
		common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_status), handler);
		}
		@@ -135,16 +167,15 @@ class LeSecurityInterfaceImpl : public LeSecurityInterface {

		class LeAdvertisingInterfaceImpl : public LeAdvertisingInterface {
		public:
		LeAdvertisingInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		virtual ~LeAdvertisingInterfaceImpl() = default;
		explicit LeAdvertisingInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		~LeAdvertisingInterfaceImpl() override = default;

		virtual void EnqueueCommand(std::unique_ptr<LeAdvertisingCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete,
		os::Handler* handler) override {
		void EnqueueCommand(std::unique_ptr<LeAdvertisingCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_complete), handler);
		}

		virtual void EnqueueCommand(std::unique_ptr<LeAdvertisingCommandBuilder> command,
		void EnqueueCommand(std::unique_ptr<LeAdvertisingCommandBuilder> command,
		common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_status), handler);
		}
		@@ -153,16 +184,15 @@ class LeAdvertisingInterfaceImpl : public LeAdvertisingInterface {

		class LeScanningInterfaceImpl : public LeScanningInterface {
		public:
		LeScanningInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		virtual ~LeScanningInterfaceImpl() = default;
		explicit LeScanningInterfaceImpl(HciLayer& hci) : hci_(hci) {}
		~LeScanningInterfaceImpl() override = default;

		virtual void EnqueueCommand(std::unique_ptr<LeScanningCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete,
		os::Handler* handler) override {
		void EnqueueCommand(std::unique_ptr<LeScanningCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_complete), handler);
		}

		virtual void EnqueueCommand(std::unique_ptr<LeScanningCommandBuilder> command,
		void EnqueueCommand(std::unique_ptr<LeScanningCommandBuilder> command,
		common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) override {
		hci_.EnqueueCommand(std::move(command), std::move(on_status), handler);
		}
		@@ -382,8 +412,7 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		os::Handler* handler) {
		ASSERT_LOG(event_handlers_.count(event_code) == 0, "Can not register a second handler for event_code %02hhx (%s)",
		event_code, EventCodeText(event_code).c_str());
		EventHandler to_save(event_handler, handler);
		event_handlers_[event_code] = to_save;
		event_handlers_[event_code] = EventHandler(event_handler, handler);
		}

		void UnregisterEventHandler(EventCode event_code) {
		@@ -406,8 +435,7 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		ASSERT_LOG(subevent_handlers_.count(subevent_code) == 0,
		"Can not register a second handler for subevent_code %02hhx (%s)", subevent_code,
		SubeventCodeText(subevent_code).c_str());
		SubeventHandler to_save(subevent_handler, handler);
		subevent_handlers_[subevent_code] = to_save;
		subevent_handlers_[subevent_code] = SubeventHandler(subevent_handler, handler);
		}

		void UnregisterLeEventHandler(SubeventCode subevent_code) {
		@@ -426,6 +454,8 @@ struct HciLayer::impl : public hal::HciHalCallbacks {
		HciLayer& module_;

		// Interfaces
		AclConnectionManagerInterfaceImpl acl_connection_manager_interface_{module_};
		LeAclConnectionManagerInterfaceImpl le_acl_connection_manager_interface_{module_};
		SecurityInterfaceImpl security_interface{module_};
		LeSecurityInterfaceImpl le_security_interface{module_};
		LeAdvertisingInterfaceImpl le_advertising_interface{module_};
		@@ -483,6 +513,24 @@ void HciLayer::UnregisterLeEventHandler(SubeventCode subevent_code) {
		impl_->UnregisterLeEventHandler(subevent_code);
		}

		AclConnectionInterface* HciLayer::GetAclConnectionInterface(common::Callback<void(EventPacketView)> event_handler,
		common::Callback<void(uint16_t, ErrorCode)> on_disconnect,
		os::Handler* handler) {
		for (const auto event : AclConnectionInterface::AclConnectionEvents) {
		RegisterEventHandler(event, event_handler, handler);
		}
		return &impl_->acl_connection_manager_interface_;
		}

		LeAclConnectionInterface* HciLayer::GetLeAclConnectionInterface(
		common::Callback<void(LeMetaEventView)> event_handler, common::Callback<void(uint16_t, ErrorCode)> on_disconnect,
		os::Handler* handler) {
		for (const auto event : LeAclConnectionInterface::LeConnectionManagementEvents) {
		RegisterLeEventHandler(event, event_handler, handler);
		}
		return &impl_->le_acl_connection_manager_interface_;
		}

		SecurityInterface* HciLayer::GetSecurityInterface(common::Callback<void(EventPacketView)> event_handler,
		os::Handler* handler) {
		for (const auto event : SecurityInterface::SecurityEvents) {

system/gd/hci/hci_layer.h

+10 −0

Original line number	Diff line number	Diff line
		@@ -24,7 +24,9 @@
		#include "common/bidi_queue.h"
		#include "common/callback.h"
		#include "hal/hci_hal.h"
		#include "hci/acl_connection_interface.h"
		#include "hci/hci_packets.h"
		#include "hci/le_acl_connection_interface.h"
		#include "hci/le_advertising_interface.h"
		#include "hci/le_scanning_interface.h"
		#include "hci/le_security_interface.h"
		@@ -64,6 +66,14 @@ class HciLayer : public Module {
		LeSecurityInterface* GetLeSecurityInterface(common::Callback<void(LeMetaEventView)> event_handler,
		os::Handler* handler);

		AclConnectionInterface* GetAclConnectionInterface(common::Callback<void(EventPacketView)> event_handler,
		common::Callback<void(uint16_t, hci::ErrorCode)> on_disconnect,
		os::Handler* handler);

		LeAclConnectionInterface* GetLeAclConnectionInterface(common::Callback<void(LeMetaEventView)> event_handler,
		common::Callback<void(uint16_t, hci::ErrorCode)> on_disconnect,
		os::Handler* handler);

		LeAdvertisingInterface* GetLeAdvertisingInterface(common::Callback<void(LeMetaEventView)> event_handler,
		os::Handler* handler);

system/gd/hci/hci_packets.pdl

+3 −3

Original line number	Diff line number	Diff line
		@@ -1034,7 +1034,7 @@ packet RemoteNameRequestCancelComplete : CommandComplete (command_op_code = REMO
		bd_addr : Address,
		}

		packet ReadRemoteSupportedFeatures : DiscoveryCommand (op_code = READ_REMOTE_SUPPORTED_FEATURES) {
		packet ReadRemoteSupportedFeatures : ConnectionManagementCommand (op_code = READ_REMOTE_SUPPORTED_FEATURES) {
		connection_handle : 12,
		_reserved_ : 4,
		}
		@@ -1042,7 +1042,7 @@ packet ReadRemoteSupportedFeatures : DiscoveryCommand (op_code = READ_REMOTE_SUP
		packet ReadRemoteSupportedFeaturesStatus : CommandStatus (command_op_code = READ_REMOTE_SUPPORTED_FEATURES) {
		}

		packet ReadRemoteExtendedFeatures : DiscoveryCommand (op_code = READ_REMOTE_EXTENDED_FEATURES) {
		packet ReadRemoteExtendedFeatures : ConnectionManagementCommand (op_code = READ_REMOTE_EXTENDED_FEATURES) {
		connection_handle : 12,
		_reserved_ : 4,
		page_number : 8,
		@@ -1051,7 +1051,7 @@ packet ReadRemoteExtendedFeatures : DiscoveryCommand (op_code = READ_REMOTE_EXTE
		packet ReadRemoteExtendedFeaturesStatus : CommandStatus (command_op_code = READ_REMOTE_EXTENDED_FEATURES) {
		}

		packet ReadRemoteVersionInformation : DiscoveryCommand (op_code = READ_REMOTE_VERSION_INFORMATION) {
		packet ReadRemoteVersionInformation : ConnectionManagementCommand (op_code = READ_REMOTE_VERSION_INFORMATION) {
		connection_handle : 12,
		_reserved_ : 4,
		}

system/gd/hci/le_acl_connection_interface.h

0 → 100644

+46 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 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.
		*/

		#pragma once

		#include "common/callback.h"
		#include "hci/hci_packets.h"
		#include "os/handler.h"
		#include "os/utils.h"

		namespace bluetooth {
		namespace hci {

		class LeAclConnectionInterface {
		public:
		LeAclConnectionInterface() = default;
		virtual ~LeAclConnectionInterface() = default;
		DISALLOW_COPY_AND_ASSIGN(LeAclConnectionInterface);

		virtual void EnqueueCommand(std::unique_ptr<LeConnectionManagementCommandBuilder> command,
		common::OnceCallback<void(CommandCompleteView)> on_complete, os::Handler* handler) = 0;

		virtual void EnqueueCommand(std::unique_ptr<LeConnectionManagementCommandBuilder> command,
		common::OnceCallback<void(CommandStatusView)> on_status, os::Handler* handler) = 0;

		static constexpr SubeventCode LeConnectionManagementEvents[] = {
		SubeventCode::CONNECTION_COMPLETE,
		SubeventCode::ENHANCED_CONNECTION_COMPLETE,
		SubeventCode::CONNECTION_UPDATE_COMPLETE,
		};
		};
		} // namespace hci
		} // namespace bluetooth