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

Commit 2b745985 authored by Josh Wu's avatar Josh Wu
Browse files

Audio: Migrate to AIDL API 

Tag: #refactor
Bug: 203490261
Test: atest BluetoothInstrumentationTests
Change-Id: I606fe51ce2e2c070646ce81966e69e82893f36a4
parent 43baa985

system/audio_bluetooth_hw/Android.bp

+9 −5
Original line number Diff line number Diff line
@@ -17,21 +17,25 @@ cc_library_shared { 
        "audio_bluetooth_hw.cc",

        "stream_apis.cc",

        "device_port_proxy.cc",

        "device_port_proxy_hidl.cc",

        "utils.cc",

    ],

    header_libs: ["libhardware_headers"],

    shared_libs: [

        "android.hardware.bluetooth.audio@2.0",

        "android.hardware.bluetooth.audio@2.1",

        "android.hardware.bluetooth.audio@2.2",

        "android.hardware.bluetooth.audio-V1-ndk",

        "libbluetooth_audio_session_aidl",

        "libaudioutils",

        "libbase",

        "libbluetooth_audio_session",

        "libbinder_ndk",

        "libcutils",

        "libfmq",

        "libhidlbase",

        "liblog",

        "libutils",

        // HIDL dependencies

        "android.hardware.bluetooth.audio@2.0",

        "android.hardware.bluetooth.audio@2.1",

        "libbluetooth_audio_session",

        "libhidlbase",

    ],

    cflags: [

        "-Wall",

system/audio_bluetooth_hw/device_port_proxy.cc

+206 −182

File changed.

Preview size limit exceeded, changes collapsed.

system/audio_bluetooth_hw/device_port_proxy.h

+137 −63
Original line number Diff line number Diff line 
/*

 * Copyright 2019 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.
@@ -16,8 +16,10 @@ 


#pragma once



#include <android/hardware/bluetooth/audio/2.2/types.h>

#include <aidl/android/hardware/bluetooth/audio/BluetoothAudioStatus.h>

#include <aidl/android/hardware/bluetooth/audio/SessionType.h>

#include <hardware/audio.h>



#include <condition_variable>

#include <mutex>

#include <unordered_map>
@@ -28,112 +30,184 @@ namespace android { 
namespace bluetooth {

namespace audio {



using SessionType_2_1 =

    ::android::hardware::bluetooth::audio::V2_1::SessionType;



// Proxy for Bluetooth Audio HW Module to communicate with Bluetooth Audio

// Session Control. All methods are not thread safe, so users must acquire a

// lock. Note: currently, in stream_apis.cc, if GetState() is only used for

// verbose logging, it is not locked, so the state may not be synchronized.

/***

 * Proxy for Bluetooth Audio HW Module to communicate with Bluetooth Audio

 * Session Control. All methods are not thread safe, so users must acquire a

 * lock. Note: currently, in stream_apis.cc, if GetState() is only used for

 * verbose logging, it is not locked, so the state may not be synchronized.

 ***/

class BluetoothAudioPort {

 public:

  BluetoothAudioPort();

  BluetoothAudioPort(){};

  virtual ~BluetoothAudioPort() = default;



  // Fetch output control / data path of BluetoothAudioPort and setup

  // callbacks into BluetoothAudioProvider. If SetUp() returns false, the audio

  // HAL must delete this BluetoothAudioPort and return EINVAL to caller

  bool SetUp(audio_devices_t devices);

  /***

   * Fetch output control / data path of BluetoothAudioPort and setup

   * callbacks into BluetoothAudioProvider. If SetUp() returns false, the audio

   * HAL must delete this BluetoothAudioPort and return EINVAL to caller

   ***/

  virtual bool SetUp(audio_devices_t) { return false; }



  /***

   * Unregister this BluetoothAudioPort from BluetoothAudioSessionControl.

   * Audio HAL must delete this BluetoothAudioPort after calling this.

   ***/

  virtual void TearDown() {}



  /***

   * When the Audio framework / HAL tries to query audio config about format,

   * channel mask and sample rate, it uses this function to fetch from the

   * Bluetooth stack

   ***/

  virtual bool LoadAudioConfig(audio_config_t*) const { return false; };



  /***

   * WAR to support Mono mode / 16 bits per sample

   ***/

  virtual void ForcePcmStereoToMono(bool) {}



  /***

   * When the Audio framework / HAL wants to change the stream state, it invokes

   * these 3 functions to control the Bluetooth stack (Audio Control Path).

   * Note: Both Start() and Suspend() will return true when there are no errors.

   * Called by Audio framework / HAL to start the stream

   ***/

  virtual bool Start() { return false; }



  /***

   * Called by Audio framework / HAL to suspend the stream

   ***/

  virtual bool Suspend() { return false; };



  /***

    virtual bool Suspend() { return false; }

    * Called by Audio framework / HAL to stop the stream

  ***/

  virtual void Stop() {}



  /***

   * Called by the Audio framework / HAL to fetch information about audio frames

   * presented to an external sink, or frames presented fror an internal sink

   ***/

  virtual bool GetPresentationPosition(uint64_t*, uint64_t*, timespec*) const {

    return false;

  }



  // Unregister this BluetoothAudioPort from BluetoothAudioSessionControl.

  // Audio HAL must delete this BluetoothAudioPort after calling this.

  void TearDown();

  /***

   * Called by the Audio framework / HAL when the metadata of the stream's

   * source has been changed.

   ***/

  virtual void UpdateSourceMetadata(const source_metadata*) const {};



  /***

   * Return the current BluetoothStreamState

   ***/

  virtual BluetoothStreamState GetState() const {

    return static_cast<BluetoothStreamState>(0);

  }



  // When the Audio framework / HAL tries to query audio config about format,

  // channel mask and sample rate, it uses this function to fetch from the

  // Bluetooth stack

  virtual bool LoadAudioConfig(audio_config_t* audio_cfg) const = 0;

  /***

   * Set the current BluetoothStreamState

   ***/

  virtual void SetState(BluetoothStreamState state) {}



  // WAR to support Mono mode / 16 bits per sample

  void ForcePcmStereoToMono(bool force) {

    is_stereo_to_mono_ = force;

  }

  virtual bool IsA2dp() const { return false; }



  virtual bool GetPreferredDataIntervalUs(size_t* interval_us) const {

    return false;

  };



  virtual size_t WriteData(const void* buffer, size_t bytes) const {

    return 0;

  };

  virtual size_t ReadData(void* buffer, size_t bytes) const { return 0; };

};



namespace aidl {



using ::aidl::android::hardware::bluetooth::audio::BluetoothAudioStatus;

using ::aidl::android::hardware::bluetooth::audio::SessionType;



class BluetoothAudioPortAidl : public BluetoothAudioPort {

 public:

  BluetoothAudioPortAidl();

  virtual ~BluetoothAudioPortAidl() = default;



  bool SetUp(audio_devices_t devices) override;



  void TearDown() override;



  void ForcePcmStereoToMono(bool force) override { is_stereo_to_mono_ = force; }



  // When the Audio framework / HAL wants to change the stream state, it invokes

  // these 3 functions to control the Bluetooth stack (Audio Control Path).

  // Note: Both Start() and Suspend() will return ture when there are no errors.

  // Called by Audio framework / HAL to start the stream

  bool Start();

  // Called by Audio framework / HAL to suspend the stream

  bool Suspend();

  // Called by Audio framework / HAL to stop the stream

  void Stop();

  bool Start() override;

  bool Suspend() override;

  void Stop() override;



  // Called by the Audio framework / HAL to fetch informaiton about audio frames

  // presented to an external sink, or frames presented fror an internal sink

  bool GetPresentationPosition(uint64_t* delay_ns, uint64_t* bytes,

                               timespec* timestamp) const;

  bool GetPresentationPosition(uint64_t* delay_ns, uint64_t* byte,

                               timespec* timestamp) const override;



  // Called by the Audio framework / HAL when the metadata of the stream's

  // source has been changed.

  void UpdateMetadata(const source_metadata* source_metadata) const;

  void UpdateSourceMetadata(

      const source_metadata* source_metadata) const override;



  void UpdateSinkMetadata(const sink_metadata* sink_metadata) const;

  /***

   * Called by the Audio framework / HAL when the metadata of the stream's

   * sink has been changed.

   ***/

  virtual void UpdateSinkMetadata(const sink_metadata* sink_metadata) const;



  // Return the current BluetoothStreamState

  BluetoothStreamState GetState() const;

  BluetoothStreamState GetState() const override;



  // Set the current BluetoothStreamState

  void SetState(BluetoothStreamState state);

  void SetState(BluetoothStreamState state) override;



  bool IsA2dp() const {

    return session_type_ == SessionType_2_1::A2DP_SOFTWARE_ENCODING_DATAPATH ||

           session_type_ == SessionType_2_1::A2DP_HARDWARE_OFFLOAD_DATAPATH;

  bool IsA2dp() const override {

    return session_type_ == SessionType::A2DP_SOFTWARE_ENCODING_DATAPATH ||

           session_type_ ==

               SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH;

  }



  bool GetPreferredDataIntervalUs(size_t* interval_us) const;

  bool GetPreferredDataIntervalUs(size_t* interval_us) const override;



 protected:

  uint16_t cookie_;

  BluetoothStreamState state_;

  SessionType_2_1 session_type_;

  SessionType session_type_;

  // WR to support Mono: True if fetching Stereo and mixing into Mono

  bool is_stereo_to_mono_ = false;

  bool in_use() const;

  virtual bool in_use() const;



 private:

  mutable std::mutex cv_mutex_;

  std::condition_variable internal_cv_;



  // Check and initialize session type for |devices| If failed, this

  // BluetoothAudioPort is not initialized and must be deleted.

  // BluetoothAudioPortAidl is not initialized and must be deleted.

  bool init_session_type(audio_devices_t device);



  bool CondwaitState(BluetoothStreamState state);



  void ControlResultHandler(

      const ::android::hardware::bluetooth::audio::V2_0::Status& status);

  void ControlResultHandler(const BluetoothAudioStatus& status);

  void SessionChangedHandler();

};



class BluetoothAudioPortOut : public BluetoothAudioPort {

class BluetoothAudioPortAidlOut : public BluetoothAudioPortAidl {

 public:

  ~BluetoothAudioPortOut() = default;

  ~BluetoothAudioPortAidlOut();



  // The audio data path to the Bluetooth stack (Software encoding)

  size_t WriteData(const void* buffer, size_t bytes) const;

  bool LoadAudioConfig(audio_config_t* audio_cfg) const;

  size_t WriteData(const void* buffer, size_t bytes) const override;

  bool LoadAudioConfig(audio_config_t* audio_cfg) const override;

};



class BluetoothAudioPortIn : public BluetoothAudioPort {

class BluetoothAudioPortAidlIn : public BluetoothAudioPortAidl {

 public:

  ~BluetoothAudioPortIn() = default;

  ~BluetoothAudioPortAidlIn();



  // The audio data path from the Bluetooth stack (Software decoded)

  size_t ReadData(void* buffer, size_t bytes) const;

  bool LoadAudioConfig(audio_config_t* audio_cfg) const;

  size_t ReadData(void* buffer, size_t bytes) const override;

  bool LoadAudioConfig(audio_config_t* audio_cfg) const override;

};



}  // namespace aidl

}  // namespace audio

}  // namespace bluetooth

}  // namespace android

system/audio_bluetooth_hw/device_port_proxy_hidl.cc

0 → 100644
+608 −0

File added.

Preview size limit exceeded, changes collapsed.

system/audio_bluetooth_hw/device_port_proxy_hidl.h

0 → 100644
+116 −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 <android/hardware/bluetooth/audio/2.1/types.h>

#include <hardware/audio.h>



#include <condition_variable>

#include <mutex>

#include <unordered_map>



#include "device_port_proxy.h"



enum class BluetoothStreamState : uint8_t;



namespace android {

namespace bluetooth {

namespace audio {

namespace hidl {



using SessionType_2_1 =

    ::android::hardware::bluetooth::audio::V2_1::SessionType;



class BluetoothAudioPortHidl : public BluetoothAudioPort {

 public:

  BluetoothAudioPortHidl();

  virtual ~BluetoothAudioPortHidl() = default;



  bool SetUp(audio_devices_t devices) override;



  void TearDown() override;



  void ForcePcmStereoToMono(bool force) override { is_stereo_to_mono_ = force; }



  bool Start() override;



  bool Suspend() override;



  void Stop() override;



  bool GetPresentationPosition(uint64_t* delay_ns, uint64_t* bytes,

                               timespec* timestamp) const override;



  void UpdateSourceMetadata(

      const source_metadata* source_metadata) const override;



  BluetoothStreamState GetState() const override;



  void SetState(BluetoothStreamState state) override;



  bool IsA2dp() const override {

    return session_type_hidl_ ==

               SessionType_2_1::A2DP_SOFTWARE_ENCODING_DATAPATH ||

           session_type_hidl_ ==

               SessionType_2_1::A2DP_HARDWARE_OFFLOAD_DATAPATH;

  }



  bool GetPreferredDataIntervalUs(size_t* interval_us) const override;



 protected:

  SessionType_2_1 session_type_hidl_;

  uint16_t cookie_;

  BluetoothStreamState state_;

  // WR to support Mono: True if fetching Stereo and mixing into Mono

  bool is_stereo_to_mono_ = false;



  bool in_use() const;



 private:

  mutable std::mutex cv_mutex_;

  std::condition_variable internal_cv_;



  bool init_session_type(audio_devices_t device);



  bool CondwaitState(BluetoothStreamState state);



  void ControlResultHandler(

      const ::android::hardware::bluetooth::audio::V2_0::Status& status);



  void SessionChangedHandler();

};



class BluetoothAudioPortHidlOut : public BluetoothAudioPortHidl {

 public:

  ~BluetoothAudioPortHidlOut();



  size_t WriteData(const void* buffer, size_t bytes) const override;

  bool LoadAudioConfig(audio_config_t* audio_cfg) const override;

};



class BluetoothAudioPortHidlIn : public BluetoothAudioPortHidl {

 public:

  ~BluetoothAudioPortHidlIn();



  size_t ReadData(void* buffer, size_t bytes) const override;

  bool LoadAudioConfig(audio_config_t* audio_cfg) const override;

};



}  // namespace hidl

}  // namespace audio

}  // namespace bluetooth

}  // namespace android
 
 No newline at end of file