Merge "RootCanal: Simplify HciTransport interface" into main (c3dcae45) · Commits · e / os / android_packages_modules_Bluetooth

tools/rootcanal/model/devices/hci_device.cc

+23 −15

Original line number	Diff line number	Diff line
		@@ -54,30 +54,38 @@ HciDevice::HciDevice(std::shared_ptr<HciTransport> transport,
		}));

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

		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](PacketType packet_type,
		const std::shared_ptr<std::vector<uint8_t>> packet) {
		switch (packet_type) {
		case PacketType::COMMAND:
		HandleCommand(packet);
		break;
		case PacketType::ACL:
		HandleAcl(packet);
		break;
		case PacketType::SCO:
		HandleSco(packet);
		break;
		case PacketType::ISO:
		HandleIso(packet);
		break;
		default:
		ASSERT(false);
		break;
		}
		},
		[this]() {
		INFO(id_, "HCI transport closed");

tools/rootcanal/model/hci/hci_sniffer.cc

+10 −41

Original line number	Diff line number	Diff line
		@@ -73,32 +73,14 @@ void HciSniffer::AppendRecord(PacketDirection packet_direction,
		output_->flush();
		}

		void HciSniffer::RegisterCallbacks(PacketCallback command_callback,
		PacketCallback acl_callback,
		PacketCallback sco_callback,
		PacketCallback iso_callback,
		void HciSniffer::RegisterCallbacks(PacketCallback packet_callback,
		CloseCallback close_callback) {
		transport_->RegisterCallbacks(
		[this,
		command_callback](const std::shared_ptr<std::vector<uint8_t>> command) {
		AppendRecord(PacketDirection::HOST_TO_CONTROLLER, PacketType::COMMAND,
		*command);
		command_callback(command);
		},
		[this, acl_callback](const std::shared_ptr<std::vector<uint8_t>> acl) {
		AppendRecord(PacketDirection::HOST_TO_CONTROLLER, PacketType::ACL,
		*acl);
		acl_callback(acl);
		},
		[this, sco_callback](const std::shared_ptr<std::vector<uint8_t>> sco) {
		AppendRecord(PacketDirection::HOST_TO_CONTROLLER, PacketType::SCO,
		*sco);
		sco_callback(sco);
		},
		[this, iso_callback](const std::shared_ptr<std::vector<uint8_t>> iso) {
		AppendRecord(PacketDirection::HOST_TO_CONTROLLER, PacketType::ISO,
		*iso);
		iso_callback(iso);
		[this, packet_callback](
		PacketType packet_type,
		const std::shared_ptr<std::vector<uint8_t>> packet) {
		AppendRecord(PacketDirection::HOST_TO_CONTROLLER, packet_type, *packet);
		packet_callback(packet_type, packet);
		},
		close_callback);
		}
		@@ -112,23 +94,10 @@ void HciSniffer::Close() {
		}
		}

		void HciSniffer::SendEvent(const std::vector<uint8_t>& packet) {
		AppendRecord(PacketDirection::CONTROLLER_TO_HOST, PacketType::EVENT, packet);
		transport_->SendEvent(packet);
		}

		void HciSniffer::SendAcl(const std::vector<uint8_t>& packet) {
		AppendRecord(PacketDirection::CONTROLLER_TO_HOST, PacketType::ACL, packet);
		transport_->SendAcl(packet);
		}

		void HciSniffer::SendSco(const std::vector<uint8_t>& packet) {
		AppendRecord(PacketDirection::CONTROLLER_TO_HOST, PacketType::SCO, packet);
		transport_->SendSco(packet);
		void HciSniffer::Send(PacketType packet_type,
		const std::vector<uint8_t>& packet) {
		AppendRecord(PacketDirection::CONTROLLER_TO_HOST, packet_type, packet);
		transport_->Send(packet_type, packet);
		}

		void HciSniffer::SendIso(const std::vector<uint8_t>& packet) {
		AppendRecord(PacketDirection::CONTROLLER_TO_HOST, PacketType::ISO, packet);
		transport_->SendIso(packet);
		}
		} // namespace rootcanal

tools/rootcanal/model/hci/hci_sniffer.h

+3 −12

Original line number	Diff line number	Diff line
		@@ -52,22 +52,13 @@ class HciSniffer : public HciTransport {
		void SetOutputStream(std::shared_ptr<std::ostream> outputStream);
		void SetPcapFilter(std::shared_ptr<PcapFilter> filter);

		void SendEvent(const std::vector<uint8_t>& packet) override;
		void Send(PacketType packet_type,
		const std::vector<uint8_t>& packet) override;

		void SendAcl(const std::vector<uint8_t>& packet) override;

		void SendSco(const std::vector<uint8_t>& packet) override;

		void SendIso(const std::vector<uint8_t>& packet) override;

		void RegisterCallbacks(PacketCallback command_callback,
		PacketCallback acl_callback,
		PacketCallback sco_callback,
		PacketCallback iso_callback,
		void RegisterCallbacks(PacketCallback packet_callback,
		CloseCallback close_callback) override;

		void Tick() override;

		void Close() override;

		private:

tools/rootcanal/model/hci/hci_socket_transport.cc

+11 −30

Original line number	Diff line number	Diff line
		@@ -23,43 +23,40 @@ namespace rootcanal {
		HciSocketTransport::HciSocketTransport(std::shared_ptr<AsyncDataChannel> socket)
		: socket_(socket) {}

		void HciSocketTransport::RegisterCallbacks(PacketCallback command_callback,
		PacketCallback acl_callback,
		PacketCallback sco_callback,
		PacketCallback iso_callback,
		void HciSocketTransport::RegisterCallbacks(PacketCallback packet_callback,
		CloseCallback close_callback) {
		// TODO: Avoid the copy here by using new buffer in H4DataChannel
		h4_ = H4DataChannelPacketizer(
		socket_,
		[command_callback](const std::vector<uint8_t>& raw_command) {
		[packet_callback](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);
		command_callback(packet_copy);
		packet_callback(PacketType::COMMAND, packet_copy);
		},
		[](const std::vector<uint8_t>&) {
		FATAL("Unexpected Event in HciSocketTransport!");
		},
		[acl_callback](const std::vector<uint8_t>& raw_acl) {
		[packet_callback](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);
		acl_callback(packet_copy);
		packet_callback(PacketType::ACL, packet_copy);
		},
		[sco_callback](const std::vector<uint8_t>& raw_sco) {
		[packet_callback](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);
		sco_callback(packet_copy);
		packet_callback(PacketType::SCO, packet_copy);
		},
		[iso_callback](const std::vector<uint8_t>& raw_iso) {
		[packet_callback](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);
		iso_callback(packet_copy);
		packet_callback(PacketType::ISO, packet_copy);
		},
		close_callback);
		}

		void HciSocketTransport::Tick() { h4_.OnDataReady(socket_); }

		void HciSocketTransport::SendHci(PacketType packet_type,
		void HciSocketTransport::Send(PacketType packet_type,
		const std::vector<uint8_t>& packet) {
		if (!socket_ \|\| !socket_->Connected()) {
		INFO("Closed socket. Dropping packet of type {}", packet_type);
		@@ -69,22 +66,6 @@ void HciSocketTransport::SendHci(PacketType packet_type,
		h4_.Send(type, packet.data(), packet.size());
		}

		void HciSocketTransport::SendEvent(const std::vector<uint8_t>& packet) {
		SendHci(PacketType::EVENT, packet);
		}

		void HciSocketTransport::SendAcl(const std::vector<uint8_t>& packet) {
		SendHci(PacketType::ACL, packet);
		}

		void HciSocketTransport::SendSco(const std::vector<uint8_t>& packet) {
		SendHci(PacketType::SCO, packet);
		}

		void HciSocketTransport::SendIso(const std::vector<uint8_t>& packet) {
		SendHci(PacketType::ISO, packet);
		}

		void HciSocketTransport::Close() { socket_->Close(); }

		} // namespace rootcanal

tools/rootcanal/model/hci/hci_socket_transport.h

+3 −14

Original line number	Diff line number	Diff line
		@@ -36,27 +36,16 @@ class HciSocketTransport : public HciTransport {
		return std::make_shared<HciSocketTransport>(socket);
		}

		void SendEvent(const std::vector<uint8_t>& packet) override;
		void Send(PacketType packet_type,
		const std::vector<uint8_t>& packet) override;

		void SendAcl(const std::vector<uint8_t>& packet) override;

		void SendSco(const std::vector<uint8_t>& packet) override;

		void SendIso(const std::vector<uint8_t>& packet) override;

		void RegisterCallbacks(PacketCallback command_callback,
		PacketCallback acl_callback,
		PacketCallback sco_callback,
		PacketCallback iso_callback,
		void RegisterCallbacks(PacketCallback packet_callback,
		CloseCallback close_callback) override;

		void Tick() override;

		void Close() override;

		private:
		void SendHci(PacketType packet_type, const std::vector<uint8_t>& packet);

		std::shared_ptr<AsyncDataChannel> socket_;
		H4DataChannelPacketizer h4_{socket_,
		[](const std::vector<uint8_t>&) {},