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

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

Merge changes Ia756c241,I54da33bc into main 

* changes:
  LeAudio: Configuration provider dependency inversion - Part 3
  LeAudio: Configuration provider dependency inversion - Part 2
parents 09c3c1d4 07d6b997

system/bta/le_audio/client.cc

+2 −2
Original line number Diff line number Diff line
@@ -3125,11 +3125,11 @@ class LeAudioClientImpl : public LeAudioClient { 
    }



    auto num_of_devices =

        get_num_of_devices_in_configuration(stream_conf->conf);

        get_num_of_devices_in_configuration(stream_conf->conf.get());



    if (num_of_devices < group->NumOfConnected() &&

        !group->IsAudioSetConfigurationSupported(leAudioDevice,

                                                 stream_conf->conf)) {

                                                 stream_conf->conf.get())) {

      /* Reconfigure if newly connected member device cannot support current

       * codec configuration */

      group->SetPendingConfiguration();

system/bta/le_audio/codec_manager.cc

+68 −12
Original line number Diff line number Diff line
@@ -118,6 +118,8 @@ struct codec_manager_impl { 
  }

  void start(

      const std::vector<btle_audio_codec_config_t>& offloading_preference) {

    dual_bidirection_swb_supported_ = osi_property_get_bool(

        "bluetooth.leaudio.dual_bidirection_swb.supported", false);

    bluetooth::le_audio::AudioSetConfigurationProvider::Initialize(

        GetCodecLocation());

    UpdateOffloadCapability(offloading_preference);
@@ -133,8 +135,16 @@ struct codec_manager_impl { 
  }

  CodecLocation GetCodecLocation(void) const { return codec_location_; }



  bool IsOffloadDualBiDirSwbSupported(void) const {

  bool IsDualBiDirSwbSupported(void) const {

    if (GetCodecLocation() == CodecLocation::ADSP) {

      // Whether dual bidirection swb is supported by property and for offload

      return offload_dual_bidirection_swb_supported_;

    } else if (GetCodecLocation() == CodecLocation::HOST) {

      // Whether dual bidirection swb is supported for software

      return dual_bidirection_swb_supported_;

    }



    return false;

  }



  std::vector<bluetooth::le_audio::btle_audio_codec_config_t>
@@ -188,13 +198,43 @@ struct codec_manager_impl { 
    }

  }



  const AudioSetConfigurations* GetOffloadCodecConfig(

  const AudioSetConfigurations* GetSupportedCodecConfigurations(

      types::LeAudioContextType ctx_type) {

    if (GetCodecLocation() == le_audio::types::CodecLocation::ADSP) {

      LOG_VERBOSE("Get offload config for the context type: %d", (int)ctx_type);



      // TODO: Need to have a mechanism to switch to software session if offload

      // doesn't support.

      return context_type_offload_config_map_.count(ctx_type)

                 ? &context_type_offload_config_map_[ctx_type]

                 : nullptr;

    }



    LOG_VERBOSE("Get software config for the context type: %d", (int)ctx_type);

    return AudioSetConfigurationProvider::Get()->GetConfigurations(ctx_type);

  }



  std::unique_ptr<AudioSetConfiguration> GetCodecConfig(

      types::LeAudioContextType ctx_type,

      std::function<const set_configurations::AudioSetConfiguration*(

          types::LeAudioContextType context_type,

          const set_configurations::AudioSetConfigurations* confs)>

          non_vendor_config_matcher) {

    // Note: For the only supported right now legacy software configuration

    //       provider, we use the device group logic to match the proper

    //       configuration with group capabilities. Note that this path only

    //       supports the LC3 codec format. For the multicodec support we should

    //       rely on the configuration matcher behind the AIDL interface.

    auto conf = non_vendor_config_matcher(

        ctx_type, GetSupportedCodecConfigurations(ctx_type));

    return conf ? std::make_unique<AudioSetConfiguration>(*conf) : nullptr;

  }



  bool CheckCodecConfigIsBiDirSwb(const AudioSetConfiguration& config) {

    return AudioSetConfigurationProvider::Get()->CheckConfigurationIsBiDirSwb(

        config);

  }



  void UpdateSupportedBroadcastConfig(

      const std::vector<AudioSetConfiguration>& adsp_capabilities) {

    LOG_INFO("UpdateSupportedBroadcastConfig");
@@ -782,7 +822,8 @@ struct codec_manager_impl { 
                                           adsp_capabilities)) {

          LOG(INFO) << "Offload supported conf, context type: " << (int)ctx_type

                    << ", settings -> " << software_audio_set_conf->name;

          if (AudioSetConfigurationProvider::Get()

          if (dual_bidirection_swb_supported_ &&

              AudioSetConfigurationProvider::Get()

                  ->CheckConfigurationIsDualBiDirSwb(

                      *software_audio_set_conf)) {

            offload_dual_bidirection_swb_supported_ = true;
@@ -799,6 +840,7 @@ struct codec_manager_impl { 
  CodecLocation codec_location_ = CodecLocation::HOST;

  bool offload_enable_ = false;

  bool offload_dual_bidirection_swb_supported_ = false;

  bool dual_bidirection_swb_supported_ = false;

  types::BidirectionalPair<offloader_stream_maps_t> offloader_stream_maps;

  std::vector<bluetooth::le_audio::broadcast_offload_config>

      supported_broadcast_config;
@@ -854,12 +896,12 @@ types::CodecLocation CodecManager::GetCodecLocation(void) const { 
  return pimpl_->codec_manager_impl_->GetCodecLocation();

}



bool CodecManager::IsOffloadDualBiDirSwbSupported(void) const {

bool CodecManager::IsDualBiDirSwbSupported(void) const {

  if (!pimpl_->IsRunning()) {

    return false;

  }



  return pimpl_->codec_manager_impl_->IsOffloadDualBiDirSwbSupported();

  return pimpl_->codec_manager_impl_->IsDualBiDirSwbSupported();

}



std::vector<bluetooth::le_audio::btle_audio_codec_config_t>
@@ -891,15 +933,29 @@ void CodecManager::UpdateActiveAudioConfig( 
        stream_params, delays_ms, update_receiver);

}



const AudioSetConfigurations* CodecManager::GetOffloadCodecConfig(

    types::LeAudioContextType ctx_type) {

std::unique_ptr<AudioSetConfiguration> CodecManager::GetCodecConfig(

    types::LeAudioContextType ctx_type,

    std::function<const set_configurations::AudioSetConfiguration*(

        types::LeAudioContextType context_type,

        const set_configurations::AudioSetConfigurations* confs)>

        non_vendor_config_matcher) {

  if (pimpl_->IsRunning()) {

    return pimpl_->codec_manager_impl_->GetOffloadCodecConfig(ctx_type);

    return pimpl_->codec_manager_impl_->GetCodecConfig(

        ctx_type, non_vendor_config_matcher);

  }



  return nullptr;

}



bool CodecManager::CheckCodecConfigIsBiDirSwb(

    const set_configurations::AudioSetConfiguration& config) const {

  if (pimpl_->IsRunning()) {

    return pimpl_->codec_manager_impl_->CheckCodecConfigIsBiDirSwb(config);

  }



  return false;

}



std::unique_ptr<broadcaster::BroadcastConfiguration>

CodecManager::GetBroadcastConfig(

    const std::vector<std::pair<types::LeAudioContextType, uint8_t>>&

system/bta/le_audio/codec_manager.h

+12 −5
Original line number Diff line number Diff line
@@ -67,7 +67,7 @@ class CodecManager { 
                 offloading_preference);

  void Stop(void);

  virtual types::CodecLocation GetCodecLocation(void) const;

  virtual bool IsOffloadDualBiDirSwbSupported(void) const;

  virtual bool IsDualBiDirSwbSupported(void) const;

  virtual void UpdateCisConfiguration(

      const std::vector<struct types::cis>& cises,

      const stream_parameters& stream_params, uint8_t direction);
@@ -77,10 +77,17 @@ class CodecManager { 
      types::BidirectionalPair<uint16_t> delays_ms,

      std::function<void(const offload_config& config, uint8_t direction)>

          update_receiver);

  virtual const ::bluetooth::le_audio::set_configurations::

      AudioSetConfigurations*

      GetOffloadCodecConfig(

          ::bluetooth::le_audio::types::LeAudioContextType ctx_type);

  virtual std::unique_ptr<

      ::bluetooth::le_audio::set_configurations::AudioSetConfiguration>

  GetCodecConfig(::bluetooth::le_audio::types::LeAudioContextType ctx_type,

                 std::function<const set_configurations::AudioSetConfiguration*(

                     types::LeAudioContextType context_type,

                     const set_configurations::AudioSetConfigurations* confs)>

                     non_vendor_config_matcher);



  virtual bool CheckCodecConfigIsBiDirSwb(

      const ::bluetooth::le_audio::set_configurations::AudioSetConfiguration&

          config) const;

  virtual std::unique_ptr<broadcaster::BroadcastConfiguration>

  GetBroadcastConfig(

      const std::vector<

system/bta/le_audio/codec_manager_test.cc

+175 −3
Original line number Diff line number Diff line
@@ -118,6 +118,45 @@ static const types::LeAudioCodecId kLeAudioCodecIdLc3 = { 
    .vendor_company_id = types::kLeAudioVendorCompanyIdUndefined,

    .vendor_codec_id = types::kLeAudioVendorCodecIdUndefined};



static const set_configurations::CodecConfigSetting lc3_16_2 = {

    .id = kLeAudioCodecIdLc3,

    .params = types::LeAudioLtvMap({

        LTV_ENTRY_SAMPLING_FREQUENCY(

            codec_spec_conf::kLeAudioSamplingFreq16000Hz),

        LTV_ENTRY_FRAME_DURATION(codec_spec_conf::kLeAudioCodecFrameDur10000us),

        LTV_ENTRY_AUDIO_CHANNEL_ALLOCATION(

            codec_spec_conf::kLeAudioLocationStereo),

        LTV_ENTRY_OCTETS_PER_CODEC_FRAME(40),

    }),

    .channel_count_per_iso_stream = 1,

};



static const set_configurations::CodecConfigSetting lc3_24_2 = {

    .id = kLeAudioCodecIdLc3,

    .params = types::LeAudioLtvMap({

        LTV_ENTRY_SAMPLING_FREQUENCY(

            codec_spec_conf::kLeAudioSamplingFreq24000Hz),

        LTV_ENTRY_FRAME_DURATION(codec_spec_conf::kLeAudioCodecFrameDur10000us),

        LTV_ENTRY_AUDIO_CHANNEL_ALLOCATION(

            codec_spec_conf::kLeAudioLocationStereo),

        LTV_ENTRY_OCTETS_PER_CODEC_FRAME(60),

    }),

    .channel_count_per_iso_stream = 1,

};



static const set_configurations::CodecConfigSetting lc3_32_2 = {

    .id = kLeAudioCodecIdLc3,

    .params = types::LeAudioLtvMap({

        LTV_ENTRY_SAMPLING_FREQUENCY(

            codec_spec_conf::kLeAudioSamplingFreq32000Hz),

        LTV_ENTRY_FRAME_DURATION(codec_spec_conf::kLeAudioCodecFrameDur10000us),

        LTV_ENTRY_AUDIO_CHANNEL_ALLOCATION(

            codec_spec_conf::kLeAudioLocationStereo),

        LTV_ENTRY_OCTETS_PER_CODEC_FRAME(80),

    }),

    .channel_count_per_iso_stream = 1,

};



static const set_configurations::CodecConfigSetting lc3_48_2 = {

    .id = kLeAudioCodecIdLc3,

    .params = types::LeAudioLtvMap({
@@ -349,10 +388,23 @@ TEST_F(CodecManagerTestAdsp, test_capabilities_none) { 
      offloading_preference(0);

  codec_manager->Start(offloading_preference);



  auto match_first_config =

      [](types::LeAudioContextType context_type,

         const set_configurations::AudioSetConfigurations* confs)

      -> const set_configurations::AudioSetConfiguration* {

    if (confs && confs->size()) {

      // For simplicity return the first element, the real matcher should

      // check the group capabilities.

      return confs->at(0);

    }

    return nullptr;

  };



  // Verify every context

  for (::bluetooth::le_audio::types::LeAudioContextType ctx_type :

       ::bluetooth::le_audio::types::kLeAudioContextAllTypesArray) {

    ASSERT_EQ(nullptr, codec_manager->GetOffloadCodecConfig(ctx_type));

    ASSERT_EQ(nullptr,

              codec_manager->GetCodecConfig(ctx_type, match_first_config));

  }

}
@@ -379,9 +431,24 @@ TEST_F(CodecManagerTestAdsp, test_capabilities) { 
                 bluetooth::le_audio::LE_AUDIO_CODEC_INDEX_SOURCE_LC3}};

    codec_manager->Start(offloading_preference);



    auto cfg = codec_manager->GetOffloadCodecConfig(test_context);

    size_t available_configs_size = 0;

    auto match_first_config =

        [&available_configs_size](

            types::LeAudioContextType context_type,

            const set_configurations::AudioSetConfigurations* confs)

        -> const set_configurations::AudioSetConfiguration* {

      if (confs && confs->size()) {

        available_configs_size = confs->size();

        // For simplicity return the first element, the real matcher should

        // check the group capabilities.

        return confs->at(0);

      }

      return nullptr;

    };



    auto cfg = codec_manager->GetCodecConfig(test_context, match_first_config);

    ASSERT_NE(nullptr, cfg);

    ASSERT_EQ(offload_capabilities.size(), cfg->size());

    ASSERT_EQ(offload_capabilities.size(), available_configs_size);



    // Clean up the before testing any other offload capabilities.

    codec_manager->Stop();
@@ -489,6 +556,111 @@ TEST_F(CodecManagerTestHost, test_start) { 
  ASSERT_EQ(codec_manager->GetCodecLocation(), CodecLocation::HOST);

}



TEST_F(CodecManagerTestHost, test_non_bidir_swb) {

  const std::vector<bluetooth::le_audio::btle_audio_codec_config_t>

      offloading_preference = {

          {.codec_type = bluetooth::le_audio::LE_AUDIO_CODEC_INDEX_SOURCE_LC3}};

  codec_manager->Start(offloading_preference);



  // NON-SWB configs

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_16_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_16_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_24_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_16_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_16_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_24_2)}}));



  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_16_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_32_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_16_2)}}));



  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_24_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_24_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_24_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_32_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_24_2)}}));



  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

           types::kLeAudioDirectionSink, 1, 2, lc3_16_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

           types::kLeAudioDirectionSource, 1, 2, lc3_16_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

           types::kLeAudioDirectionSink, 1, 2, lc3_24_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

           types::kLeAudioDirectionSource, 1, 2, lc3_24_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

           types::kLeAudioDirectionSink, 1, 2, lc3_32_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

           types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

           types::kLeAudioDirectionSink, 1, 2, lc3_48_2)}}));

  ASSERT_FALSE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

           types::kLeAudioDirectionSource, 1, 2, lc3_48_2)}}));

}



