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

Commit ed42483c authored by Łukasz Rymanowski's avatar Łukasz Rymanowski
Browse files

leaudio: Fix Audio HAL startRequest 

This patch fix possible race on startRequest.

It could happen that ConfirmStreamingRequest is called in the main
thread before, StartRequest() ends and sets pending flag.

That could lead to incorrect Bluetooth Audio Hal state - stay in
STARTING state.

08-30 11:14:06.921114  8896 11089 I bt_stack: [INFO:le_audio_software_aidl.cc(69)] StartRequest
08-30 11:14:06.921221  8896  8965 I bt_stack: [INFO:client.cc(2967)] OnAudioSinkResume
08-30 11:14:06.921272  8896  8965 I bt_stack:  audio_receiver_state: IDLE
08-30 11:14:06.921272  8896  8965 I bt_stack:  audio_sender_state: READY_TO_RELEASE
08-30 11:14:06.921272  8896  8965 I bt_stack:  configuration_context_type_: 4
08-30 11:14:06.921299  8896  8965 I bt_stack: [INFO:client_audio.cc(428)] ConfirmStreamingRequest
08-30 11:14:06.921314  8896  8965 I bt_stack: [INFO:le_audio_software.cc(197)] ConfirmStreamingRequest
08-30 11:14:06.921327  8896  8965 W bt_stack: [WARNING:le_audio_software.cc(212)] , no pending start stream request

<snip>

08-30 11:14:11.421940   817 12545 E BTAudioHalDeviceProxyAIDL: Start: session_type=LE_AUDIO_SOFTWARE_ENCODING_DATAPATH, cookie=0x400, state=STARTING failure
08-30 11:14:11.422137   817 12545 E BTAudioHalStream: out_write: state=STARTING failed to resume
08-30 11:14:11.438755   817 12545 I BTAudioHalStream: out_write: state=STARTING first time bytes=1920
08-30 11:14:11.438829   817 12545 W BTAudioHalStream: out_resume: state=STARTING NOT ready to resume?!
08-30 11:14:11.438852   817 12545 E BTAudioHalStream: out_write: state=STARTING failed to resume

Bug: 244299911
Bug: 244384741
Test: atest BluetoothInstrumentationTests
Test: manual testing media -> phone call->media switch
Tag: #feature
Change-Id: I55e7c9d4301bc027e6f1dd505813bb2b05799629
parent 13881ecc

system/audio_hal_interface/aidl/le_audio_software_aidl.cc

+42 −16
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 


#include "codec_status_aidl.h"

#include "hal_version_manager.h"

#include "osi/include/log.h"



