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

Commit 3c4427cb authored by shihchienc's avatar shihchienc Committed by Patrick Chang
Browse files

leaudio: Set and use preferred config 

This patch is to implement `SetCodecConfigPreference`. Also when getting
active configuration, check if preferred config is used first.

Bug: 259191520
Bug: 353909820
Bug: 351229684
Test: mm packages/modules/Bluetooth
Test set preferred config with remote devices having different
strategies, later join, reconnection. Check if reconfiguration happen
during streaming if preferred config is adopted
Test: check set codec preference works in both legacy and multi codec.
Test: atest bluetooth_le_audio_test bluetooth_le_audio_client_test
Flag: com.android.bluetooth.flags.leaudio_set_codec_config_preference
Change-Id: I94621b18a3236bb010bcf74817daca5febea4fca
parent 74096f0c

system/bta/include/bta_le_audio_api.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -61,6 +61,7 @@ public: 
  virtual void SetCodecConfigPreference(

  virtual void SetCodecConfigPreference(

          int group_id, bluetooth::le_audio::btle_audio_codec_config_t input_codec_config,

          int group_id, bluetooth::le_audio::btle_audio_codec_config_t input_codec_config,

          bluetooth::le_audio::btle_audio_codec_config_t output_codec_config) = 0;

          bluetooth::le_audio::btle_audio_codec_config_t output_codec_config) = 0;

  virtual bool IsUsingPreferredCodecConfig(int group_id, int context_type) = 0;

  virtual void SetCcidInformation(int ccid, int context_type) = 0;

  virtual void SetCcidInformation(int ccid, int context_type) = 0;

  virtual void SetInCall(bool in_call) = 0;

  virtual void SetInCall(bool in_call) = 0;

  virtual bool IsInCall() = 0;

  virtual bool IsInCall() = 0;

system/bta/le_audio/client.cc

+44 −2
Original line number Original line Diff line number Diff line
@@ -47,6 +47,7 @@ 
#include "gatt_api.h"

#include "gatt_api.h"

#include "hci/controller_interface.h"

#include "hci/controller_interface.h"

#include "internal_include/stack_config.h"

#include "internal_include/stack_config.h"

#include "le_audio/device_groups.h"

#include "le_audio_health_status.h"

#include "le_audio_health_status.h"

#include "le_audio_set_configuration_provider.h"

#include "le_audio_set_configuration_provider.h"

#include "le_audio_types.h"