TEST_F(CodecManagerTestHost, test_bidir_swb) {

  const std::vector<bluetooth::le_audio::btle_audio_codec_config_t>

      offloading_preference = {

          {.codec_type = bluetooth::le_audio::LE_AUDIO_CODEC_INDEX_SOURCE_LC3}};

  codec_manager->Start(offloading_preference);



  // SWB configs

  ASSERT_TRUE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_32_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));

  ASSERT_TRUE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_48_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_32_2)}}));

  ASSERT_TRUE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_32_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_48_2)}}));

  ASSERT_TRUE(codec_manager->CheckCodecConfigIsBiDirSwb(

      {.confs = {set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSink, 1, 2, lc3_48_2),

                 set_configurations::SetConfiguration(

                     types::kLeAudioDirectionSource, 1, 2, lc3_48_2)}}));

}



TEST_F(CodecManagerTestHost, test_dont_update_broadcast_offloader) {

  const std::vector<bluetooth::le_audio::btle_audio_codec_config_t>

      offloading_preference = {

system/bta/le_audio/device_groups.cc

+30 −32
Original line number Diff line number Diff line
@@ -752,14 +752,15 @@ bool LeAudioDeviceGroup::UpdateAudioContextAvailability(void) { 


bool LeAudioDeviceGroup::UpdateAudioSetConfigurationCache(

    LeAudioContextType ctx_type) {

  const bluetooth::le_audio::set_configurations::AudioSetConfiguration*

      new_conf = FindFirstSupportedConfiguration(ctx_type);

  auto new_conf = CodecManager::GetInstance()->GetCodecConfig(

      ctx_type, std::bind(&LeAudioDeviceGroup::FindFirstSupportedConfiguration,

                          this, std::placeholders::_1, std::placeholders::_2));

  auto update_config = true;



  if (context_to_configuration_cache_map.count(ctx_type) != 0) {

    auto [is_valid, existing_conf] =

    auto& [is_valid, existing_conf] =

        context_to_configuration_cache_map.at(ctx_type);

    update_config = (new_conf != existing_conf);

    update_config = (new_conf.get() != existing_conf.get());

    /* Just mark it as still valid */

    if (!update_config && !is_valid) {

      context_to_configuration_cache_map.at(ctx_type).first = true;
@@ -768,9 +769,12 @@ bool LeAudioDeviceGroup::UpdateAudioSetConfigurationCache( 
  }



  if (update_config) {

    context_to_configuration_cache_map[ctx_type] = std::pair(true, new_conf);

    LOG_INFO("config: %s -> %s", ToHexString(ctx_type).c_str(),

             (new_conf ? new_conf->name.c_str() : "(none)"));

    context_to_configuration_cache_map.erase(ctx_type);

    if (new_conf)

      context_to_configuration_cache_map.insert(

          std::make_pair(ctx_type, std::make_pair(true, std::move(new_conf))));

  }

  return update_config;

}
@@ -1345,18 +1349,10 @@ bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported( 
   * when all devices in the group are connected.

   */

  bool dual_bidirection_swb_supported_ =

      AudioSetConfigurationProvider::Get()->IsDualBiDirSwbSupported();

  if (Size() > 1 &&

      AudioSetConfigurationProvider::Get()->CheckConfigurationIsBiDirSwb(

      CodecManager::GetInstance()->IsDualBiDirSwbSupported();

  if (Size() > 1 && CodecManager::GetInstance()->CheckCodecConfigIsBiDirSwb(

                        *audio_set_conf)) {

    if (!dual_bidirection_swb_supported_ ||

        (CodecManager::GetInstance()->GetCodecLocation() ==

             types::CodecLocation::ADSP &&

         !CodecManager::GetInstance()->IsOffloadDualBiDirSwbSupported())) {

      /* two conditions

       * 1) dual bidirection swb is not supported for both software/offload

       * 2) offload not supported

       */

    if (!dual_bidirection_swb_supported_) {

      return false;

    }

  }
@@ -1476,7 +1472,7 @@ bool LeAudioDeviceGroup::ConfigureAses( 
  return true;

}



const set_configurations::AudioSetConfiguration*

std::shared_ptr<const set_configurations::AudioSetConfiguration>

LeAudioDeviceGroup::GetCachedConfiguration(

    LeAudioContextType context_type) const {

  if (context_to_configuration_cache_map.count(context_type) != 0) {
@@ -1485,12 +1481,12 @@ LeAudioDeviceGroup::GetCachedConfiguration( 
  return nullptr;

}



const set_configurations::AudioSetConfiguration*

std::shared_ptr<const set_configurations::AudioSetConfiguration>

LeAudioDeviceGroup::GetActiveConfiguration(void) const {

  return GetCachedConfiguration(configuration_context_type_);

}



const set_configurations::AudioSetConfiguration*

std::shared_ptr<const set_configurations::AudioSetConfiguration>

LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) {

  if (context_type == LeAudioContextType::UNINITIALIZED) {

    return nullptr;
@@ -1501,8 +1497,10 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) { 


  /* Refresh the cache if there is no valid configuration */

  if (context_to_configuration_cache_map.count(context_type) != 0) {

    std::tie(is_valid, conf) =

    auto& valid_config_pair =

        context_to_configuration_cache_map.at(context_type);

    is_valid = valid_config_pair.first;

    conf = valid_config_pair.second.get();

  }

  if (!is_valid || (conf == nullptr)) {

    UpdateAudioSetConfigurationCache(context_type);
@@ -1514,8 +1512,7 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) { 
std::optional<LeAudioCodecConfiguration>

LeAudioDeviceGroup::GetCachedCodecConfigurationByDirection(

    LeAudioContextType context_type, uint8_t direction) const {

  const set_configurations::AudioSetConfiguration* audio_set_conf =

      GetCachedConfiguration(context_type);

  auto audio_set_conf = GetCachedConfiguration(context_type);

  if (!audio_set_conf) return std::nullopt;



  LeAudioCodecConfiguration group_config = {0, 0, 0, 0};
@@ -1569,8 +1566,10 @@ LeAudioDeviceGroup::GetCodecConfigurationByDirection( 


  /* Refresh the cache if there is no valid configuration */

  if (context_to_configuration_cache_map.count(context_type) != 0) {

    std::tie(is_valid, conf) =

    auto& valid_config_pair =

        context_to_configuration_cache_map.at(context_type);

    is_valid = valid_config_pair.first;

    conf = valid_config_pair.second.get();

  }

  if (!is_valid || (conf == nullptr)) {

    UpdateAudioSetConfigurationCache(context_type);
@@ -1803,7 +1802,7 @@ bool LeAudioDeviceGroup::IsConfiguredForContext( 
  }



  /* Check if used configuration is same as the active one.*/

  return (stream_conf.conf == GetActiveConfiguration());

  return (stream_conf.conf.get() == GetActiveConfiguration().get());

}



bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported(
@@ -1828,10 +1827,8 @@ bool LeAudioDeviceGroup::IsAudioSetConfigurationSupported( 


const set_configurations::AudioSetConfiguration*

LeAudioDeviceGroup::FindFirstSupportedConfiguration(

    LeAudioContextType context_type) const {

  const set_configurations::AudioSetConfigurations* confs =

      AudioSetConfigurationProvider::Get()->GetConfigurations(context_type);



    LeAudioContextType context_type,

    const set_configurations::AudioSetConfigurations* confs) const {

  LOG_DEBUG("context type: %s,  number of connected devices: %d",

            bluetooth::common::ToString(context_type).c_str(),

            +NumOfConnected());
@@ -1880,7 +1877,8 @@ bool LeAudioDeviceGroup::Configure( 
  LOG_DEBUG(" setting context type: %s",

            bluetooth::common::ToString(context_type).c_str());



  if (!ConfigureAses(conf, context_type, metadata_context_types, ccid_lists)) {

  if (!ConfigureAses(conf.get(), context_type, metadata_context_types,

                     ccid_lists)) {

    LOG_ERROR(

        ", requested context type: %s , is in mismatch with cached available "

        "contexts",
@@ -1898,7 +1896,7 @@ bool LeAudioDeviceGroup::Configure( 
LeAudioDeviceGroup::~LeAudioDeviceGroup(void) { this->Cleanup(); }



void LeAudioDeviceGroup::PrintDebugState(void) const {

  auto* active_conf = GetActiveConfiguration();

  auto active_conf = GetActiveConfiguration();

  std::stringstream debug_str;



  debug_str << "\n Groupd id: " << group_id_
@@ -1962,7 +1960,7 @@ void LeAudioDeviceGroup::PrintDebugState(void) const { 
void LeAudioDeviceGroup::Dump(int fd, int active_group_id) const {

  bool is_active = (group_id_ == active_group_id);

  std::stringstream stream, stream_pacs;

  auto* active_conf = GetActiveConfiguration();

  auto active_conf = GetActiveConfiguration();



  stream << "\n    == Group id: " << group_id_

         << (is_enabled_ ? " enabled" : " disabled")