Get rid of HciLayer shim (f104b960) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/facade/grpc_root_server.cc

+2 −2

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@
		#include "hci/facade/le_acl_manager_facade.h"
		#include "hci/facade/le_advertising_manager_facade.h"
		#include "hci/facade/le_scanning_manager_facade.h"
		#include "hci/hci_layer.h"
		#include "hci/le_advertising_manager.h"
		#include "hci/le_scanning_manager.h"
		#include "l2cap/classic/facade.h"
		@@ -42,7 +43,6 @@
		#include "security/facade.h"
		#include "security/security_module.h"
		#include "shim/dumpsys.h"
		#include "shim/hci_layer.h"
		#include "shim/l2cap.h"
		#include "stack_manager.h"
		#include "storage/legacy.h"
		@@ -110,9 +110,9 @@ class RootFacadeService : public ::bluetooth::facade::RootFacade::Service {
		modules.add<::bluetooth::neighbor::InquiryModule>();
		modules.add<::bluetooth::neighbor::NameModule>();
		modules.add<::bluetooth::shim::Dumpsys>();
		modules.add<::bluetooth::shim::HciLayer>();
		modules.add<::bluetooth::shim::L2cap>();
		modules.add<::bluetooth::neighbor::PageModule>();
		modules.add<::bluetooth::hci::HciLayer>();
		modules.add<::bluetooth::hci::LeAdvertisingManager>();
		modules.add<::bluetooth::hci::LeScanningManager>();
		modules.add<::bluetooth::security::SecurityModule>();

system/gd/shim/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -2,7 +2,6 @@ filegroup {
		name: "BluetoothShimSources",
		srcs: [
		"dumpsys.cc",
		"hci_layer.cc",
		"l2cap.cc",
		"stack.cc",
		]

system/gd/shim/hci_layer.cc

deleted100644 → 0

+0 −215

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 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.
		*/
		#define LOG_TAG "bt_gd_shim"

		#include <cstdint>
		#include <memory>
		#include <queue>
		#include <string>
		#include <unordered_map>
		#include <vector>

		#include "hci/hci_layer.h"
		#include "hci/hci_packets.h"
		#include "module.h"
		#include "os/handler.h"
		#include "os/log.h"
		#include "packet/raw_builder.h"
		#include "shim/hci_layer.h"

		namespace bluetooth {
		namespace shim {

		namespace {
		constexpr char kModuleName[] = "shim::HciLayer";
		} // namespace

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

		struct HciLayer::impl {
		impl(os::Handler* handler, hci::HciLayer* hci_layer) : handler_(handler), hci_layer_(hci_layer) {}

		void OnTransmitPacketCommandComplete(const void* token, hci::CommandCompleteView view) {
		if (command_complete_callback_ == nullptr) {
		LOG_WARN("%s Received packet complete with no complete callback registered", __func__);
		return;
		}

		uint16_t command_op_code = static_cast<uint16_t>(view.GetCommandOpCode());
		std::vector<const uint8_t> data(view.begin(), view.end());

		command_complete_callback_(command_op_code, data, token);
		}

		void OnTransmitPacketStatus(const void* token, hci::CommandStatusView view) {
		if (command_status_callback_ == nullptr) {
		LOG_WARN("%s Received packet complete with no status callback registered", __func__);
		return;
		}

		uint16_t command_op_code = static_cast<uint16_t>(view.GetCommandOpCode());
		std::vector<const uint8_t> data(view.begin(), view.end());

		uint8_t status = static_cast<uint8_t>(view.GetStatus());
		command_status_callback_(command_op_code, data, token, status);
		}

		void TransmitCommand(uint16_t command, const uint8_t* data, size_t len, const void* token) {
		ASSERT(data != nullptr);
		ASSERT(token != nullptr);

		const hci::OpCode op_code = static_cast<const hci::OpCode>(command);

		auto payload = MakeUniquePacket(data, len);
		auto packet = hci::CommandPacketBuilder::Create(op_code, std::move(payload));

		if (IsCommandStatusOpcode(op_code)) {
		hci_layer_->EnqueueCommand(std::move(packet),
		common::BindOnce(&impl::OnTransmitPacketStatus, common::Unretained(this), token),
		handler_);
		} else {
		hci_layer_->EnqueueCommand(
		std::move(packet), common::BindOnce(&impl::OnTransmitPacketCommandComplete, common::Unretained(this), token),
		handler_);
		}
		}

		void RegisterCommandComplete(CommandCompleteCallback callback) {
		ASSERT(command_complete_callback_ == nullptr);
		command_complete_callback_ = callback;
		}

		void UnregisterCommandComplete() {
		ASSERT(command_complete_callback_ != nullptr);
		command_complete_callback_ = nullptr;
		}

		void RegisterCommandStatus(CommandStatusCallback callback) {
		ASSERT(command_status_callback_ == nullptr);
		command_status_callback_ = callback;
		}

		void UnregisterCommandStatus() {
		ASSERT(command_status_callback_ != nullptr);
		command_status_callback_ = nullptr;
		}

		private:
		os::Handler* handler_{nullptr};
		hci::HciLayer* hci_layer_{nullptr};

		CommandCompleteCallback command_complete_callback_;
		CommandStatusCallback command_status_callback_;

		/**
		* Returns true if expecting command complete, false otherwise
		*/
		bool IsCommandStatusOpcode(hci::OpCode op_code) {
		switch (op_code) {
		case hci::OpCode::INQUIRY:
		case hci::OpCode::CREATE_CONNECTION:
		case hci::OpCode::DISCONNECT:
		case hci::OpCode::ACCEPT_CONNECTION_REQUEST:
		case hci::OpCode::REJECT_CONNECTION_REQUEST:
		case hci::OpCode::CHANGE_CONNECTION_PACKET_TYPE:
		case hci::OpCode::AUTHENTICATION_REQUESTED:
		case hci::OpCode::SET_CONNECTION_ENCRYPTION:
		case hci::OpCode::CHANGE_CONNECTION_LINK_KEY:
		case hci::OpCode::MASTER_LINK_KEY:
		case hci::OpCode::REMOTE_NAME_REQUEST:
		case hci::OpCode::READ_REMOTE_SUPPORTED_FEATURES:
		case hci::OpCode::READ_REMOTE_EXTENDED_FEATURES:
		case hci::OpCode::READ_REMOTE_VERSION_INFORMATION:
		case hci::OpCode::READ_CLOCK_OFFSET:
		case hci::OpCode::SETUP_SYNCHRONOUS_CONNECTION:
		case hci::OpCode::ACCEPT_SYNCHRONOUS_CONNECTION:
		case hci::OpCode::REJECT_SYNCHRONOUS_CONNECTION:
		case hci::OpCode::ENHANCED_SETUP_SYNCHRONOUS_CONNECTION:
		case hci::OpCode::ENHANCED_ACCEPT_SYNCHRONOUS_CONNECTION:
		case hci::OpCode::HOLD_MODE:
		case hci::OpCode::SNIFF_MODE:
		case hci::OpCode::EXIT_SNIFF_MODE:
		case hci::OpCode::QOS_SETUP:
		case hci::OpCode::SWITCH_ROLE:
		case hci::OpCode::FLOW_SPECIFICATION:
		case hci::OpCode::REFRESH_ENCRYPTION_KEY:
		case hci::OpCode::LE_CREATE_CONNECTION:
		case hci::OpCode::LE_CONNECTION_UPDATE:
		case hci::OpCode::LE_READ_REMOTE_FEATURES:
		case hci::OpCode::LE_READ_LOCAL_P_256_PUBLIC_KEY_COMMAND:
		case hci::OpCode::LE_GENERATE_DHKEY_COMMAND:
		case hci::OpCode::LE_SET_PHY:
		case hci::OpCode::LE_EXTENDED_CREATE_CONNECTION:
		case hci::OpCode::LE_PERIODIC_ADVERTISING_CREATE_SYNC:
		return true;
		default:
		return false;
		}
		}

		std::unique_ptr<packet::RawBuilder> MakeUniquePacket(const uint8_t* data, size_t len) {
		packet::RawBuilder builder;
		std::vector<uint8_t> bytes(data, data + len);

		auto payload = std::make_unique<packet::RawBuilder>();
		payload->AddOctets(bytes);

		return payload;
		}
		};

		void HciLayer::TransmitCommand(uint16_t op_code, const uint8_t* data, size_t len, const void* token) {
		pimpl_->TransmitCommand(op_code, data, len, std::move(token));
		}

		void HciLayer::RegisterCommandComplete(CommandCompleteCallback callback) {
		pimpl_->RegisterCommandComplete(callback);
		}

		void HciLayer::UnregisterCommandComplete() {
		pimpl_->UnregisterCommandComplete();
		}

		void HciLayer::RegisterCommandStatus(CommandStatusCallback callback) {
		pimpl_->RegisterCommandStatus(callback);
		}

		void HciLayer::UnregisterCommandStatus() {
		pimpl_->UnregisterCommandStatus();
		}

		/**
		* Module methods
		*/
		void HciLayer::ListDependencies(ModuleList* list) {
		list->add<hci::HciLayer>();
		}

		void HciLayer::Start() {
		LOG_INFO("%s Starting controller shim layer", __func__);
		pimpl_ = std::make_unique<impl>(GetHandler(), GetDependency<hci::HciLayer>());
		}

		void HciLayer::Stop() {
		pimpl_.reset();
		}

		std::string HciLayer::ToString() const {
		return kModuleName;
		}

		} // namespace shim
		} // namespace bluetooth

system/gd/shim/hci_layer.h

deleted100644 → 0

+0 −67

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 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 <cstdint>
		#include <memory>
		#include <string>

		#include "module.h"

		/**
		* The hci layer shim module that depends on the Gd hci layer module.
		*/
		namespace bluetooth {
		namespace shim {

		/**
		* Legacy interface and API into the Gd shim hci layer module.
		*/
		using CommandCompleteCallback =
		std::function<void(uint16_t command_op_code, std::vector<const uint8_t> data, const void* token)>;
		using CommandStatusCallback =
		std::function<void(uint16_t command_op_code, std::vector<const uint8_t> data, const void* token, uint8_t status)>;

		class HciLayer : public ::bluetooth::Module {
		public:
		HciLayer() = default;
		~HciLayer() = default;

		void TransmitCommand(uint16_t op_code, const uint8_t* data, size_t len, const void* token);

		void RegisterCommandComplete(CommandCompleteCallback callback);
		void UnregisterCommandComplete();

		void RegisterCommandStatus(CommandStatusCallback callback);
		void UnregisterCommandStatus();

		static const ModuleFactory Factory;

		protected:
		void ListDependencies(ModuleList* list) override; // Module
		void Start() override; // Module
		void Stop() override; // Module
		std::string ToString() const override; // Module

		private:
		struct impl;
		std::unique_ptr<impl> pimpl_;
		DISALLOW_COPY_AND_ASSIGN(HciLayer);
		};

		} // namespace shim
		} // namespace bluetooth

system/gd/shim/only_include_this_file_into_legacy_stack___ever.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -27,7 +27,6 @@
		namespace bluetooth {
		namespace shim {
		class Dumpsys;
		class HciLayer;
		class L2cap;
		} // namespace shim
		} // namespace bluetooth
		No newline at end of file