#include "le_audio_types.h"
@@ -987,7 +988,45 @@ public: 
  void SetCodecConfigPreference(

  void SetCodecConfigPreference(

          int group_id, bluetooth::le_audio::btle_audio_codec_config_t input_codec_config,

          int group_id, bluetooth::le_audio::btle_audio_codec_config_t input_codec_config,

          bluetooth::le_audio::btle_audio_codec_config_t output_codec_config) override {

          bluetooth::le_audio::btle_audio_codec_config_t output_codec_config) override {

    // TODO Implement

    if (!com::android::bluetooth::flags::leaudio_set_codec_config_preference()) {

      log::debug("leaudio_set_codec_config_preference flag is not enabled");

      return;

    }



    LeAudioDeviceGroup* group = aseGroups_.FindById(group_id);



    if (!group) {

      log::error("Unknown group id: %d", group_id);

    }



    if (group->SetPreferredAudioSetConfiguration(input_codec_config, output_codec_config)) {

      log::info("group id: {}, setting preferred codec is successful.", group_id);

    } else {

      log::warn("group id: {}, setting preferred codec is failed.", group_id);

      return;

    }



    if (group_id != active_group_id_) {

      log::warn("Selected group is not active.");

      return;

    }



    if (SetConfigurationAndStopStreamWhenNeeded(group, group->GetConfigurationContextType())) {

      log::debug("Group id {} do the reconfiguration based on preferred codec config", group_id);

    } else {

      log::debug("Group id {} preferred codec config is not changed", group_id);

    }

  }



  bool IsUsingPreferredCodecConfig(int group_id, int context_type) {

    LeAudioDeviceGroup* group = aseGroups_.FindById(group_id);

    if (!group) {

      log::error("Unknown group id: %d", group_id);

      return false;

    }



    return group->IsUsingPreferredAudioSetConfiguration(

            static_cast<LeAudioContextType>(context_type));

  }

  }





  void SetCcidInformation(int ccid, int context_type) override {

  void SetCcidInformation(int ccid, int context_type) override {
@@ -4170,7 +4209,10 @@ public: 




  inline bool IsDirectionAvailableForCurrentConfiguration(const LeAudioDeviceGroup* group,

  inline bool IsDirectionAvailableForCurrentConfiguration(const LeAudioDeviceGroup* group,

                                                          uint8_t direction) const {

                                                          uint8_t direction) const {

    auto current_config = group->GetCachedConfiguration(configuration_context_type_);

    auto current_config =

            group->IsUsingPreferredAudioSetConfiguration(configuration_context_type_)

                    ? group->GetCachedPreferredConfiguration(configuration_context_type_)

                    : group->GetCachedConfiguration(configuration_context_type_);

    if (current_config) {

    if (current_config) {

      return current_config->confs.get(direction).size() != 0;

      return current_config->confs.get(direction).size() != 0;

    }

    }

system/bta/le_audio/device_groups.cc

+53 −1
Original line number Original line Diff line number Diff line
@@ -971,6 +971,22 @@ bool LeAudioDeviceGroup::SetPreferredAudioSetConfiguration( 
  return is_updated;

  return is_updated;

}

}





bool LeAudioDeviceGroup::IsUsingPreferredAudioSetConfiguration(

        const LeAudioContextType& context_type) const {

  if (!preferred_config_.sink || !preferred_config_.source) {

    log::assert_that(!preferred_config_.sink && !preferred_config_.source,

                     "Preferred config should be null for both direction");

    return false;

  }



  if (preferred_config_.sink->codec_priority == -1 ||

      preferred_config_.source->codec_priority == -1) {

    return false;

  }



  return GetPreferredConfiguration(context_type).get();

}



void LeAudioDeviceGroup::ResetPreferredAudioSetConfiguration(void) const {

void LeAudioDeviceGroup::ResetPreferredAudioSetConfiguration(void) const {

  log::info("Reset preferred configuration cached for all cotexts.");

  log::info("Reset preferred configuration cached for all cotexts.");

  context_to_preferred_configuration_cache_map_.clear();

  context_to_preferred_configuration_cache_map_.clear();
@@ -1711,9 +1727,19 @@ LeAudioDeviceGroup::GetCachedConfiguration(LeAudioContextType context_type) cons 
  return nullptr;

  return nullptr;

}

}





std::shared_ptr<const set_configurations::AudioSetConfiguration>

LeAudioDeviceGroup::GetCachedPreferredConfiguration(LeAudioContextType context_type) const {

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

    return context_to_preferred_configuration_cache_map_.at(context_type).second;

  }

  return nullptr;

}



std::shared_ptr<const set_configurations::AudioSetConfiguration>

std::shared_ptr<const set_configurations::AudioSetConfiguration>

LeAudioDeviceGroup::GetActiveConfiguration(void) const {

LeAudioDeviceGroup::GetActiveConfiguration(void) const {

  return GetCachedConfiguration(configuration_context_type_);

  return IsUsingPreferredAudioSetConfiguration(configuration_context_type_)

                 ? GetCachedPreferredConfiguration(configuration_context_type_)

                 : GetCachedConfiguration(configuration_context_type_);

}

}





std::shared_ptr<const set_configurations::AudioSetConfiguration>

std::shared_ptr<const set_configurations::AudioSetConfiguration>
@@ -1722,6 +1748,11 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) const { 
    return nullptr;

    return nullptr;

  }

  }





  if (IsUsingPreferredAudioSetConfiguration(context_type)) {

    log::debug("Using preferred codec config: {}", common::ToString(context_type));

    return GetCachedPreferredConfiguration(context_type);

  }



  const set_configurations::AudioSetConfiguration* conf = nullptr;

  const set_configurations::AudioSetConfiguration* conf = nullptr;

  bool is_valid = false;

  bool is_valid = false;
