Merge "Audio: Migrate to AIDL API" am: 98a68a03d1 (8757d21e) · Commits · e / os / android_packages_modules_Bluetooth

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