Merge "HCI HAL: HCI Proxy Audio Software offload integration" into main (1a16e134) · Commits · e / os / android_hardware_interfaces

bluetooth/aidl/Android.bp

+0 −8

Original line number	Diff line number	Diff line
		@@ -16,13 +16,6 @@ aidl_interface {
		srcs: ["android/hardware/bluetooth/*.aidl"],
		stability: "vintf",
		backend: {
		cpp: {
		// FIXME should this be disabled?
		// prefer NDK backend which can be used anywhere
		// If you disable this, you also need to delete the C++
		// translate code.
		enabled: true,
		},
		rust: {
		enabled: true,
		},
		@@ -44,5 +37,4 @@ aidl_interface {
		},
		],
		frozen: true,

		}

bluetooth/aidl/default/Android.bp

+32 −51

Original line number	Diff line number	Diff line
		@@ -2,81 +2,62 @@ package {
		default_applicable_licenses: ["Android-Apache-2.0"],
		}

		cc_defaults {
		name: "android.hardware.bluetooth-service-build-defaults",
		cc_library_static {
		name: "libbluetoothhcihalimpl",
		vendor_available: true,
		host_supported: true,
		srcs: [
		"BluetoothHci.cpp",
		"net_bluetooth_mgmt.cpp",
		],
		cflags: [
		"-Wall",
		"-Wextra",
		],
		shared_libs: [
		"android.hardware.bluetooth-V1-ndk",
		"libbase",
		"libbinder_ndk",
		"libcutils",
		"libhidlbase",
		"liblog",
		"libutils",
		header_libs: [
		"libbluetooth_offload_hal_headers",
		],
		static_libs: [
		"android.hardware.bluetooth.async",
		"android.hardware.bluetooth.hci",
		],
		}

		cc_library_static {
		name: "libbluetoothhcihalimpl",
		vendor_available: true,
		host_supported: true,
		defaults: ["android.hardware.bluetooth-service-build-defaults"],
		srcs: [
		"BluetoothHci.cpp",
		"net_bluetooth_mgmt.cpp",
		shared_libs: [
		"libbase",
		"libcutils",
		"liblog",
		"libutils",
		],
		}

		cc_binary {
		rust_binary {
		name: "android.hardware.bluetooth-service.default",
		crate_name: "bluetooth_hci_hal_server",
		relative_install_path: "hw",
		init_rc: ["bluetooth-service-default.rc"],
		vintf_fragments: [":manifest_android.hardware.bluetooth-service.default.xml"],
		vendor: true,
		defaults: ["android.hardware.bluetooth-service-build-defaults"],
		srcs: [
		"service.cpp",
		],
		shared_libs: [
		"android.hardware.bluetooth-V1-ndk",
		"libbase",
		"libbinder_ndk",
		"libhidlbase",
		"libutils",
		"liblog",
		],
		static_libs: [
		"libbluetoothhcihalimpl",
		],
		}

		cc_fuzz {
		name: "android.hardware.bluetooth-service.default_fuzzer",
		host_supported: true,
		defaults: ["service_fuzzer_defaults"],
		srcs: [
		"test/fuzzer.cpp",
		prefer_rlib: true,
		srcs: ["main.rs"],
		rustlibs: [
		"android.hardware.bluetooth-V1-rust",
		"libbluetooth_offload_hal",
		"libbluetooth_offload_leaudio_hci",
		"libbinder_rs",
		"liblogger",
		"liblog_rust",
		],
		static_libs: [
		"android.hardware.bluetooth.async",
		"android.hardware.bluetooth.hci",
		"android.hardware.bluetooth-V1-ndk",
		"libbluetoothhcihalimpl",
		"liblog",
		],
		fuzz_config: {
		componentid: 27441,
		cc: [
		"mylesgw@google.com",
		shared_libs: [
		"libbase",
		"libc++",
		"libcutils",
		"liblog",
		"libutils",
		],
		},
		}

		filegroup {

bluetooth/aidl/default/BluetoothHci.cpp

+261 −266

Original line number	Diff line number	Diff line
		/*
		* Copyright 2022 The Android Open Source Project
		* Copyright 2024 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.
		@@ -16,18 +16,20 @@

		#define LOG_TAG "android.hardware.bluetooth.service.default"

		#include "BluetoothHci.h"

		#include <cutils/properties.h>
		#include <fcntl.h>
		#include <netdb.h>
		#include <netinet/in.h>
		#include <poll.h>
		#include <hal/ffi.h>
		#include <string.h>
		#include <sys/uio.h>
		#include <termios.h>

		#include <future>
		#include <memory>
		#include <vector>

		#include "async_fd_watcher.h"
		#include "h4_protocol.h"
		#include "log/log.h"
		#include "net_bluetooth_mgmt.h"

		namespace {
		int SetTerminalRaw(int fd) {
		@@ -44,12 +46,9 @@ int SetTerminalRaw(int fd) {

		using namespace ::android::hardware::bluetooth::hci;
		using namespace ::android::hardware::bluetooth::async;
		using aidl::android::hardware::bluetooth::Status;

		namespace aidl::android::hardware::bluetooth::impl {

		void OnDeath(void* cookie);

		std::optional<std::string> GetSystemProperty(const std::string& property) {
		std::array<char, PROPERTY_VALUE_MAX> value_array{0};
		auto value_len = property_get(property.c_str(), value_array.data(), nullptr);
		@@ -63,62 +62,43 @@ bool starts_with(const std::string& str, const std::string& prefix) {
		return str.compare(0, prefix.length(), prefix) == 0;
		}

		class BluetoothDeathRecipient {
		class Hal {
		public:
		BluetoothDeathRecipient(BluetoothHci* hci) : mHci(hci) {}

		void LinkToDeath(const std::shared_ptr<IBluetoothHciCallbacks>& cb) {
		mCb = cb;
		clientDeathRecipient_ = AIBinder_DeathRecipient_new(OnDeath);
		auto linkToDeathReturnStatus = AIBinder_linkToDeath(
		mCb->asBinder().get(), clientDeathRecipient_, this /* cookie */);
		LOG_ALWAYS_FATAL_IF(linkToDeathReturnStatus != STATUS_OK,
		"Unable to link to death recipient");
		Hal(const std::string& dev_path = "/dev/hvc5") {
		char property_bytes[PROPERTY_VALUE_MAX];
		property_get("vendor.ser.bt-uart", property_bytes, dev_path.c_str());
		mDevPath = std::string(property_bytes);
		}

		void UnlinkToDeath(const std::shared_ptr<IBluetoothHciCallbacks>& cb) {
		LOG_ALWAYS_FATAL_IF(cb != mCb, "Unable to unlink mismatched pointers");
		static void Initialize(void* instance,
		const struct hal_callbacks* callbacks) {
		static_cast<Hal*>(instance)->Initialize(callbacks);
		}

		void serviceDied() {
		if (mCb != nullptr && !AIBinder_isAlive(mCb->asBinder().get())) {
		ALOGE("Bluetooth remote service has died");
		} else {
		ALOGE("BluetoothDeathRecipient::serviceDied called but service not dead");
		return;
		}
		{
		std::lock_guard<std::mutex> guard(mHasDiedMutex);
		has_died_ = true;
		}
		mHci->close();
		}
		BluetoothHci* mHci;
		std::shared_ptr<IBluetoothHciCallbacks> mCb;
		AIBinder_DeathRecipient* clientDeathRecipient_;
		bool getHasDied() {
		std::lock_guard<std::mutex> guard(mHasDiedMutex);
		return has_died_;
		static void Close(void* instance) { static_cast<Hal*>(instance)->Close(); }

		static void SendCommand(void* instance, const uint8_t* data, size_t len) {
		static_cast<Hal*>(instance)->SendCommand(
		std::vector<uint8_t>(data, data + len));
		}

		private:
		std::mutex mHasDiedMutex;
		bool has_died_{false};
		};
		static void SendAcl(void* instance, const uint8_t* data, size_t len) {
		static_cast<Hal*>(instance)->SendAcl(
		std::vector<uint8_t>(data, data + len));
		}

		void OnDeath(void* cookie) {
		auto* death_recipient = static_cast<BluetoothDeathRecipient*>(cookie);
		death_recipient->serviceDied();
		static void SendSco(void* instance, const uint8_t* data, size_t len) {
		static_cast<Hal*>(instance)->SendSco(
		std::vector<uint8_t>(data, data + len));
		}

		BluetoothHci::BluetoothHci(const std::string& dev_path) {
		char property_bytes[PROPERTY_VALUE_MAX];
		property_get("vendor.ser.bt-uart", property_bytes, dev_path.c_str());
		mDevPath = std::string(property_bytes);
		mDeathRecipient = std::make_shared<BluetoothDeathRecipient>(this);
		static void SendIso(void* instance, const uint8_t* data, size_t len) {
		static_cast<Hal*>(instance)->SendIso(
		std::vector<uint8_t>(data, data + len));
		}

		int BluetoothHci::getFdFromDevPath() {
		private:
		int getFdFromDevPath() {
		int fd = open(mDevPath.c_str(), O_RDWR);
		if (fd < 0) {
		ALOGE("Could not connect to bt: %s (%s)", mDevPath.c_str(),
		@@ -132,7 +112,7 @@ int BluetoothHci::getFdFromDevPath() {
		return fd;
		}

		void BluetoothHci::reset() {
		void reset() {
		// Send a reset command and wait until the command complete comes back.

		std::vector<uint8_t> reset = {0x03, 0x0c, 0x00};
		@@ -182,8 +162,7 @@ void BluetoothHci::reset() {
		mFdWatcher.WatchFdForNonBlockingReads(mFd,
		[this](int) { mH4->OnDataReady(); });

		ndk::ScopedAStatus result = send(PacketType::COMMAND, reset);
		if (!result.isOk()) {
		if (!send(PacketType::COMMAND, reset)) {
		ALOGE("Error sending reset command");
		}
		auto status = resetFuture.wait_for(std::chrono::seconds(1));
		@@ -197,15 +176,9 @@ void BluetoothHci::reset() {
		resetPromise.reset();
		}

		ndk::ScopedAStatus BluetoothHci::initialize(
		const std::shared_ptr<IBluetoothHciCallbacks>& cb) {
		void Initialize(const struct hal_callbacks* callbacks) {
		ALOGI(__func__);

		if (cb == nullptr) {
		ALOGE("cb == nullptr! -> Unable to call initializationComplete(ERR)");
		return ndk::ScopedAStatus::fromServiceSpecificError(STATUS_BAD_VALUE);
		}

		HalState old_state = HalState::READY;
		{
		std::lock_guard<std::mutex> guard(mStateMutex);
		@@ -218,12 +191,13 @@ ndk::ScopedAStatus BluetoothHci::initialize(

		if (old_state != HalState::READY) {
		ALOGE("initialize: Unexpected State %d", static_cast<int>(old_state));
		close();
		cb->initializationComplete(Status::ALREADY_INITIALIZED);
		return ndk::ScopedAStatus::ok();
		Close();
		callbacks->initialization_complete(callbacks->handle,
		STATUS_ALREADY_INITIALIZED);
		return;
		}

		mCb = cb;
		mCallbacks = std::make_unique<struct hal_callbacks>(*callbacks);
		management_.reset(new NetBluetoothMgmt);
		mFd = management_->openHci();
		if (mFd < 0) {
		@@ -233,13 +207,12 @@ ndk::ScopedAStatus BluetoothHci::initialize(
		mFd = getFdFromDevPath();
		if (mFd < 0) {
		mState = HalState::READY;
		cb->initializationComplete(Status::UNABLE_TO_OPEN_INTERFACE);
		return ndk::ScopedAStatus::ok();
		mCallbacks->initialization_complete(mCallbacks->handle,
		STATUS_UNABLE_TO_OPEN_INTERFACE);
		return;
		}
		}

		mDeathRecipient->LinkToDeath(mCb);

		// TODO: HCI Reset on emulators since the bluetooth controller
		// cannot be powered on/off during the HAL setup; and the stack
		// might received spurious packets/events during boottime.
		@@ -248,8 +221,8 @@ ndk::ScopedAStatus BluetoothHci::initialize(
		const std::string kBoardProperty = "ro.product.board";
		const std::string kCuttlefishBoard = "cutf";
		auto board_name = GetSystemProperty(kBoardProperty);
		if (board_name.has_value() && (
		starts_with(board_name.value(), "cutf") \|\|
		if (board_name.has_value() &&
		(starts_with(board_name.value(), "cutf") \|\|
		starts_with(board_name.value(), "goldfish"))) {
		reset();
		}
		@@ -260,16 +233,20 @@ ndk::ScopedAStatus BluetoothHci::initialize(
		LOG_ALWAYS_FATAL("Unexpected command!");
		},
		[this](const std::vector<uint8_t>& raw_acl) {
		mCb->aclDataReceived(raw_acl);
		mCallbacks->acl_received(mCallbacks->handle, raw_acl.data(),
		raw_acl.size());
		},
		[this](const std::vector<uint8_t>& raw_sco) {
		mCb->scoDataReceived(raw_sco);
		mCallbacks->sco_received(mCallbacks->handle, raw_sco.data(),
		raw_sco.size());
		},
		[this](const std::vector<uint8_t>& raw_event) {
		mCb->hciEventReceived(raw_event);
		mCallbacks->event_received(mCallbacks->handle, raw_event.data(),
		raw_event.size());
		},
		[this](const std::vector<uint8_t>& raw_iso) {
		mCb->isoDataReceived(raw_iso);
		mCallbacks->iso_received(mCallbacks->handle, raw_iso.data(),
		raw_iso.size());
		},
		[this]() {
		ALOGI("HCI socket device disconnected");
		@@ -282,21 +259,12 @@ ndk::ScopedAStatus BluetoothHci::initialize(
		std::lock_guard<std::mutex> guard(mStateMutex);
		mState = HalState::ONE_CLIENT;
		}
		ALOGI("initialization complete");
		auto status = mCb->initializationComplete(Status::SUCCESS);
		if (!status.isOk()) {
		if (!mDeathRecipient->getHasDied()) {
		ALOGE("Error sending init callback, but no death notification");
		}
		close();
		return ndk::ScopedAStatus::fromServiceSpecificError(
		STATUS_FAILED_TRANSACTION);
		}

		return ndk::ScopedAStatus::ok();
		ALOGI("initialization complete");
		mCallbacks->initialization_complete(mCallbacks->handle, STATUS_SUCCESS);
		}

		ndk::ScopedAStatus BluetoothHci::close() {
		void Close() {
		ALOGI(__func__);
		{
		std::lock_guard<std::mutex> guard(mStateMutex);
		@@ -304,8 +272,9 @@ ndk::ScopedAStatus BluetoothHci::close() {
		LOG_ALWAYS_FATAL_IF(mState == HalState::INITIALIZING,
		"mState is INITIALIZING");
		ALOGI("Already closed");
		return ndk::ScopedAStatus::ok();
		return;
		}
		mCallbacks.reset();
		mState = HalState::CLOSING;
		}

		@@ -322,43 +291,69 @@ ndk::ScopedAStatus BluetoothHci::close() {
		mState = HalState::READY;
		mH4 = nullptr;
		}
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus BluetoothHci::sendHciCommand(
		const std::vector<uint8_t>& packet) {
		return send(PacketType::COMMAND, packet);
		void SendCommand(const std::vector<uint8_t>& data) {
		send(PacketType::COMMAND, data);
		}

		ndk::ScopedAStatus BluetoothHci::sendAclData(
		const std::vector<uint8_t>& packet) {
		return send(PacketType::ACL_DATA, packet);
		void SendAcl(const std::vector<uint8_t>& data) {
		send(PacketType::ACL_DATA, data);
		}

		ndk::ScopedAStatus BluetoothHci::sendScoData(
		const std::vector<uint8_t>& packet) {
		return send(PacketType::SCO_DATA, packet);
		void SendSco(const std::vector<uint8_t>& data) {
		send(PacketType::SCO_DATA, data);
		}

		ndk::ScopedAStatus BluetoothHci::sendIsoData(
		const std::vector<uint8_t>& packet) {
		return send(PacketType::ISO_DATA, packet);
		void SendIso(const std::vector<uint8_t>& data) {
		send(PacketType::ISO_DATA, data);
		}

		ndk::ScopedAStatus BluetoothHci::send(PacketType type,
		const std::vector<uint8_t>& v) {
		bool send(PacketType type, const std::vector<uint8_t>& v) {
		if (v.empty()) {
		ALOGE("Packet is empty, no data was found to be sent");
		return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
		return false;
		}

		std::lock_guard<std::mutex> guard(mStateMutex);
		if (mH4 == nullptr) {
		return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
		ALOGE("Illegal State");
		return false;
		}

		mH4->Send(type, v);
		return ndk::ScopedAStatus::ok();
		}
		return true;
		}

		std::unique_ptr<struct hal_callbacks> mCallbacks;
		std::string mDevPath;
		int mFd{-1};
		::android::hardware::bluetooth::async::AsyncFdWatcher mFdWatcher;
		std::shared_ptr<::android::hardware::bluetooth::hci::H4Protocol> mH4;
		std::unique_ptr<NetBluetoothMgmt> management_{};

		// Don't close twice or open before close is complete
		std::mutex mStateMutex;
		enum class HalState {
		READY,
		INITIALIZING,
		ONE_CLIENT,
		CLOSING,
		} mState{HalState::READY};
		};

		} // namespace aidl::android::hardware::bluetooth::impl

		extern "C" {

		using namespace aidl::android::hardware::bluetooth::impl;

		struct hal_interface hal_new() {
		return (struct hal_interface){
		.handle = new Hal(),
		.initialize = &Hal::Initialize,
		.close = &Hal::Close,
		.send_command = &Hal::SendCommand,
		.send_acl = &Hal::SendAcl,
		.send_sco = &Hal::SendSco,
		.send_iso = &Hal::SendIso,
		};
		}
		}

bluetooth/aidl/default/BluetoothHci.h

deleted100644 → 0

+0 −87

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 <aidl/android/hardware/bluetooth/BnBluetoothHci.h>
		#include <aidl/android/hardware/bluetooth/IBluetoothHciCallbacks.h>

		#include <future>
		#include <string>

		#include "async_fd_watcher.h"
		#include "h4_protocol.h"
		#include "net_bluetooth_mgmt.h"

		namespace aidl::android::hardware::bluetooth::impl {

		class BluetoothDeathRecipient;

		// This Bluetooth HAL implementation connects with a serial port at dev_path_.
		class BluetoothHci : public BnBluetoothHci {
		public:
		BluetoothHci(const std::string& dev_path = "/dev/hvc5");

		ndk::ScopedAStatus initialize(
		const std::shared_ptr<IBluetoothHciCallbacks>& cb) override;

		ndk::ScopedAStatus sendHciCommand(
		const std::vector<uint8_t>& packet) override;

		ndk::ScopedAStatus sendAclData(const std::vector<uint8_t>& packet) override;

		ndk::ScopedAStatus sendScoData(const std::vector<uint8_t>& packet) override;

		ndk::ScopedAStatus sendIsoData(const std::vector<uint8_t>& packet) override;

		ndk::ScopedAStatus close() override;

		static void OnPacketReady();

		static BluetoothHci* get();

		private:
		int mFd{-1};
		std::shared_ptr<IBluetoothHciCallbacks> mCb = nullptr;

		std::shared_ptr<::android::hardware::bluetooth::hci::H4Protocol> mH4;

		std::shared_ptr<BluetoothDeathRecipient> mDeathRecipient;

		std::string mDevPath;

		::android::hardware::bluetooth::async::AsyncFdWatcher mFdWatcher;

		int getFdFromDevPath();
		[[nodiscard]] ndk::ScopedAStatus send(
		::android::hardware::bluetooth::hci::PacketType type,
		const std::vector<uint8_t>& packet);
		std::unique_ptr<NetBluetoothMgmt> management_{};

		// Send a reset command and discard all packets until a reset is received.
		void reset();

		// Don't close twice or open before close is complete
		std::mutex mStateMutex;
		enum class HalState {
		READY,
		INITIALIZING,
		ONE_CLIENT,
		CLOSING,
		} mState{HalState::READY};
		};

		} // namespace aidl::android::hardware::bluetooth::impl

bluetooth/aidl/default/main.rs

0 → 100644

+58 −0

Original line number	Diff line number	Diff line
		// Copyright 2024, 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.

		use android_hardware_bluetooth::aidl::android::hardware::bluetooth::IBluetoothHci::{
		self,
		IBluetoothHci as _
		};
		use android_hardware_bluetooth::binder;
		use bluetooth_offload_hal::{ HciHalProxy, CInterface };
		use bluetooth_offload_leaudio_hci::LeAudioModuleBuilder;
		use log;
		use std::panic;

		fn new_hal() -> CInterface {
		extern "C" { fn hal_new() -> CInterface; }
		unsafe { hal_new() }
		}

		fn main() {
		logger::init(
		logger::Config::default()
		.with_max_level(log::LevelFilter::Debug)
		.with_tag_on_device("android.hardware.bluetooth"),
		);

		panic::set_hook(Box::new(\|panic_info\| {
		log::error!("{}", panic_info);
		}));

		log::info!("Bluetooth HAL starting up");

		binder::ProcessState::set_thread_pool_max_thread_count(0);
		binder::ProcessState::start_thread_pool();

		binder::add_service(
		&format!("{}/default", IBluetoothHci::BpBluetoothHci::get_descriptor()),
		IBluetoothHci::BnBluetoothHci::new_binder(
		HciHalProxy::new(
		vec![ Box::new(LeAudioModuleBuilder {}) ],
		new_hal()
		),
		binder::BinderFeatures::default(),
		).as_binder()
		).expect("Failed to register service");

		binder::ProcessState::join_thread_pool();
		}