@@ -1738,6 +1769,27 @@ LeAudioDeviceGroup::GetConfiguration(LeAudioContextType context_type) const { 
  return GetCachedConfiguration(context_type);

  return GetCachedConfiguration(context_type);

}

}





std::shared_ptr<const set_configurations::AudioSetConfiguration>

LeAudioDeviceGroup::GetPreferredConfiguration(LeAudioContextType context_type) const {

  if (context_type == LeAudioContextType::UNINITIALIZED) {

    return nullptr;

  }



  const set_configurations::AudioSetConfiguration* conf = nullptr;

  bool is_valid = false;



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

    auto& valid_config_pair = context_to_preferred_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, true);

  }



  return GetCachedPreferredConfiguration(context_type);

}



LeAudioCodecConfiguration LeAudioDeviceGroup::GetAudioSessionCodecConfigForDirection(

LeAudioCodecConfiguration LeAudioDeviceGroup::GetAudioSessionCodecConfigForDirection(

        LeAudioContextType context_type, uint8_t direction) const {

        LeAudioContextType context_type, uint8_t direction) const {

  auto audio_set_conf = GetConfiguration(context_type);

  auto audio_set_conf = GetConfiguration(context_type);

system/bta/le_audio/device_groups.h

+5 −0
Original line number Original line Diff line number Diff line
@@ -214,6 +214,7 @@ public: 
  bool SetPreferredAudioSetConfiguration(

  bool SetPreferredAudioSetConfiguration(

          const bluetooth::le_audio::btle_audio_codec_config_t& input_codec_config,

          const bluetooth::le_audio::btle_audio_codec_config_t& input_codec_config,

          const bluetooth::le_audio::btle_audio_codec_config_t& output_codec_config) const;

          const bluetooth::le_audio::btle_audio_codec_config_t& output_codec_config) const;

  bool IsUsingPreferredAudioSetConfiguration(const types::LeAudioContextType& context_type) const;

  void ResetPreferredAudioSetConfiguration(void) const;

  void ResetPreferredAudioSetConfiguration(void) const;

  bool ReloadAudioLocations(void);

  bool ReloadAudioLocations(void);

  bool ReloadAudioDirections(void);

  bool ReloadAudioDirections(void);
@@ -222,8 +223,12 @@ public: 
  bool IsPendingConfiguration(void) const;

  bool IsPendingConfiguration(void) const;

  std::shared_ptr<const set_configurations::AudioSetConfiguration> GetConfiguration(

  std::shared_ptr<const set_configurations::AudioSetConfiguration> GetConfiguration(

          types::LeAudioContextType ctx_type) const;

          types::LeAudioContextType ctx_type) const;

  std::shared_ptr<const set_configurations::AudioSetConfiguration> GetPreferredConfiguration(

          types::LeAudioContextType ctx_type) const;

  std::shared_ptr<const set_configurations::AudioSetConfiguration> GetCachedConfiguration(

  std::shared_ptr<const set_configurations::AudioSetConfiguration> GetCachedConfiguration(

          types::LeAudioContextType ctx_type) const;

          types::LeAudioContextType ctx_type) const;

  std::shared_ptr<const set_configurations::AudioSetConfiguration> GetCachedPreferredConfiguration(

          types::LeAudioContextType ctx_type) const;

  void InvalidateCachedConfigurations(void);

  void InvalidateCachedConfigurations(void);

  void SetPendingConfiguration(void);

  void SetPendingConfiguration(void);

  void ClearPendingConfiguration(void);

  void ClearPendingConfiguration(void);