Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a4649608 authored by Antoine Soulier's avatar Antoine Soulier Committed by Automerger Merge Worker
Browse files

Merge "HCI HAL: HCI Proxy Audio Software offload integration" into main am: 1a16e134 

Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/3343023



Change-Id: Ibaafcbbbc0abc7f0034a6e550482100214b9d0ad
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 0d1073c3 1a16e134

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();

}