Merge "RootCanal: Split HciSocketDevice into HciDevice + HciSocketTransport" (dc549a84) · Commits · e / os / android_packages_modules_Bluetooth

system/test/rootcanal/bluetooth_hci.cc

+6 −3

Original line number	Diff line number	Diff line
		@@ -25,8 +25,9 @@

		#include "hci_internals.h"
		#include "log/log.h"
		#include "model/devices/hci_socket_device.h"
		#include "model/devices/hci_device.h"
		#include "model/devices/link_layer_socket_device.h"
		#include "model/hci/hci_socket_transport.h"

		namespace android {
		namespace hardware {
		@@ -37,7 +38,8 @@ namespace sim {
		using android::hardware::hidl_vec;
		using rootcanal::AsyncTaskId;
		using rootcanal::DualModeController;
		using rootcanal::HciSocketDevice;
		using rootcanal::HciDevice;
		using rootcanal::HciSocketTransport;
		using rootcanal::LinkLayerSocketDevice;
		using rootcanal::TaskCallback;

		@@ -205,7 +207,8 @@ Return<void> BluetoothHci::initialize_impl(
		SetUpTestChannel();
		SetUpHciServer([this](std::shared_ptr<AsyncDataChannel> socket,
		AsyncDataChannelServer* srv) {
		test_model_.AddHciConnection(HciSocketDevice::Create(socket, ""));
		auto transport = HciSocketTransport::Create(socket);
		test_model_.AddHciConnection(HciDevice::Create(transport, ""));
		srv->StartListening();
		});
		SetUpLinkLayerServer([this](std::shared_ptr<AsyncDataChannel> socket,

tools/rootcanal/Android.bp

+9 −8

Original line number	Diff line number	Diff line
		@@ -80,13 +80,14 @@ cc_library_static {
		"model/controller/security_manager.cc",
		"model/devices/device.cc",
		"model/devices/device_properties.cc",
		"model/devices/h4_data_channel_packetizer.cc",
		"model/devices/h4_packetizer.cc",
		"model/devices/h4_parser.cc",
		"model/devices/hci_protocol.cc",
		"model/devices/hci_socket_device.cc",
		"model/devices/hci_device.cc",
		"model/devices/link_layer_socket_device.cc",
		"model/devices/remote_loopback_device.cc",
		"model/hci/h4_data_channel_packetizer.cc",
		"model/hci/h4_packetizer.cc",
		"model/hci/h4_parser.cc",
		"model/hci/hci_protocol.cc",
		"model/hci/hci_socket_transport.cc",
		"model/setup/async_manager.cc",
		"model/setup/phy_layer_factory.cc",
		"model/setup/test_channel_transport.cc",
		@@ -230,9 +231,9 @@ cc_library_static {
		"gd_defaults",
		],
		srcs: [
		"model/devices/h4_packetizer.cc",
		"model/devices/h4_parser.cc",
		"model/devices/hci_protocol.cc",
		"model/hci/h4_packetizer.cc",
		"model/hci/h4_parser.cc",
		"model/hci/hci_protocol.cc",
		],

		local_include_dirs: [

tools/rootcanal/desktop/test_environment.cc

+5 −3

Original line number	Diff line number	Diff line
		@@ -20,8 +20,8 @@
		#include <utility> // for move
		#include <vector> // for vector

		#include "model/devices/hci_socket_device.h" // for HciSocketDevice
		#include "model/devices/link_layer_socket_device.h" // for LinkLayerSocketDevice
		#include "model/hci/hci_socket_transport.h" // for HciSocketTransport
		#include "net/async_data_channel.h" // for AsyncDataChannel
		#include "net/async_data_channel_connector.h" // for AsyncDataChannelConnector
		#include "os/log.h" // for LOG_INFO, LOG_ERROR, LOG_WARN
		@@ -31,7 +31,8 @@ namespace bluetooth {
		namespace root_canal {

		using rootcanal::AsyncTaskId;
		using rootcanal::HciSocketDevice;
		using rootcanal::HciDevice;
		using rootcanal::HciSocketTransport;
		using rootcanal::LinkLayerSocketDevice;
		using rootcanal::TaskCallback;

		@@ -57,8 +58,9 @@ void TestEnvironment::initialize(std::promise<void> barrier) {
		SetUpTestChannel();
		SetUpHciServer([this](std::shared_ptr<AsyncDataChannel> socket,
		AsyncDataChannelServer* srv) {
		auto transport = HciSocketTransport::Create(socket);
		test_model_.AddHciConnection(
		HciSocketDevice::Create(socket, controller_properties_file_));
		HciDevice::Create(transport, controller_properties_file_));
		srv->StartListening();
		});
		SetUpLinkLayerServer();

tools/rootcanal/model/devices/hci_socket_device.cc→tools/rootcanal/model/devices/hci_device.cc

+104 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2018 The Android Open Source Project
		* Copyright 2022 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.
		@@ -14,21 +14,15 @@
		* limitations under the License.
		*/

		#include "hci_socket_device.h"
		#include "hci_device.h"

		#include <chrono> // for milliseconds
		#include <type_traits> // for remove_extent_t

		#include "model/devices/device_properties.h" // for DeviceProperties
		#include "os/log.h" // for LOG_INFO, LOG_ALWAYS_FATAL

		using std::vector;
		#include "os/log.h"

		namespace rootcanal {

		HciSocketDevice::HciSocketDevice(std::shared_ptr<AsyncDataChannel> socket,
		HciDevice::HciDevice(std::shared_ptr<HciTransport> transport,
		const std::string& properties_filename)
		: DualModeController(properties_filename), socket_(socket) {
		: DualModeController(properties_filename), transport_(transport) {
		advertising_interval_ms_ = std::chrono::milliseconds(1000);

		page_scan_delay_ms_ = std::chrono::milliseconds(600);
		@@ -36,7 +30,7 @@ HciSocketDevice::HciSocketDevice(std::shared_ptr<AsyncDataChannel> socket,
		properties_.SetPageScanRepetitionMode(0);
		properties_.SetClassOfDevice(0x600420);
		properties_.SetExtendedInquiryData({
		16, // length
		12, // length
		9, // Type: Device Name
		'g',
		'D',
		@@ -49,10 +43,7 @@ HciSocketDevice::HciSocketDevice(std::shared_ptr<AsyncDataChannel> socket,
		'h',
		'c',
		'i',
		'_',
		'n',
		'e',
		't',

		});
		properties_.SetName({
		'g',
		@@ -66,77 +57,47 @@ HciSocketDevice::HciSocketDevice(std::shared_ptr<AsyncDataChannel> socket,
		'H',
		'C',
		'I',
		'_',
		'N',
		'e',
		't',
		});

		h4_ = H4DataChannelPacketizer(
		socket,
		[this](const std::vector<uint8_t>& raw_command) {
		std::shared_ptr<std::vector<uint8_t>> packet_copy =
		std::make_shared<std::vector<uint8_t>>(raw_command);
		HandleCommand(packet_copy);
		},
		[](const std::vector<uint8_t>&) {
		LOG_ALWAYS_FATAL("Unexpected Event in HciSocketDevice!");
		},
		[this](const std::vector<uint8_t>& raw_acl) {
		std::shared_ptr<std::vector<uint8_t>> packet_copy =
		std::make_shared<std::vector<uint8_t>>(raw_acl);
		HandleAcl(packet_copy);
		},
		[this](const std::vector<uint8_t>& raw_sco) {
		std::shared_ptr<std::vector<uint8_t>> packet_copy =
		std::make_shared<std::vector<uint8_t>>(raw_sco);
		HandleSco(packet_copy);
		},
		[this](const std::vector<uint8_t>& raw_iso) {
		std::shared_ptr<std::vector<uint8_t>> packet_copy =
		std::make_shared<std::vector<uint8_t>>(raw_iso);
		HandleIso(packet_copy);
		},
		[this]() {
		LOG_INFO("HCI socket device disconnected");
		Close();
		});

		RegisterEventChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {
		SendHci(PacketType::EVENT, packet);
		transport_->SendEvent(*packet);
		});
		RegisterAclChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {
		SendHci(PacketType::ACL, packet);
		transport_->SendAcl(*packet);
		});
		RegisterScoChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {
		SendHci(PacketType::SCO, packet);
		transport_->SendSco(*packet);
		});
		RegisterIsoChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {
		SendHci(PacketType::ISO, packet);
		transport_->SendIso(*packet);
		});
		}

		void HciSocketDevice::TimerTick() {
		h4_.OnDataReady(socket_);
		DualModeController::TimerTick();
		transport_->RegisterCallbacks(
		[this](const std::shared_ptr<std::vector<uint8_t>> command) {
		HandleCommand(command);
		},
		[this](const std::shared_ptr<std::vector<uint8_t>> acl) {
		HandleAcl(acl);
		},
		[this](const std::shared_ptr<std::vector<uint8_t>> sco) {
		HandleSco(sco);
		},
		[this](const std::shared_ptr<std::vector<uint8_t>> iso) {
		HandleIso(iso);
		},
		[this]() {
		LOG_INFO("HCI transport closed");
		Close();
		});
		}

		void HciSocketDevice::SendHci(
		PacketType packet_type,
		const std::shared_ptr<std::vector<uint8_t>> packet) {
		if (!socket_ \|\| !socket_->Connected()) {
		LOG_INFO("Closed socket. Dropping packet of type %d",
		static_cast<int>(packet_type));
		return;
		}
		uint8_t type = static_cast<uint8_t>(packet_type);
		h4_.Send(type, packet->data(), packet->size());
		void HciDevice::TimerTick() {
		transport_->TimerTick();
		DualModeController::TimerTick();
		}

		void HciSocketDevice::Close() {
		if (socket_) {
		socket_->Close();
		}
		void HciDevice::Close() {
		transport_->Close();
		DualModeController::Close();
		}

tools/rootcanal/model/devices/hci_device.h

0 → 100644

+49 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2022 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 <memory> // for shared_ptr, make_...
		#include <string> // for string

		#include "model/controller/dual_mode_controller.h" // for DualModeController
		#include "model/hci/hci_transport.h" // for HciTransport

		namespace rootcanal {

		class HciDevice : public DualModeController {
		public:
		HciDevice(std::shared_ptr<HciTransport> transport,
		const std::string& properties_filename);
		~HciDevice() = default;

		static std::shared_ptr<HciDevice> Create(
		std::shared_ptr<HciTransport> transport,
		const std::string& properties_filename) {
		return std::make_shared<HciDevice>(transport, properties_filename);
		}

		std::string GetTypeString() const override { return "hci_device"; }

		void TimerTick() override;

		void Close() override;

		private:
		std::shared_ptr<HciTransport> transport_;
		};

		} // namespace rootcanal