namespace bluetooth {

namespace audio {
@@ -40,6 +41,7 @@ using ::aidl::android::hardware::bluetooth::audio::PcmConfiguration; 
using ::bluetooth::audio::aidl::AudioConfiguration;

using ::bluetooth::audio::aidl::BluetoothAudioCtrlAck;

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

using ::bluetooth::audio::le_audio::StartRequestState;

using ::bluetooth::audio::le_audio::StreamCallbacks;

using ::le_audio::set_configurations::SetConfiguration;

using ::le_audio::types::LeAudioLc3Config;
@@ -63,16 +65,30 @@ LeAudioTransport::LeAudioTransport(void (*flush)(void), 
      total_bytes_processed_(0),

      data_position_({}),

      pcm_config_(std::move(pcm_config)),

      is_pending_start_request_(false){};

      start_request_state_(StartRequestState::IDLE){};



BluetoothAudioCtrlAck LeAudioTransport::StartRequest(bool is_low_latency) {

  LOG(INFO) << __func__;



  SetStartRequestState(StartRequestState::PENDING_BEFORE_RESUME);

  if (stream_cb_.on_resume_(true)) {

    is_pending_start_request_ = true;

    if (start_request_state_ == StartRequestState::CONFIRMED) {

      LOG_INFO("Start completed.");

      SetStartRequestState(StartRequestState::IDLE);

      return BluetoothAudioCtrlAck::SUCCESS_FINISHED;

    }



    if (start_request_state_ == StartRequestState::CANCELED) {

      LOG_INFO("Start request failed.");

      SetStartRequestState(StartRequestState::IDLE);

      return BluetoothAudioCtrlAck::FAILURE;

    }



    LOG_INFO("Start pending.");

    SetStartRequestState(StartRequestState::PENDING_AFTER_RESUME);

    return BluetoothAudioCtrlAck::PENDING;

  }



  LOG_ERROR("Start request failed.");

  SetStartRequestState(StartRequestState::IDLE);

  return BluetoothAudioCtrlAck::FAILURE;

}
@@ -193,11 +209,14 @@ LeAudioTransport::LeAudioGetBroadcastConfig() { 
  return broadcast_config_;

}



bool LeAudioTransport::IsPendingStartStream(void) {

  return is_pending_start_request_;

StartRequestState LeAudioTransport::GetStartRequestState(void) {

  return start_request_state_;

}

void LeAudioTransport::ClearStartRequestState(void) {

  start_request_state_ = StartRequestState::IDLE;

}

void LeAudioTransport::ClearPendingStartStream(void) {

  is_pending_start_request_ = false;

void LeAudioTransport::SetStartRequestState(StartRequestState state) {

  start_request_state_ = state;

}



inline void flush_unicast_sink() {
@@ -294,11 +313,14 @@ LeAudioSinkTransport::LeAudioGetBroadcastConfig() { 
  return transport_->LeAudioGetBroadcastConfig();

}



bool LeAudioSinkTransport::IsPendingStartStream(void) {

  return transport_->IsPendingStartStream();

StartRequestState LeAudioSinkTransport::GetStartRequestState(void) {

  return transport_->GetStartRequestState();

}

void LeAudioSinkTransport::ClearPendingStartStream(void) {

  transport_->ClearPendingStartStream();

void LeAudioSinkTransport::ClearStartRequestState(void) {

  transport_->ClearStartRequestState();

}

void LeAudioSinkTransport::SetStartRequestState(StartRequestState state) {

  transport_->SetStartRequestState(state);

}



void flush_source() {
@@ -368,11 +390,15 @@ void LeAudioSourceTransport::LeAudioSetSelectedHalPcmConfig( 
                                             channels_count, data_interval);

}



bool LeAudioSourceTransport::IsPendingStartStream(void) {

  return transport_->IsPendingStartStream();

StartRequestState LeAudioSourceTransport::GetStartRequestState(void) {

  return transport_->GetStartRequestState();

}

void LeAudioSourceTransport::ClearStartRequestState(void) {

  transport_->ClearStartRequestState();

}

void LeAudioSourceTransport::ClearPendingStartStream(void) {

  transport_->ClearPendingStartStream();



void LeAudioSourceTransport::SetStartRequestState(StartRequestState state) {

  transport_->SetStartRequestState(state);

}



std::unordered_map<int32_t, uint8_t> sampling_freq_map{

system/audio_hal_interface/aidl/le_audio_software_aidl.h

+11 −7
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ using ::aidl::android::hardware::bluetooth::audio::PcmConfiguration; 
using ::aidl::android::hardware::bluetooth::audio::SessionType;

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

using ::bluetooth::audio::aidl::BluetoothAudioCtrlAck;

using ::bluetooth::audio::le_audio::StartRequestState;

using ::le_audio::set_configurations::AudioSetConfiguration;

using ::le_audio::set_configurations::CodecCapabilitySetting;
@@ -101,8 +102,9 @@ class LeAudioTransport { 


  const LeAudioBroadcastConfiguration& LeAudioGetBroadcastConfig();



  bool IsPendingStartStream(void);

  void ClearPendingStartStream(void);

  StartRequestState GetStartRequestState(void);

  void ClearStartRequestState(void);

  void SetStartRequestState(StartRequestState state);



 private:

  void (*flush_)(void);
@@ -112,7 +114,7 @@ class LeAudioTransport { 
  timespec data_position_;

  PcmConfiguration pcm_config_;

  LeAudioBroadcastConfiguration broadcast_config_;

  bool is_pending_start_request_;

  std::atomic<StartRequestState> start_request_state_;

};



// Sink transport implementation for Le Audio
@@ -154,8 +156,9 @@ class LeAudioSinkTransport 


  const LeAudioBroadcastConfiguration& LeAudioGetBroadcastConfig();



  bool IsPendingStartStream(void);

  void ClearPendingStartStream(void);

  StartRequestState GetStartRequestState(void);

  void ClearStartRequestState(void);

  void SetStartRequestState(StartRequestState state);



  static inline LeAudioSinkTransport* instance_unicast_ = nullptr;

  static inline LeAudioSinkTransport* instance_broadcast_ = nullptr;
@@ -201,8 +204,9 @@ class LeAudioSourceTransport 
                                      uint8_t channels_count,

                                      uint32_t data_interval);



  bool IsPendingStartStream(void);

  void ClearPendingStartStream(void);

  StartRequestState GetStartRequestState(void);

  void ClearStartRequestState(void);

  void SetStartRequestState(StartRequestState state);



  static inline LeAudioSourceTransport* instance = nullptr;

  static inline BluetoothAudioSourceClientInterface* interface = nullptr;

system/audio_hal_interface/hidl/le_audio_software_hidl.cc

+42 −16
Original line number Diff line number Diff line
@@ -19,6 +19,8 @@ 


#include "le_audio_software_hidl.h"



#include "osi/include/log.h"



namespace bluetooth {

namespace audio {

namespace hidl {
@@ -32,6 +34,7 @@ using ::bluetooth::audio::hidl::SessionType; 
using ::bluetooth::audio::hidl::SessionType_2_1;



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

using ::bluetooth::audio::le_audio::StartRequestState;



/**

 * Helper utils
@@ -103,16 +106,30 @@ LeAudioTransport::LeAudioTransport(void (*flush)(void), 
      total_bytes_processed_(0),

      data_position_({}),

      pcm_config_(std::move(pcm_config)),

      is_pending_start_request_(false){};

      start_request_state_(StartRequestState::IDLE){};



BluetoothAudioCtrlAck LeAudioTransport::StartRequest() {

  LOG(INFO) << __func__;



  SetStartRequestState(StartRequestState::PENDING_BEFORE_RESUME);

  if (stream_cb_.on_resume_(true)) {

    is_pending_start_request_ = true;

    if (start_request_state_ == StartRequestState::CONFIRMED) {

      LOG_INFO("Start completed.");

      SetStartRequestState(StartRequestState::IDLE);

      return BluetoothAudioCtrlAck::SUCCESS_FINISHED;

    }



    if (start_request_state_ == StartRequestState::CANCELED) {

      LOG_INFO("Start request failed.");

      SetStartRequestState(StartRequestState::IDLE);

      return BluetoothAudioCtrlAck::FAILURE;

    }



    LOG_INFO("Start pending.");

    SetStartRequestState(StartRequestState::PENDING_AFTER_RESUME);

    return BluetoothAudioCtrlAck::PENDING;

  }



  LOG_ERROR("Start request failed.");

  SetStartRequestState(StartRequestState::IDLE);

  return BluetoothAudioCtrlAck::FAILURE;

}
@@ -195,11 +212,14 @@ void LeAudioTransport::LeAudioSetSelectedHalPcmConfig(uint32_t sample_rate_hz, 
  pcm_config_.dataIntervalUs = data_interval;

}



bool LeAudioTransport::IsPendingStartStream(void) {

  return is_pending_start_request_;

StartRequestState LeAudioTransport::GetStartRequestState(void) {

  return start_request_state_;

}

void LeAudioTransport::ClearPendingStartStream(void) {

  is_pending_start_request_ = false;

void LeAudioTransport::ClearStartRequestState(void) {

  start_request_state_ = StartRequestState::IDLE;

}

void LeAudioTransport::SetStartRequestState(StartRequestState state) {

  start_request_state_ = state;

}



void flush_sink() {
@@ -264,11 +284,14 @@ void LeAudioSinkTransport::LeAudioSetSelectedHalPcmConfig( 
                                             channels_count, data_interval);

}



bool LeAudioSinkTransport::IsPendingStartStream(void) {

  return transport_->IsPendingStartStream();

StartRequestState LeAudioSinkTransport::GetStartRequestState(void) {

  return transport_->GetStartRequestState();

}

void LeAudioSinkTransport::ClearStartRequestState(void) {

  transport_->ClearStartRequestState();

}

void LeAudioSinkTransport::ClearPendingStartStream(void) {

  transport_->ClearPendingStartStream();

void LeAudioSinkTransport::SetStartRequestState(StartRequestState state) {

  transport_->SetStartRequestState(state);

}



void flush_source() {
@@ -333,11 +356,14 @@ void LeAudioSourceTransport::LeAudioSetSelectedHalPcmConfig( 
                                             channels_count, data_interval);

}



bool LeAudioSourceTransport::IsPendingStartStream(void) {

  return transport_->IsPendingStartStream();

StartRequestState LeAudioSourceTransport::GetStartRequestState(void) {

  return transport_->GetStartRequestState();

}

void LeAudioSourceTransport::ClearStartRequestState(void) {

  transport_->ClearStartRequestState();

}

void LeAudioSourceTransport::ClearPendingStartStream(void) {

  transport_->ClearPendingStartStream();

void LeAudioSourceTransport::SetStartRequestState(StartRequestState state) {

  transport_->SetStartRequestState(state);

}

}  // namespace le_audio

}  // namespace hidl

system/audio_hal_interface/hidl/le_audio_software_hidl.h

+12 −7
Original line number Diff line number Diff line
@@ -30,6 +30,8 @@ using ::bluetooth::audio::hidl::BluetoothAudioCtrlAck; 
using ::le_audio::set_configurations::AudioSetConfiguration;

using ::le_audio::set_configurations::CodecCapabilitySetting;



using ::bluetooth::audio::le_audio::StartRequestState;



constexpr uint8_t kChannelNumberMono = 1;

constexpr uint8_t kChannelNumberStereo = 2;
@@ -81,8 +83,9 @@ class LeAudioTransport { 
                                      uint8_t channels_count,

                                      uint32_t data_interval);



  bool IsPendingStartStream(void);

  void ClearPendingStartStream(void);

  StartRequestState GetStartRequestState(void);

  void ClearStartRequestState(void);

  void SetStartRequestState(StartRequestState state);



 private:

  void (*flush_)(void);
@@ -91,7 +94,7 @@ class LeAudioTransport { 
  uint64_t total_bytes_processed_;

  timespec data_position_;

  PcmParameters pcm_config_;

  bool is_pending_start_request_;

  std::atomic<StartRequestState> start_request_state_;

};



// Sink transport implementation for Le Audio
@@ -126,8 +129,9 @@ class LeAudioSinkTransport 
                                      uint8_t channels_count,

                                      uint32_t data_interval);



  bool IsPendingStartStream(void);

  void ClearPendingStartStream(void);

  StartRequestState GetStartRequestState(void);

  void ClearStartRequestState(void);

  void SetStartRequestState(StartRequestState state);



  static inline LeAudioSinkTransport* instance = nullptr;

  static inline BluetoothAudioSinkClientInterface* interface = nullptr;
@@ -168,8 +172,9 @@ class LeAudioSourceTransport 
                                      uint8_t channels_count,

                                      uint32_t data_interval);



  bool IsPendingStartStream(void);

  void ClearPendingStartStream(void);

  StartRequestState GetStartRequestState(void);

  void ClearStartRequestState(void);

  void SetStartRequestState(StartRequestState state);



  static inline LeAudioSourceTransport* instance = nullptr;

  static inline BluetoothAudioSourceClientInterface* interface = nullptr;

system/audio_hal_interface/le_audio_software.cc

+172 −69
Original line number Diff line number Diff line
@@ -194,61 +194,113 @@ void LeAudioClientInterface::Sink::StartSession() { 
}



void LeAudioClientInterface::Sink::ConfirmStreamingRequest() {

  LOG(INFO) << __func__;



  if (HalVersionManager::GetHalTransport() ==

      BluetoothAudioHalTransport::HIDL) {

    if (!hidl::le_audio::LeAudioSinkTransport::instance

             ->IsPendingStartStream()) {

      LOG(WARNING) << ", no pending start stream request";

    auto hidl_instance = hidl::le_audio::LeAudioSinkTransport::instance;

    auto start_request_state = hidl_instance->GetStartRequestState();



    switch (start_request_state) {

      case StartRequestState::IDLE:

        LOG_WARN(", no pending start stream request");

        return;

    }

    hidl::le_audio::LeAudioSinkTransport::instance->ClearPendingStartStream();

      case StartRequestState::PENDING_BEFORE_RESUME:

        LOG_INFO("Response before sending PENDING to audio HAL");

        hidl_instance->SetStartRequestState(StartRequestState::CONFIRMED);

        return;

      case StartRequestState::PENDING_AFTER_RESUME:

        LOG_INFO("Response after sending PENDING to audio HAL");

        hidl_instance->ClearStartRequestState();

        hidl::le_audio::LeAudioSinkTransport::interface->StreamStarted(

            hidl::BluetoothAudioCtrlAck::SUCCESS_FINISHED);

        return;

  }

  if (!get_aidl_transport_instance(is_broadcaster_)->IsPendingStartStream()) {

    LOG(WARNING) << ", no pending start stream request";

      case StartRequestState::CONFIRMED:

      case StartRequestState::CANCELED:

        LOG_ERROR("Invalid state, start stream already confirmed");

        return;

    }

  get_aidl_transport_instance(is_broadcaster_)->ClearPendingStartStream();

  }



  auto aidl_instance = get_aidl_transport_instance(is_broadcaster_);

  auto start_request_state = aidl_instance->GetStartRequestState();

  switch (start_request_state) {

    case StartRequestState::IDLE:

      LOG_WARN(", no pending start stream request");

      return;

    case StartRequestState::PENDING_BEFORE_RESUME:

      LOG_INFO("Response before sending PENDING to audio HAL");

      aidl_instance->SetStartRequestState(StartRequestState::CONFIRMED);

      return;

    case StartRequestState::PENDING_AFTER_RESUME:

      LOG_INFO("Response after sending PENDING to audio HAL");

      aidl_instance->ClearStartRequestState();

      get_aidl_client_interface(is_broadcaster_)

          ->StreamStarted(aidl::BluetoothAudioCtrlAck::SUCCESS_FINISHED);

      return;

    case StartRequestState::CONFIRMED:

    case StartRequestState::CANCELED:

      LOG_ERROR("Invalid state, start stream already confirmed");

      return;

  }

}



void LeAudioClientInterface::Sink::CancelStreamingRequest() {

  LOG(INFO) << __func__;

  if (HalVersionManager::GetHalTransport() ==

      BluetoothAudioHalTransport::HIDL) {

    if (!hidl::le_audio::LeAudioSinkTransport::instance

             ->IsPendingStartStream()) {

      LOG(WARNING) << ", no pending start stream request";

    auto hidl_instance = hidl::le_audio::LeAudioSinkTransport::instance;

    auto start_request_state = hidl_instance->GetStartRequestState();

    switch (start_request_state) {

      case StartRequestState::IDLE:

        LOG_WARN(", no pending start stream request");

        return;

    }

    hidl::le_audio::LeAudioSinkTransport::instance->ClearPendingStartStream();

      case StartRequestState::PENDING_BEFORE_RESUME:

        LOG_INFO("Response before sending PENDING to audio HAL");

        hidl_instance->SetStartRequestState(StartRequestState::CANCELED);

        return;

      case StartRequestState::PENDING_AFTER_RESUME:

        LOG_INFO("Response after sending PENDING to audio HAL");

        hidl_instance->ClearStartRequestState();

        hidl::le_audio::LeAudioSinkTransport::interface->StreamStarted(

            hidl::BluetoothAudioCtrlAck::FAILURE);

        return;

      case StartRequestState::CONFIRMED:

      case StartRequestState::CANCELED:

        LOG_ERROR("Invalid state, start stream already confirmed");

        break;

    }

  if (!get_aidl_transport_instance(is_broadcaster_)->IsPendingStartStream()) {

    LOG(WARNING) << ", no pending start stream request";

    return;

  }

  get_aidl_transport_instance(is_broadcaster_)->ClearPendingStartStream();



  auto aidl_instance = get_aidl_transport_instance(is_broadcaster_);

  auto start_request_state = aidl_instance->GetStartRequestState();

  switch (start_request_state) {

    case StartRequestState::IDLE:

      LOG_WARN(", no pending start stream request");

      return;

    case StartRequestState::PENDING_BEFORE_RESUME:

      LOG_INFO("Response before sending PENDING to audio HAL");

      aidl_instance->SetStartRequestState(StartRequestState::CANCELED);

      return;

    case StartRequestState::PENDING_AFTER_RESUME:

      LOG_INFO("Response after sending PENDING to audio HAL");

      aidl_instance->ClearStartRequestState();

      get_aidl_client_interface(is_broadcaster_)

          ->StreamStarted(aidl::BluetoothAudioCtrlAck::FAILURE);

      return;

    case StartRequestState::CONFIRMED:

    case StartRequestState::CANCELED:

      LOG_ERROR("Invalid state, start stream already confirmed");

      break;

  }

}



void LeAudioClientInterface::Sink::StopSession() {

  LOG(INFO) << __func__ << " sink";

  if (HalVersionManager::GetHalTransport() ==

      BluetoothAudioHalTransport::HIDL) {

    hidl::le_audio::LeAudioSinkTransport::instance->ClearPendingStartStream();

    hidl::le_audio::LeAudioSinkTransport::instance->ClearStartRequestState();

    hidl::le_audio::LeAudioSinkTransport::interface->EndSession();

    return;

  }

  get_aidl_transport_instance(is_broadcaster_)->ClearPendingStartStream();

  get_aidl_transport_instance(is_broadcaster_)->ClearStartRequestState();

  get_aidl_client_interface(is_broadcaster_)->EndSession();

}
@@ -405,62 +457,113 @@ void LeAudioClientInterface::Source::SuspendedForReconfiguration() { 
}



void LeAudioClientInterface::Source::ConfirmStreamingRequest() {

  LOG(INFO) << __func__;

  if ((hidl::le_audio::LeAudioSourceTransport::instance &&

       !hidl::le_audio::LeAudioSourceTransport::instance

            ->IsPendingStartStream()) ||

      (aidl::le_audio::LeAudioSourceTransport::instance &&

       !aidl::le_audio::LeAudioSourceTransport::instance

            ->IsPendingStartStream())) {

    LOG(WARNING) << ", no pending start stream request";

    return;

  }



  if (HalVersionManager::GetHalTransport() ==

      BluetoothAudioHalTransport::HIDL) {

    hidl::le_audio::LeAudioSourceTransport::instance->ClearPendingStartStream();

    auto hidl_instance = hidl::le_audio::LeAudioSourceTransport::instance;

    auto start_request_state = hidl_instance->GetStartRequestState();



    switch (start_request_state) {

      case StartRequestState::IDLE:

        LOG_WARN(", no pending start stream request");

        return;

      case StartRequestState::PENDING_BEFORE_RESUME:

        LOG_INFO("Response before sending PENDING to audio HAL");

        hidl_instance->SetStartRequestState(StartRequestState::CONFIRMED);

        return;

      case StartRequestState::PENDING_AFTER_RESUME:

        LOG_INFO("Response after sending PENDING to audio HAL");

        hidl_instance->ClearStartRequestState();

        hidl::le_audio::LeAudioSourceTransport::interface->StreamStarted(

            hidl::BluetoothAudioCtrlAck::SUCCESS_FINISHED);

        return;

      case StartRequestState::CONFIRMED:

      case StartRequestState::CANCELED:

        LOG_ERROR("Invalid state, start stream already confirmed");

        return;

    }

  }

  aidl::le_audio::LeAudioSourceTransport::instance->ClearPendingStartStream();



  auto aidl_instance = aidl::le_audio::LeAudioSourceTransport::instance;

  auto start_request_state = aidl_instance->GetStartRequestState();

  switch (start_request_state) {

    case StartRequestState::IDLE:

      LOG_WARN(", no pending start stream request");

      return;

    case StartRequestState::PENDING_BEFORE_RESUME:

      LOG_INFO("Response before sending PENDING to audio HAL");

      aidl_instance->SetStartRequestState(StartRequestState::CONFIRMED);

      return;

    case StartRequestState::PENDING_AFTER_RESUME:

      LOG_INFO("Response after sending PENDING to audio HAL");

      aidl_instance->ClearStartRequestState();

      aidl::le_audio::LeAudioSourceTransport::interface->StreamStarted(

          aidl::BluetoothAudioCtrlAck::SUCCESS_FINISHED);

      return;

    case StartRequestState::CONFIRMED:

    case StartRequestState::CANCELED:

      LOG_ERROR("Invalid state, start stream already confirmed");

      return;

  }

}



void LeAudioClientInterface::Source::CancelStreamingRequest() {

  LOG(INFO) << __func__;

  if (HalVersionManager::GetHalTransport() ==

      BluetoothAudioHalTransport::HIDL) {

    if (!hidl::le_audio::LeAudioSourceTransport::instance

             ->IsPendingStartStream()) {

      LOG(WARNING) << ", no pending start stream request";

    auto hidl_instance = hidl::le_audio::LeAudioSourceTransport::instance;

    auto start_request_state = hidl_instance->GetStartRequestState();

    switch (start_request_state) {

      case StartRequestState::IDLE:

        LOG_WARN(", no pending start stream request");

        return;

    }

    hidl::le_audio::LeAudioSourceTransport::instance->ClearPendingStartStream();

      case StartRequestState::PENDING_BEFORE_RESUME:

        LOG_INFO("Response before sending PENDING to audio HAL");

        hidl_instance->SetStartRequestState(StartRequestState::CANCELED);

        return;

      case StartRequestState::PENDING_AFTER_RESUME:

        LOG_INFO("Response after sending PENDING to audio HAL");

        hidl_instance->ClearStartRequestState();

        hidl::le_audio::LeAudioSourceTransport::interface->StreamStarted(

            hidl::BluetoothAudioCtrlAck::FAILURE);

        return;

      case StartRequestState::CONFIRMED:

      case StartRequestState::CANCELED:

        LOG_ERROR("Invalid state, start stream already confirmed");

        break;

    }

  if (!aidl::le_audio::LeAudioSourceTransport::instance

           ->IsPendingStartStream()) {

    LOG(WARNING) << ", no pending start stream request";

    return;

  }

  aidl::le_audio::LeAudioSourceTransport::instance->ClearPendingStartStream();



  auto aidl_instance = aidl::le_audio::LeAudioSourceTransport::instance;

  auto start_request_state = aidl_instance->GetStartRequestState();

  switch (start_request_state) {

    case StartRequestState::IDLE:

      LOG_WARN(", no pending start stream request");

      return;

    case StartRequestState::PENDING_BEFORE_RESUME:

      LOG_INFO("Response before sending PENDING to audio HAL");

      aidl_instance->SetStartRequestState(StartRequestState::CANCELED);

      return;

    case StartRequestState::PENDING_AFTER_RESUME:

      LOG_INFO("Response after sending PENDING to audio HAL");

      aidl_instance->ClearStartRequestState();

      aidl::le_audio::LeAudioSourceTransport::interface->StreamStarted(

          aidl::BluetoothAudioCtrlAck::FAILURE);

      return;

    case StartRequestState::CONFIRMED:

    case StartRequestState::CANCELED:

      LOG_ERROR("Invalid state, start stream already confirmed");

      break;

  }

}



void LeAudioClientInterface::Source::StopSession() {

  LOG(INFO) << __func__ << " source";

  if (HalVersionManager::GetHalTransport() ==

      BluetoothAudioHalTransport::HIDL) {

    hidl::le_audio::LeAudioSourceTransport::instance->ClearPendingStartStream();

    hidl::le_audio::LeAudioSourceTransport::instance->ClearStartRequestState();

    hidl::le_audio::LeAudioSourceTransport::interface->EndSession();

    return;

  }

  aidl::le_audio::LeAudioSourceTransport::instance->ClearPendingStartStream();

  aidl::le_audio::LeAudioSourceTransport::instance->ClearStartRequestState();

  aidl::le_audio::LeAudioSourceTransport::interface->EndSession();

}