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

Commit e40b7666 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "leaudio: Fix Audio HAL startRequest"

parents 73c6d95f ed42483c

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

}