bta/le_audio/client_audio.cc - platform/system/bt - Git at Google

 /******************************************************************************
  *
  * Copyright 2019 HIMSA II K/S - www.himsa.com. Represented by EHIMA -
  * www.ehima.com
  *
  * 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.
  *
  ******************************************************************************/

 #include "client_audio.h"

 #include "audio_hal_interface/le_audio_software.h"
 #include "btu.h"
 #include "common/repeating_timer.h"
 #include "common/time_util.h"
 #include "osi/include/wakelock.h"

 using bluetooth::audio::le_audio::LeAudioClientInterface;

 namespace {
 LeAudioCodecConfiguration source_codec_config;
 bluetooth::common::RepeatingTimer audio_timer;
 LeAudioClientInterface* leAudioClientInterface = nullptr;
 LeAudioClientInterface::Sink* sinkClientInterface = nullptr;
 LeAudioClientInterface::Source* sourceClientInterface = nullptr;
 LeAudioClientAudioSinkReceiver* localAudioSinkReceiver = nullptr;
 LeAudioClientAudioSourceReceiver* localAudioSourceReceiver = nullptr;

 enum {
   HAL_UNINITIALIZED,
   HAL_STOPPED,
   HAL_STARTED,
 } le_audio_sink_hal_state,
     le_audio_source_hal_state;

 struct AudioHalStats {
   size_t media_read_total_underflow_bytes;
   size_t media_read_total_underflow_count;
   uint64_t media_read_last_underflow_us;

   AudioHalStats() { Reset(); }

   void Reset() {
     media_read_total_underflow_bytes = 0;
     media_read_total_underflow_count = 0;
     media_read_last_underflow_us = 0;
   }
 };

 AudioHalStats stats;

 bool le_audio_sink_on_resume_req(bool start_media_task);
 bool le_audio_sink_on_suspend_req();

 void send_audio_data() {
   uint32_t bytes_per_tick =
       (source_codec_config.num_channels * source_codec_config.sample_rate *
        source_codec_config.data_interval_us / 1000 *
        (source_codec_config.bits_per_sample / 8)) /
       1000;

   std::vector<uint8_t> data(bytes_per_tick);

   uint32_t bytes_read = 0;
   if (sinkClientInterface != nullptr) {
     bytes_read = sinkClientInterface->Read(data.data(), bytes_per_tick);
   } else {
     LOG(ERROR) << __func__ << ", no LE Audio sink client interface - aborting.";
     return;
   }

   // LOG(INFO) << __func__ << ", bytes_read: " << static_cast<int>(bytes_read)
   //          << ", bytes_per_tick: " << static_cast<int>(bytes_per_tick);

   if (bytes_read < bytes_per_tick) {
     stats.media_read_total_underflow_bytes += bytes_per_tick - bytes_read;
     stats.media_read_total_underflow_count++;
     stats.media_read_last_underflow_us =
         bluetooth::common::time_get_os_boottime_us();
   }

   if (localAudioSinkReceiver != nullptr) {
     localAudioSinkReceiver->OnAudioDataReady(data);
   }
 }

 void start_audio_ticks() {
   wakelock_acquire();
   audio_timer.SchedulePeriodic(
       get_main_thread()->GetWeakPtr(), FROM_HERE, base::Bind(&send_audio_data),
       base::TimeDelta::FromMicroseconds(source_codec_config.data_interval_us));
 }

 void stop_audio_ticks() {
   audio_timer.CancelAndWait();
   wakelock_release();
 }

 bool le_audio_sink_on_resume_req(bool start_media_task) {
   if (localAudioSinkReceiver != nullptr) {
     // Call OnAudioResume and block till it returns.
     std::promise<void> do_resume_promise;
     std::future<void> do_resume_future = do_resume_promise.get_future();
     bt_status_t status = do_in_main_thread(
         FROM_HERE,
         base::BindOnce(&LeAudioClientAudioSinkReceiver::OnAudioResume,
                        base::Unretained(localAudioSinkReceiver),
                        std::move(do_resume_promise)));
     if (status == BT_STATUS_SUCCESS) {
       do_resume_future.wait();
     } else {
       LOG(ERROR) << __func__
                  << ": LE_AUDIO_CTRL_CMD_START: do_in_main_thread err="
                  << status;
       return false;
     }
   } else {
     LOG(ERROR) << __func__
                << ": LE_AUDIO_CTRL_CMD_START: audio sink receiver not started";
     return false;
   }

   return true;
 }

 bool le_audio_source_on_resume_req(bool start_media_task) {
   if (localAudioSourceReceiver != nullptr) {
     // Call OnAudioResume and block till it returns.
     std::promise<void> do_resume_promise;
     std::future<void> do_resume_future = do_resume_promise.get_future();
     bt_status_t status = do_in_main_thread(
         FROM_HERE,
         base::BindOnce(&LeAudioClientAudioSourceReceiver::OnAudioResume,
                        base::Unretained(localAudioSourceReceiver),
                        std::move(do_resume_promise)));
     if (status == BT_STATUS_SUCCESS) {
       do_resume_future.wait();
     } else {
       LOG(ERROR) << __func__
                  << ": LE_AUDIO_CTRL_CMD_START: do_in_main_thread err="
                  << status;
       return false;
     }
   } else {
     LOG(ERROR)
         << __func__
         << ": LE_AUDIO_CTRL_CMD_START: audio source receiver not started";
     return false;
   }

   return true;
 }

 bool le_audio_sink_on_suspend_req() {
   stop_audio_ticks();
   if (localAudioSinkReceiver != nullptr) {
     // Call OnAudioSuspend and block till it returns.
     std::promise<void> do_suspend_promise;
     std::future<void> do_suspend_future = do_suspend_promise.get_future();
     bt_status_t status = do_in_main_thread(
         FROM_HERE,
         base::BindOnce(&LeAudioClientAudioSinkReceiver::OnAudioSuspend,
                        base::Unretained(localAudioSinkReceiver),
                        std::move(do_suspend_promise)));
     if (status == BT_STATUS_SUCCESS) {
       do_suspend_future.wait();
       return true;
     } else {
       LOG(ERROR) << __func__
                  << ": LE_AUDIO_CTRL_CMD_SUSPEND: do_in_main_thread err="
                  << status;
     }
   } else {
     LOG(ERROR) << __func__
                << ": LE_AUDIO_CTRL_CMD_SUSPEND: audio receiver not started";
   }
   return false;
 }

 bool le_audio_source_on_suspend_req() {
   if (localAudioSourceReceiver != nullptr) {
     // Call OnAudioSuspend and block till it returns.
     std::promise<void> do_suspend_promise;
     std::future<void> do_suspend_future = do_suspend_promise.get_future();
     bt_status_t status = do_in_main_thread(
         FROM_HERE,
         base::BindOnce(&LeAudioClientAudioSourceReceiver::OnAudioSuspend,
                        base::Unretained(localAudioSourceReceiver),
                        std::move(do_suspend_promise)));
     if (status == BT_STATUS_SUCCESS) {
       do_suspend_future.wait();
       return true;
     } else {
       LOG(ERROR) << __func__
                  << ": LE_AUDIO_CTRL_CMD_SUSPEND: do_in_main_thread err="
                  << status;
     }
   } else {
     LOG(ERROR) << __func__
                << ": LE_AUDIO_CTRL_CMD_SUSPEND: audio receiver not started";
   }
   return false;
 }

 bool le_audio_sink_on_metadata_update_req(
     const source_metadata_t& source_metadata) {
   if (localAudioSinkReceiver == nullptr) {
     LOG(ERROR) << __func__ << ", audio receiver not started";
     return false;
   }

   // Call OnAudioSuspend and block till it returns.
   std::promise<void> do_update_metadata_promise;
   std::future<void> do_update_metadata_future =
       do_update_metadata_promise.get_future();
   bt_status_t status = do_in_main_thread(
       FROM_HERE,
       base::BindOnce(&LeAudioClientAudioSinkReceiver::OnAudioMetadataUpdate,
                      base::Unretained(localAudioSinkReceiver),
                      std::move(do_update_metadata_promise), source_metadata));

   if (status == BT_STATUS_SUCCESS) {
     do_update_metadata_future.wait();
     return true;
   }

   LOG(ERROR) << __func__ << ", do_in_main_thread err=" << status;

   return false;
 }

 }  // namespace

 bool LeAudioClientAudioSource::Start(
     const LeAudioCodecConfiguration& codec_configuration,
     LeAudioClientAudioSinkReceiver* audioReceiver) {
   LOG(INFO) << __func__;

   if (!sinkClientInterface) {
     LOG(ERROR) << "sinkClientInterface is not Acquired!";
     return false;
   }

   if (le_audio_sink_hal_state == HAL_STARTED) {
     LOG(ERROR) << "LE audio device HAL is already in use!";
     return false;
   }

   LOG(INFO) << __func__ << ": Le Audio Source Open, bits per sample: "
             << int{codec_configuration.bits_per_sample}
             << ", num channels: " << int{codec_configuration.num_channels}
             << ", sample rate: " << codec_configuration.sample_rate
             << ", data interval: " << codec_configuration.data_interval_us;

   stats.Reset();

   /* Global config for periodic audio data */
   source_codec_config = codec_configuration;
   LeAudioClientInterface::PcmParameters pcmParameters = {
       .data_interval_us = codec_configuration.data_interval_us,
       .sample_rate = codec_configuration.sample_rate,
       .bits_per_sample = codec_configuration.bits_per_sample,
       .channels_count = codec_configuration.num_channels};

   sinkClientInterface->SetPcmParameters(pcmParameters);
   sinkClientInterface->StartSession();

   localAudioSinkReceiver = audioReceiver;
   le_audio_sink_hal_state = HAL_STARTED;

   return true;
 }

 void LeAudioClientAudioSource::Stop() {
   LOG(INFO) << __func__;
   if (!sinkClientInterface) {
     LOG(ERROR) << __func__ << " sinkClientInterface stopped";
     return;
   }

   if (le_audio_sink_hal_state != HAL_STARTED) {
     LOG(ERROR) << "LE audio device HAL was not started!";
     return;
   }

   LOG(INFO) << __func__ << ": Le Audio Source Close";

   sinkClientInterface->StopSession();
   le_audio_sink_hal_state = HAL_STOPPED;
   localAudioSinkReceiver = nullptr;

   stop_audio_ticks();
 }

 const void* LeAudioClientAudioSource::Acquire() {
   LOG(INFO) << __func__;
   if (sinkClientInterface != nullptr) {
     LOG(WARNING) << __func__ << ", Sink client interface already initialized";
     return nullptr;
   }

   /* Get pointer to singleton LE audio client interface */
   if (leAudioClientInterface == nullptr) {
     leAudioClientInterface = LeAudioClientInterface::Get();

     if (leAudioClientInterface == nullptr) {
       LOG(ERROR) << __func__ << ", can't get LE audio client interface";
       return nullptr;
     }
   }

   auto sink_stream_cb = bluetooth::audio::le_audio::StreamCallbacks{
       .on_resume_ = le_audio_sink_on_resume_req,
       .on_suspend_ = le_audio_sink_on_suspend_req,
       .on_metadata_update_ = le_audio_sink_on_metadata_update_req,
   };

   sinkClientInterface =
       leAudioClientInterface->GetSink(sink_stream_cb, get_main_thread());

   if (sinkClientInterface == nullptr) {
     LOG(ERROR) << __func__ << ", can't get LE audio sink client interface";
     return nullptr;
   }

   le_audio_sink_hal_state = HAL_STOPPED;
   return sinkClientInterface;
 }

 void LeAudioClientAudioSource::Release(const void* instance) {
   LOG(INFO) << __func__;
   if (sinkClientInterface != instance) {
     LOG(WARNING) << "Trying to release not own session";
     return;
   }

   if (le_audio_sink_hal_state == HAL_UNINITIALIZED) {
     LOG(WARNING) << "LE audio device HAL is not running.";
     return;
   }

   sinkClientInterface->Cleanup();
   leAudioClientInterface->ReleaseSink(sinkClientInterface);
   le_audio_sink_hal_state = HAL_UNINITIALIZED;
   sinkClientInterface = nullptr;
 }

 void LeAudioClientAudioSource::ConfirmStreamingRequest() {
   LOG(INFO) << __func__;
   if ((sinkClientInterface == nullptr) ||
       (le_audio_sink_hal_state != HAL_STARTED)) {
     LOG(ERROR) << "LE audio device HAL was not started!";
     return;
   }

   sinkClientInterface->ConfirmStreamingRequest();
   LOG(INFO) << __func__ << ", start_audio_ticks";
   start_audio_ticks();
 }

 void LeAudioClientAudioSource::CancelStreamingRequest() {
   LOG(INFO) << __func__;
   if ((sinkClientInterface == nullptr) ||
       (le_audio_sink_hal_state != HAL_STARTED)) {
     LOG(ERROR) << "LE audio device HAL was not started!";
     return;
   }

   sinkClientInterface->CancelStreamingRequest();
 }

 void LeAudioClientAudioSource::UpdateRemoteDelay(uint16_t remote_delay_ms) {
   LOG(INFO) << __func__;
   if ((sinkClientInterface == nullptr) ||
       (le_audio_sink_hal_state != HAL_STARTED)) {
     LOG(ERROR) << "LE audio device HAL was not started!";
     return;
   }

   sinkClientInterface->SetRemoteDelay(remote_delay_ms);
 }

 void LeAudioClientAudioSource::DebugDump(int fd) {
   uint64_t now_us = bluetooth::common::time_get_os_boottime_us();
   std::stringstream stream;
   stream << "  Le Audio Audio HAL:"
          << "\n    Counts (underflow)                                      : "
          << stats.media_read_total_underflow_count
          << "\n    Bytes (underflow)                                       : "
          << stats.media_read_total_underflow_bytes
          << "\n    Last update time ago in ms (underflow)                  : "
          << (stats.media_read_last_underflow_us > 0
                  ? (unsigned long long)(now_us -
                                         stats.media_read_last_underflow_us) /
                        1000
                  : 0)
          << std::endl;
   dprintf(fd, "%s", stream.str().c_str());
 }

 bool LeAudioClientAudioSink::Start(
     const LeAudioCodecConfiguration& codec_configuration,
     LeAudioClientAudioSourceReceiver* audioReceiver) {
   LOG(INFO) << __func__;
   if (!sourceClientInterface) {
     LOG(ERROR) << "sourceClientInterface is not Acquired!";
     return false;
   }

   if (le_audio_source_hal_state == HAL_STARTED) {
     LOG(ERROR) << "LE audio device HAL is already in use!";
     return false;
   }

   LOG(INFO) << __func__ << ": Le Audio Sink Open, bit rate: "
             << codec_configuration.bits_per_sample
             << ", num channels: " << int{codec_configuration.num_channels}
             << ", sample rate: " << codec_configuration.sample_rate
             << ", data interval: " << codec_configuration.data_interval_us;

   LeAudioClientInterface::PcmParameters pcmParameters = {
       .data_interval_us = codec_configuration.data_interval_us,
       .sample_rate = codec_configuration.sample_rate,
       .bits_per_sample = codec_configuration.bits_per_sample,
       .channels_count = codec_configuration.num_channels};

   sourceClientInterface->SetPcmParameters(pcmParameters);
   sourceClientInterface->StartSession();

   localAudioSourceReceiver = audioReceiver;
   le_audio_source_hal_state = HAL_STARTED;
   return true;
 }

 void LeAudioClientAudioSink::Stop() {
   LOG(INFO) << __func__;
   if (!sourceClientInterface) {
     LOG(ERROR) << __func__ << " sourceClientInterface stopped";
     return;
   }

   if (le_audio_source_hal_state != HAL_STARTED) {
     LOG(ERROR) << "LE audio device HAL was not started!";
     return;
   }

   LOG(INFO) << __func__ << ": Le Audio Sink Close";

   sourceClientInterface->StopSession();
   le_audio_source_hal_state = HAL_STOPPED;
   localAudioSourceReceiver = nullptr;
 }

 const void* LeAudioClientAudioSink::Acquire() {
   LOG(INFO) << __func__;
   if (sourceClientInterface != nullptr) {
     LOG(WARNING) << __func__ << ", Source client interface already initialized";
     return nullptr;
   }

   /* Get pointer to singleton LE audio client interface */
   if (leAudioClientInterface == nullptr) {
     leAudioClientInterface = LeAudioClientInterface::Get();

     if (leAudioClientInterface == nullptr) {
       LOG(ERROR) << __func__ << ", can't get LE audio client interface";
       return nullptr;
     }
   }

   auto source_stream_cb = bluetooth::audio::le_audio::StreamCallbacks{
       .on_resume_ = le_audio_source_on_resume_req,
       .on_suspend_ = le_audio_source_on_suspend_req,
   };

   sourceClientInterface =
       leAudioClientInterface->GetSource(source_stream_cb, get_main_thread());

   if (sourceClientInterface == nullptr) {
     LOG(ERROR) << __func__ << ", can't get LE audio source client interface";
     return nullptr;
   }

   le_audio_source_hal_state = HAL_STOPPED;
   return sourceClientInterface;
 }

 void LeAudioClientAudioSink::Release(const void* instance) {
   LOG(INFO) << __func__;
   if (sourceClientInterface != instance) {
     LOG(WARNING) << "Trying to release not own session";
     return;
   }

   if (le_audio_source_hal_state == HAL_UNINITIALIZED) {
     LOG(WARNING) << ", LE audio device source HAL is not running.";
     return;
   }

   sourceClientInterface->Cleanup();
   leAudioClientInterface->ReleaseSource(sourceClientInterface);
   le_audio_source_hal_state = HAL_UNINITIALIZED;
   sourceClientInterface = nullptr;
 }

 size_t LeAudioClientAudioSink::SendData(uint8_t* data, uint16_t size) {
   size_t bytes_written;
   if (!sourceClientInterface) {
     LOG(ERROR) << "sourceClientInterface not initialized!";
     return 0;
   }

   if (le_audio_source_hal_state != HAL_STARTED) {
     LOG(ERROR) << "LE audio device HAL was not started!";
     return 0;
   }

   /* TODO: What to do if not all data is written ? */
   bytes_written = sourceClientInterface->Write(data, size);
   if (bytes_written != size)
     LOG(ERROR) << ", Not all data is written to source HAL. bytes written: "
                << static_cast<int>(bytes_written)
                << ", total: " << static_cast<int>(size);

   return bytes_written;
 }

 void LeAudioClientAudioSink::ConfirmStreamingRequest() {
   LOG(INFO) << __func__;
   if ((sourceClientInterface == nullptr) ||
       (le_audio_source_hal_state != HAL_STARTED)) {
     LOG(ERROR) << "LE audio device HAL was not started!";
     return;
   }

   sourceClientInterface->ConfirmStreamingRequest();
 }

 void LeAudioClientAudioSink::CancelStreamingRequest() {
   LOG(INFO) << __func__;
   if ((sourceClientInterface == nullptr) ||
       (le_audio_source_hal_state != HAL_STARTED)) {
     LOG(ERROR) << "LE audio device HAL was not started!";
     return;
   }

   sourceClientInterface->CancelStreamingRequest();
 }

 void LeAudioClientAudioSink::UpdateRemoteDelay(uint16_t remote_delay_ms) {
   if ((sourceClientInterface == nullptr) ||
       (le_audio_source_hal_state != HAL_STARTED)) {
     LOG(ERROR) << "LE audio device HAL was not started!";
     return;
   }

   sourceClientInterface->SetRemoteDelay(remote_delay_ms);
 }

 void LeAudioClientAudioSink::DebugDump(int fd) {
   /* TODO: Add some statistic for source client interface */
 }
	/******************************************************************************
	*
	* Copyright 2019 HIMSA II K/S - www.himsa.com. Represented by EHIMA -
	* www.ehima.com
	*
	* 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.
	*
	******************************************************************************/

	#include "client_audio.h"

	#include "audio_hal_interface/le_audio_software.h"
	#include "btu.h"
	#include "common/repeating_timer.h"
	#include "common/time_util.h"
	#include "osi/include/wakelock.h"

	using bluetooth::audio::le_audio::LeAudioClientInterface;

	namespace {
	LeAudioCodecConfiguration source_codec_config;
	bluetooth::common::RepeatingTimer audio_timer;
	LeAudioClientInterface* leAudioClientInterface = nullptr;
	LeAudioClientInterface::Sink* sinkClientInterface = nullptr;
	LeAudioClientInterface::Source* sourceClientInterface = nullptr;
	LeAudioClientAudioSinkReceiver* localAudioSinkReceiver = nullptr;
	LeAudioClientAudioSourceReceiver* localAudioSourceReceiver = nullptr;

	enum {
	HAL_UNINITIALIZED,
	HAL_STOPPED,
	HAL_STARTED,
	} le_audio_sink_hal_state,
	le_audio_source_hal_state;

	struct AudioHalStats {
	size_t media_read_total_underflow_bytes;
	size_t media_read_total_underflow_count;
	uint64_t media_read_last_underflow_us;

	AudioHalStats() { Reset(); }

	void Reset() {
	media_read_total_underflow_bytes = 0;
	media_read_total_underflow_count = 0;
	media_read_last_underflow_us = 0;
	}
	};

	AudioHalStats stats;

	bool le_audio_sink_on_resume_req(bool start_media_task);
	bool le_audio_sink_on_suspend_req();

	void send_audio_data() {
	uint32_t bytes_per_tick =
	(source_codec_config.num_channels * source_codec_config.sample_rate *
	source_codec_config.data_interval_us / 1000 *
	(source_codec_config.bits_per_sample / 8)) /
	1000;

	std::vector<uint8_t> data(bytes_per_tick);

	uint32_t bytes_read = 0;
	if (sinkClientInterface != nullptr) {
	bytes_read = sinkClientInterface->Read(data.data(), bytes_per_tick);
	} else {
	LOG(ERROR) << __func__ << ", no LE Audio sink client interface - aborting.";
	return;
	}

	// LOG(INFO) << __func__ << ", bytes_read: " << static_cast<int>(bytes_read)
	// << ", bytes_per_tick: " << static_cast<int>(bytes_per_tick);

	if (bytes_read < bytes_per_tick) {
	stats.media_read_total_underflow_bytes += bytes_per_tick - bytes_read;
	stats.media_read_total_underflow_count++;
	stats.media_read_last_underflow_us =
	bluetooth::common::time_get_os_boottime_us();
	}

	if (localAudioSinkReceiver != nullptr) {
	localAudioSinkReceiver->OnAudioDataReady(data);
	}
	}

	void start_audio_ticks() {
	wakelock_acquire();
	audio_timer.SchedulePeriodic(
	get_main_thread()->GetWeakPtr(), FROM_HERE, base::Bind(&send_audio_data),
	base::TimeDelta::FromMicroseconds(source_codec_config.data_interval_us));
	}

	void stop_audio_ticks() {
	audio_timer.CancelAndWait();
	wakelock_release();
	}

	bool le_audio_sink_on_resume_req(bool start_media_task) {
	if (localAudioSinkReceiver != nullptr) {
	// Call OnAudioResume and block till it returns.
	std::promise<void> do_resume_promise;
	std::future<void> do_resume_future = do_resume_promise.get_future();
	bt_status_t status = do_in_main_thread(
	FROM_HERE,
	base::BindOnce(&LeAudioClientAudioSinkReceiver::OnAudioResume,
	base::Unretained(localAudioSinkReceiver),
	std::move(do_resume_promise)));
	if (status == BT_STATUS_SUCCESS) {
	do_resume_future.wait();
	} else {
	LOG(ERROR) << __func__
	<< ": LE_AUDIO_CTRL_CMD_START: do_in_main_thread err="
	<< status;
	return false;
	}
	} else {
	LOG(ERROR) << __func__
	<< ": LE_AUDIO_CTRL_CMD_START: audio sink receiver not started";
	return false;
	}

	return true;
	}

	bool le_audio_source_on_resume_req(bool start_media_task) {
	if (localAudioSourceReceiver != nullptr) {
	// Call OnAudioResume and block till it returns.
	std::promise<void> do_resume_promise;
	std::future<void> do_resume_future = do_resume_promise.get_future();
	bt_status_t status = do_in_main_thread(
	FROM_HERE,
	base::BindOnce(&LeAudioClientAudioSourceReceiver::OnAudioResume,
	base::Unretained(localAudioSourceReceiver),
	std::move(do_resume_promise)));
	if (status == BT_STATUS_SUCCESS) {
	do_resume_future.wait();
	} else {
	LOG(ERROR) << __func__
	<< ": LE_AUDIO_CTRL_CMD_START: do_in_main_thread err="
	<< status;
	return false;
	}
	} else {
	LOG(ERROR)
	<< __func__
	<< ": LE_AUDIO_CTRL_CMD_START: audio source receiver not started";
	return false;
	}

	return true;
	}

	bool le_audio_sink_on_suspend_req() {
	stop_audio_ticks();
	if (localAudioSinkReceiver != nullptr) {
	// Call OnAudioSuspend and block till it returns.
	std::promise<void> do_suspend_promise;
	std::future<void> do_suspend_future = do_suspend_promise.get_future();
	bt_status_t status = do_in_main_thread(
	FROM_HERE,
	base::BindOnce(&LeAudioClientAudioSinkReceiver::OnAudioSuspend,
	base::Unretained(localAudioSinkReceiver),
	std::move(do_suspend_promise)));
	if (status == BT_STATUS_SUCCESS) {
	do_suspend_future.wait();
	return true;
	} else {
	LOG(ERROR) << __func__
	<< ": LE_AUDIO_CTRL_CMD_SUSPEND: do_in_main_thread err="
	<< status;
	}
	} else {
	LOG(ERROR) << __func__
	<< ": LE_AUDIO_CTRL_CMD_SUSPEND: audio receiver not started";
	}
	return false;
	}

	bool le_audio_source_on_suspend_req() {
	if (localAudioSourceReceiver != nullptr) {
	// Call OnAudioSuspend and block till it returns.
	std::promise<void> do_suspend_promise;
	std::future<void> do_suspend_future = do_suspend_promise.get_future();
	bt_status_t status = do_in_main_thread(
	FROM_HERE,
	base::BindOnce(&LeAudioClientAudioSourceReceiver::OnAudioSuspend,
	base::Unretained(localAudioSourceReceiver),
	std::move(do_suspend_promise)));
	if (status == BT_STATUS_SUCCESS) {
	do_suspend_future.wait();
	return true;
	} else {
	LOG(ERROR) << __func__
	<< ": LE_AUDIO_CTRL_CMD_SUSPEND: do_in_main_thread err="
	<< status;
	}
	} else {
	LOG(ERROR) << __func__
	<< ": LE_AUDIO_CTRL_CMD_SUSPEND: audio receiver not started";
	}
	return false;
	}

	bool le_audio_sink_on_metadata_update_req(
	const source_metadata_t& source_metadata) {
	if (localAudioSinkReceiver == nullptr) {
	LOG(ERROR) << __func__ << ", audio receiver not started";
	return false;
	}

	// Call OnAudioSuspend and block till it returns.
	std::promise<void> do_update_metadata_promise;
	std::future<void> do_update_metadata_future =
	do_update_metadata_promise.get_future();
	bt_status_t status = do_in_main_thread(
	FROM_HERE,
	base::BindOnce(&LeAudioClientAudioSinkReceiver::OnAudioMetadataUpdate,
	base::Unretained(localAudioSinkReceiver),
	std::move(do_update_metadata_promise), source_metadata));

	if (status == BT_STATUS_SUCCESS) {
	do_update_metadata_future.wait();
	return true;
	}

	LOG(ERROR) << __func__ << ", do_in_main_thread err=" << status;

	return false;
	}

	} // namespace

	bool LeAudioClientAudioSource::Start(
	const LeAudioCodecConfiguration& codec_configuration,
	LeAudioClientAudioSinkReceiver* audioReceiver) {
	LOG(INFO) << __func__;

	if (!sinkClientInterface) {
	LOG(ERROR) << "sinkClientInterface is not Acquired!";
	return false;
	}

	if (le_audio_sink_hal_state == HAL_STARTED) {
	LOG(ERROR) << "LE audio device HAL is already in use!";
	return false;
	}

	LOG(INFO) << __func__ << ": Le Audio Source Open, bits per sample: "
	<< int{codec_configuration.bits_per_sample}
	<< ", num channels: " << int{codec_configuration.num_channels}
	<< ", sample rate: " << codec_configuration.sample_rate
	<< ", data interval: " << codec_configuration.data_interval_us;

	stats.Reset();

	/* Global config for periodic audio data */
	source_codec_config = codec_configuration;
	LeAudioClientInterface::PcmParameters pcmParameters = {
	.data_interval_us = codec_configuration.data_interval_us,
	.sample_rate = codec_configuration.sample_rate,
	.bits_per_sample = codec_configuration.bits_per_sample,
	.channels_count = codec_configuration.num_channels};

	sinkClientInterface->SetPcmParameters(pcmParameters);
	sinkClientInterface->StartSession();

	localAudioSinkReceiver = audioReceiver;
	le_audio_sink_hal_state = HAL_STARTED;

	return true;
	}

	void LeAudioClientAudioSource::Stop() {
	LOG(INFO) << __func__;
	if (!sinkClientInterface) {
	LOG(ERROR) << __func__ << " sinkClientInterface stopped";
	return;
	}

	if (le_audio_sink_hal_state != HAL_STARTED) {
	LOG(ERROR) << "LE audio device HAL was not started!";
	return;
	}

	LOG(INFO) << __func__ << ": Le Audio Source Close";

	sinkClientInterface->StopSession();
	le_audio_sink_hal_state = HAL_STOPPED;
	localAudioSinkReceiver = nullptr;

	stop_audio_ticks();
	}

	const void* LeAudioClientAudioSource::Acquire() {
	LOG(INFO) << __func__;
	if (sinkClientInterface != nullptr) {
	LOG(WARNING) << __func__ << ", Sink client interface already initialized";
	return nullptr;
	}

	/* Get pointer to singleton LE audio client interface */
	if (leAudioClientInterface == nullptr) {
	leAudioClientInterface = LeAudioClientInterface::Get();

	if (leAudioClientInterface == nullptr) {
	LOG(ERROR) << __func__ << ", can't get LE audio client interface";
	return nullptr;
	}
	}

	auto sink_stream_cb = bluetooth::audio::le_audio::StreamCallbacks{
	.on_resume_ = le_audio_sink_on_resume_req,
	.on_suspend_ = le_audio_sink_on_suspend_req,
	.on_metadata_update_ = le_audio_sink_on_metadata_update_req,
	};

	sinkClientInterface =
	leAudioClientInterface->GetSink(sink_stream_cb, get_main_thread());

	if (sinkClientInterface == nullptr) {
	LOG(ERROR) << __func__ << ", can't get LE audio sink client interface";
	return nullptr;
	}

	le_audio_sink_hal_state = HAL_STOPPED;
	return sinkClientInterface;
	}

	void LeAudioClientAudioSource::Release(const void* instance) {
	LOG(INFO) << __func__;
	if (sinkClientInterface != instance) {
	LOG(WARNING) << "Trying to release not own session";
	return;
	}

	if (le_audio_sink_hal_state == HAL_UNINITIALIZED) {
	LOG(WARNING) << "LE audio device HAL is not running.";
	return;
	}

	sinkClientInterface->Cleanup();
	leAudioClientInterface->ReleaseSink(sinkClientInterface);
	le_audio_sink_hal_state = HAL_UNINITIALIZED;
	sinkClientInterface = nullptr;
	}

	void LeAudioClientAudioSource::ConfirmStreamingRequest() {
	LOG(INFO) << __func__;
	if ((sinkClientInterface == nullptr) \|\|
	(le_audio_sink_hal_state != HAL_STARTED)) {
	LOG(ERROR) << "LE audio device HAL was not started!";
	return;
	}

	sinkClientInterface->ConfirmStreamingRequest();
	LOG(INFO) << __func__ << ", start_audio_ticks";
	start_audio_ticks();
	}

	void LeAudioClientAudioSource::CancelStreamingRequest() {
	LOG(INFO) << __func__;
	if ((sinkClientInterface == nullptr) \|\|
	(le_audio_sink_hal_state != HAL_STARTED)) {
	LOG(ERROR) << "LE audio device HAL was not started!";
	return;
	}

	sinkClientInterface->CancelStreamingRequest();
	}

	void LeAudioClientAudioSource::UpdateRemoteDelay(uint16_t remote_delay_ms) {
	LOG(INFO) << __func__;
	if ((sinkClientInterface == nullptr) \|\|
	(le_audio_sink_hal_state != HAL_STARTED)) {
	LOG(ERROR) << "LE audio device HAL was not started!";
	return;
	}

	sinkClientInterface->SetRemoteDelay(remote_delay_ms);
	}

	void LeAudioClientAudioSource::DebugDump(int fd) {
	uint64_t now_us = bluetooth::common::time_get_os_boottime_us();
	std::stringstream stream;
	stream << " Le Audio Audio HAL:"
	<< "\n Counts (underflow) : "
	<< stats.media_read_total_underflow_count
	<< "\n Bytes (underflow) : "
	<< stats.media_read_total_underflow_bytes
	<< "\n Last update time ago in ms (underflow) : "
	<< (stats.media_read_last_underflow_us > 0
	? (unsigned long long)(now_us -
	stats.media_read_last_underflow_us) /
	1000
	: 0)
	<< std::endl;
	dprintf(fd, "%s", stream.str().c_str());
	}

	bool LeAudioClientAudioSink::Start(
	const LeAudioCodecConfiguration& codec_configuration,
	LeAudioClientAudioSourceReceiver* audioReceiver) {
	LOG(INFO) << __func__;
	if (!sourceClientInterface) {
	LOG(ERROR) << "sourceClientInterface is not Acquired!";
	return false;
	}

	if (le_audio_source_hal_state == HAL_STARTED) {
	LOG(ERROR) << "LE audio device HAL is already in use!";
	return false;
	}

	LOG(INFO) << __func__ << ": Le Audio Sink Open, bit rate: "
	<< codec_configuration.bits_per_sample
	<< ", num channels: " << int{codec_configuration.num_channels}
	<< ", sample rate: " << codec_configuration.sample_rate
	<< ", data interval: " << codec_configuration.data_interval_us;

	LeAudioClientInterface::PcmParameters pcmParameters = {
	.data_interval_us = codec_configuration.data_interval_us,
	.sample_rate = codec_configuration.sample_rate,
	.bits_per_sample = codec_configuration.bits_per_sample,
	.channels_count = codec_configuration.num_channels};

	sourceClientInterface->SetPcmParameters(pcmParameters);
	sourceClientInterface->StartSession();

	localAudioSourceReceiver = audioReceiver;
	le_audio_source_hal_state = HAL_STARTED;
	return true;
	}

	void LeAudioClientAudioSink::Stop() {
	LOG(INFO) << __func__;
	if (!sourceClientInterface) {
	LOG(ERROR) << __func__ << " sourceClientInterface stopped";
	return;
	}

	if (le_audio_source_hal_state != HAL_STARTED) {
	LOG(ERROR) << "LE audio device HAL was not started!";
	return;
	}

	LOG(INFO) << __func__ << ": Le Audio Sink Close";

	sourceClientInterface->StopSession();
	le_audio_source_hal_state = HAL_STOPPED;
	localAudioSourceReceiver = nullptr;
	}

	const void* LeAudioClientAudioSink::Acquire() {
	LOG(INFO) << __func__;
	if (sourceClientInterface != nullptr) {
	LOG(WARNING) << __func__ << ", Source client interface already initialized";
	return nullptr;
	}

	/* Get pointer to singleton LE audio client interface */
	if (leAudioClientInterface == nullptr) {
	leAudioClientInterface = LeAudioClientInterface::Get();

	if (leAudioClientInterface == nullptr) {
	LOG(ERROR) << __func__ << ", can't get LE audio client interface";
	return nullptr;
	}
	}

	auto source_stream_cb = bluetooth::audio::le_audio::StreamCallbacks{
	.on_resume_ = le_audio_source_on_resume_req,
	.on_suspend_ = le_audio_source_on_suspend_req,
	};

	sourceClientInterface =
	leAudioClientInterface->GetSource(source_stream_cb, get_main_thread());

	if (sourceClientInterface == nullptr) {
	LOG(ERROR) << __func__ << ", can't get LE audio source client interface";
	return nullptr;
	}

	le_audio_source_hal_state = HAL_STOPPED;
	return sourceClientInterface;
	}

	void LeAudioClientAudioSink::Release(const void* instance) {
	LOG(INFO) << __func__;
	if (sourceClientInterface != instance) {
	LOG(WARNING) << "Trying to release not own session";
	return;
	}

	if (le_audio_source_hal_state == HAL_UNINITIALIZED) {
	LOG(WARNING) << ", LE audio device source HAL is not running.";
	return;
	}

	sourceClientInterface->Cleanup();
	leAudioClientInterface->ReleaseSource(sourceClientInterface);
	le_audio_source_hal_state = HAL_UNINITIALIZED;
	sourceClientInterface = nullptr;
	}

	size_t LeAudioClientAudioSink::SendData(uint8_t* data, uint16_t size) {
	size_t bytes_written;
	if (!sourceClientInterface) {
	LOG(ERROR) << "sourceClientInterface not initialized!";
	return 0;
	}

	if (le_audio_source_hal_state != HAL_STARTED) {
	LOG(ERROR) << "LE audio device HAL was not started!";
	return 0;
	}

	/* TODO: What to do if not all data is written ? */
	bytes_written = sourceClientInterface->Write(data, size);
	if (bytes_written != size)
	LOG(ERROR) << ", Not all data is written to source HAL. bytes written: "
	<< static_cast<int>(bytes_written)
	<< ", total: " << static_cast<int>(size);

	return bytes_written;
	}

	void LeAudioClientAudioSink::ConfirmStreamingRequest() {
	LOG(INFO) << __func__;
	if ((sourceClientInterface == nullptr) \|\|
	(le_audio_source_hal_state != HAL_STARTED)) {
	LOG(ERROR) << "LE audio device HAL was not started!";
	return;
	}

	sourceClientInterface->ConfirmStreamingRequest();
	}

	void LeAudioClientAudioSink::CancelStreamingRequest() {
	LOG(INFO) << __func__;
	if ((sourceClientInterface == nullptr) \|\|
	(le_audio_source_hal_state != HAL_STARTED)) {
	LOG(ERROR) << "LE audio device HAL was not started!";
	return;
	}

	sourceClientInterface->CancelStreamingRequest();
	}

	void LeAudioClientAudioSink::UpdateRemoteDelay(uint16_t remote_delay_ms) {
	if ((sourceClientInterface == nullptr) \|\|
	(le_audio_source_hal_state != HAL_STARTED)) {
	LOG(ERROR) << "LE audio device HAL was not started!";
	return;
	}

	sourceClientInterface->SetRemoteDelay(remote_delay_ms);
	}

	void LeAudioClientAudioSink::DebugDump(int fd) {
	/* TODO: Add some statistic for source client interface */
	}