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

Commit a73199af authored by Bao Do's avatar Bao Do
Browse files

Remove debug name from MetadataLtv and store in in-memory structure. 

By removing it from Metadata, we introduce another mechanism to store
the name in memory structure and output the name for debugging purpose
during matching.

Bug: 395093132
Test: atest VtsHalBluetoothAudioTargetTest
Change-Id: I4b59031c7207b27c0c0cb464efa4bf86506fa29f
parent 1be0855a

bluetooth/audio/aidl/default/LeAudioOffloadAudioProvider.cpp

+48 −65
Original line number Diff line number Diff line
@@ -123,40 +123,6 @@ bool LeAudioOffloadAudioProvider::isValid(const SessionType& sessionType) { 
  return (sessionType == session_type_);

}



std::string getSettingOutputString(

    IBluetoothAudioProvider::LeAudioAseConfigurationSetting& setting) {

  std::stringstream ss;

  std::string name = "";

  if (!setting.sinkAseConfiguration.has_value() &&

      !setting.sourceAseConfiguration.has_value())

    return "";

  std::vector<

      std::optional<LeAudioAseConfigurationSetting::AseDirectionConfiguration>>*

      directionAseConfiguration;

  if (setting.sinkAseConfiguration.has_value() &&

      !setting.sinkAseConfiguration.value().empty())

    directionAseConfiguration = &setting.sinkAseConfiguration.value();

  else

    directionAseConfiguration = &setting.sourceAseConfiguration.value();

  for (auto& aseConfiguration : *directionAseConfiguration) {

    if (aseConfiguration.has_value() &&

        aseConfiguration.value().aseConfiguration.metadata.has_value()) {

      for (auto& meta :

           aseConfiguration.value().aseConfiguration.metadata.value()) {

        if (meta.has_value() &&

            meta.value().getTag() == MetadataLtv::vendorSpecific) {

          auto k = meta.value().get<MetadataLtv::vendorSpecific>().opaqueValue;

          name = std::string(k.begin(), k.end());

          break;

        }

      }

    }

  }



  ss << "setting name: " << name << ", setting: " << setting.toString();

  return ss.str();

}



ndk::ScopedAStatus LeAudioOffloadAudioProvider::startSession(

    const std::shared_ptr<IBluetoothAudioPort>& host_if,

    const AudioConfiguration& audio_config,
@@ -742,9 +708,11 @@ LeAudioOffloadAudioProvider::getRequirementMatchedAseConfigurationSettings( 
  return filtered_setting;

}



std::optional<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>

std::optional<std::pair<

    std::string, IBluetoothAudioProvider::LeAudioAseConfigurationSetting>>

LeAudioOffloadAudioProvider::matchWithRequirement(

    std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>&

    std::vector<std::pair<

        std::string, IBluetoothAudioProvider::LeAudioAseConfigurationSetting>>&

        matched_ase_configuration_settings,

    const IBluetoothAudioProvider::LeAudioConfigurationRequirement& requirement,

    bool isMatchContext, bool isExact, bool isMatchFlags) {
@@ -758,14 +726,15 @@ LeAudioOffloadAudioProvider::matchWithRequirement( 
    if (!requirement.flags.has_value()) return std::nullopt;

    requirement_flags_bitmask = requirement.flags.value().bitmask;

  }

  for (auto& setting : matched_ase_configuration_settings) {

  for (auto& [setting_name, setting] : matched_ase_configuration_settings) {

    // Try to match context.

    if (isMatchContext) {

      if ((setting.audioContext.bitmask & requirement.audioContext.bitmask) !=

          requirement.audioContext.bitmask)

        continue;

      LOG(DEBUG) << __func__ << ": Setting with matched context: "

                 << getSettingOutputString(setting);

      LOG(DEBUG) << __func__

                 << ": Setting with matched context: name: " << setting_name

                 << ", setting: " << setting.toString();

    }



    // Try to match configuration flags
@@ -774,19 +743,20 @@ LeAudioOffloadAudioProvider::matchWithRequirement( 
      if ((setting.flags.value().bitmask & requirement_flags_bitmask) !=

          requirement_flags_bitmask)

        continue;

      LOG(DEBUG) << __func__ << ": Setting with matched flags: "

                 << getSettingOutputString(setting);

      LOG(DEBUG) << __func__

                 << ": Setting with matched flags: name: " << setting_name

                 << ", setting: " << setting.toString();

    }



    auto filtered_ase_configuration_setting =

        getRequirementMatchedAseConfigurationSettings(setting, requirement,

                                                      isExact);

    if (filtered_ase_configuration_setting.has_value()) {

      LOG(INFO) << __func__ << ": Result found: "

                << getSettingOutputString(

                       filtered_ase_configuration_setting.value());

      LOG(INFO) << __func__ << ": Result found: name: " << setting_name

                << ", setting: "

                << filtered_ase_configuration_setting.value().toString();

      // Found a matched setting, ignore other settings

      return filtered_ase_configuration_setting;

      return {{setting_name, filtered_ase_configuration_setting.value()}};

    }

  }

  // If cannot satisfy this requirement, return nullopt
@@ -812,7 +782,8 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseConfiguration( 
    std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>*

        _aidl_return) {

  // Get all configuration settings

  std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>

  std::vector<std::pair<

      std::string, IBluetoothAudioProvider::LeAudioAseConfigurationSetting>>

      ase_configuration_settings =

          BluetoothAudioCodecs::GetLeAudioAseConfigurationSettings();
@@ -822,15 +793,17 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseConfiguration( 
  }



  // Matched ASE configuration with ignored audio context

  std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>

  std::vector<std::pair<

      std::string, IBluetoothAudioProvider::LeAudioAseConfigurationSetting>>

      sink_matched_ase_configuration_settings;

  std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>

  std::vector<std::pair<

      std::string, IBluetoothAudioProvider::LeAudioAseConfigurationSetting>>

      matched_ase_configuration_settings;



  // A setting must match both source and sink.

  // First filter all setting matched with sink capability

  if (in_remoteSinkAudioCapabilities.has_value()) {

    for (auto& setting : ase_configuration_settings) {

    for (auto& [setting_name, setting] : ase_configuration_settings) {

      for (auto& capability : in_remoteSinkAudioCapabilities.value()) {

        if (!capability.has_value()) continue;

        auto filtered_ase_configuration_setting =
@@ -838,7 +811,7 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseConfiguration( 
                setting, capability.value(), kLeAudioDirectionSink);

        if (filtered_ase_configuration_setting.has_value()) {

          sink_matched_ase_configuration_settings.push_back(

              filtered_ase_configuration_setting.value());

              {setting_name, filtered_ase_configuration_setting.value()});

        }

      }

    }
@@ -848,7 +821,8 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseConfiguration( 


  // Combine filter every source capability

  if (in_remoteSourceAudioCapabilities.has_value()) {

    for (auto& setting : sink_matched_ase_configuration_settings)

    for (auto& [setting_name, setting] :

         sink_matched_ase_configuration_settings)

      for (auto& capability : in_remoteSourceAudioCapabilities.value()) {

        if (!capability.has_value()) continue;

        auto filtered_ase_configuration_setting =
@@ -856,7 +830,7 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseConfiguration( 
                setting, capability.value(), kLeAudioDirectionSource);

        if (filtered_ase_configuration_setting.has_value()) {

          matched_ase_configuration_settings.push_back(

              filtered_ase_configuration_setting.value());

              {setting_name, filtered_ase_configuration_setting.value()});

        }

      }

  } else {
@@ -864,7 +838,11 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseConfiguration( 
        sink_matched_ase_configuration_settings;

  }



  std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting> result;

  std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>

      result_no_name;

  std::vector<std::pair<

      std::string, IBluetoothAudioProvider::LeAudioAseConfigurationSetting>>

      result;

  for (auto& requirement : in_requirements) {

    // For each requirement, try to match with a setting.

    // If we cannot match, return an empty result.
@@ -896,18 +874,19 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseConfiguration( 
    if (!found) {

      LOG(ERROR) << __func__

                 << ": Cannot find any match for this requirement, exitting...";

      result.clear();

      *_aidl_return = result;

      *_aidl_return = result_no_name;

      return ndk::ScopedAStatus::ok();

    }

  }



  LOG(INFO) << __func__

            << ": Found matches for all requirements, chosen settings:";

  for (auto& setting : result) {

    LOG(INFO) << __func__ << ": " << getSettingOutputString(setting);

  for (auto& [setting_name, setting] : result) {

    LOG(INFO) << __func__ << ": name: " << setting_name

              << ", setting: " << setting.toString();

    result_no_name.push_back(setting);

  }

  *_aidl_return = result;

  *_aidl_return = result_no_name;

  return ndk::ScopedAStatus::ok();

};
@@ -937,7 +916,8 @@ LeAudioOffloadAudioProvider::getDirectionQosConfiguration( 
    uint8_t direction,

    const IBluetoothAudioProvider::LeAudioAseQosConfigurationRequirement&

        qosRequirement,

    std::vector<LeAudioAseConfigurationSetting>& ase_configuration_settings,

    std::vector<std::pair<std::string, LeAudioAseConfigurationSetting>>&

        ase_configuration_settings,

    bool isExact, bool isMatchFlags) {

  auto requirement_flags_bitmask = 0;

  if (isMatchFlags) {
@@ -955,13 +935,14 @@ LeAudioOffloadAudioProvider::getDirectionQosConfiguration( 
    direction_qos_requirement = qosRequirement.sourceAseQosRequirement.value();

  }



  for (auto& setting : ase_configuration_settings) {

  for (auto& [setting_name, setting] : ase_configuration_settings) {

    // Context matching

    if ((setting.audioContext.bitmask & qosRequirement.audioContext.bitmask) !=

        qosRequirement.audioContext.bitmask)

      continue;

    LOG(DEBUG) << __func__ << ": Setting with matched context: "

               << getSettingOutputString(setting);

    LOG(DEBUG) << __func__

               << ": Setting with matched context: name: " << setting_name

               << ", setting: " << setting.toString();



    // Match configuration flags

    if (isMatchFlags) {
@@ -969,8 +950,9 @@ LeAudioOffloadAudioProvider::getDirectionQosConfiguration( 
      if ((setting.flags.value().bitmask & requirement_flags_bitmask) !=

          requirement_flags_bitmask)

        continue;

      LOG(DEBUG) << __func__ << ": Setting with matched flags: "

                 << getSettingOutputString(setting);

      LOG(DEBUG) << __func__

                 << ": Setting with matched flags: name: " << setting_name

                 << ", setting: " << setting.toString();

    }



    // Get a list of all matched AseDirectionConfiguration
@@ -1041,7 +1023,8 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::getLeAudioAseQosConfiguration( 
  IBluetoothAudioProvider::LeAudioAseQosConfigurationPair result;



  // Get all configuration settings

  std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>

  std::vector<std::pair<

      std::string, IBluetoothAudioProvider::LeAudioAseConfigurationSetting>>

      ase_configuration_settings =

          BluetoothAudioCodecs::GetLeAudioAseConfigurationSettings();

bluetooth/audio/aidl/default/LeAudioOffloadAudioProvider.h

+7 −3
Original line number Diff line number Diff line
@@ -163,15 +163,19 @@ class LeAudioOffloadAudioProvider : public BluetoothAudioProvider { 
      uint8_t direction,

      const IBluetoothAudioProvider::LeAudioAseQosConfigurationRequirement&

          qosRequirement,

      std::vector<LeAudioAseConfigurationSetting>& ase_configuration_settings,

      std::vector<std::pair<std::string, LeAudioAseConfigurationSetting>>&

          ase_configuration_settings,

      bool isExact, bool isMatchedFlag);

  bool isSubgroupConfigurationMatchedContext(

      AudioContext requirement_context,

      IBluetoothAudioProvider::BroadcastQuality quality,

      LeAudioBroadcastSubgroupConfiguration configuration);

  std::optional<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>

  std::optional<std::pair<

      std::string, IBluetoothAudioProvider::LeAudioAseConfigurationSetting>>

  matchWithRequirement(

      std::vector<IBluetoothAudioProvider::LeAudioAseConfigurationSetting>&

      std::vector<

          std::pair<std::string,

                    IBluetoothAudioProvider::LeAudioAseConfigurationSetting>>&

          matched_ase_configuration_settings,

      const IBluetoothAudioProvider::LeAudioConfigurationRequirement&

          requirements,

bluetooth/audio/utils/aidl_session/BluetoothAudioCodecs.cpp

+1 −1
Original line number Diff line number Diff line
@@ -452,7 +452,7 @@ std::vector<CodecInfo> BluetoothAudioCodecs::GetHfpOffloadCodecInfo() { 
  return kDefaultOffloadHfpCodecInfo;

}



std::vector<LeAudioAseConfigurationSetting>

std::vector<std::pair<std::string, LeAudioAseConfigurationSetting>>

BluetoothAudioCodecs::GetLeAudioAseConfigurationSettings() {

  return AudioSetConfigurationProviderJson::

      GetLeAudioAseConfigurationSettings();

bluetooth/audio/utils/aidl_session/BluetoothAudioCodecs.h

+1 −1
Original line number Diff line number Diff line
@@ -54,7 +54,7 @@ class BluetoothAudioCodecs { 
  static std::vector<CodecInfo> GetLeAudioOffloadCodecInfo(

      const SessionType& session_type);



  static std::vector<LeAudioAseConfigurationSetting>

  static std::vector<std::pair<std::string, LeAudioAseConfigurationSetting>>

  GetLeAudioAseConfigurationSettings();



  static std::vector<CodecInfo> GetHfpOffloadCodecInfo();

bluetooth/audio/utils/aidl_session/BluetoothLeAudioAseConfigurationSettingProvider.cpp

+12 −20
Original line number Diff line number Diff line
@@ -65,7 +65,8 @@ std::map<std::string, 
                    ConfigurationFlags>>

    configurations_;



std::vector<LeAudioAseConfigurationSetting> ase_configuration_settings_;

std::vector<std::pair<std::string, LeAudioAseConfigurationSetting>>

    ase_configuration_settings_;



constexpr uint8_t kIsoDataPathHci = 0x00;

constexpr uint8_t kIsoDataPathPlatformDefault = 0x01;
@@ -273,7 +274,7 @@ static const std::vector< 


/* Implementation */



std::vector<LeAudioAseConfigurationSetting>

std::vector<std::pair<std::string, LeAudioAseConfigurationSetting>>

AudioSetConfigurationProviderJson::GetLeAudioAseConfigurationSettings() {

  AudioSetConfigurationProviderJson::LoadAudioSetConfigurationProviderJson();

  return ase_configuration_settings_;
@@ -392,7 +393,7 @@ void AudioSetConfigurationProviderJson::populateConfigurationData( 
}



void AudioSetConfigurationProviderJson::populateAseConfiguration(

    const std::string& name, LeAudioAseConfiguration& ase,

    LeAudioAseConfiguration& ase,

    const le_audio::AudioSetSubConfiguration* flat_subconfig,

    const le_audio::QosConfiguration* qos_cfg,

    ConfigurationFlags& configurationFlags) {
@@ -431,12 +432,6 @@ void AudioSetConfigurationProviderJson::populateAseConfiguration( 
  }

  // Codec configuration data

  populateConfigurationData(ase, flat_subconfig->codec_configuration());

  // Populate the config name for easier debug

  auto meta = std::vector<std::optional<MetadataLtv>>();

  MetadataLtv::VendorSpecific cfg_name;

  cfg_name.opaqueValue = std::vector<uint8_t>(name.begin(), name.end());

  meta.push_back(cfg_name);

  ase.metadata = meta;

}



void AudioSetConfigurationProviderJson::populateAseQosConfiguration(
@@ -507,7 +502,6 @@ void AudioSetConfigurationProviderJson::populateAseQosConfiguration( 
// Parse into AseDirectionConfiguration

AseDirectionConfiguration

AudioSetConfigurationProviderJson::SetConfigurationFromFlatSubconfig(

    const std::string& name,

    const le_audio::AudioSetSubConfiguration* flat_subconfig,

    const le_audio::QosConfiguration* qos_cfg, CodecLocation location,

    ConfigurationFlags& configurationFlags) {
@@ -518,8 +512,7 @@ AudioSetConfigurationProviderJson::SetConfigurationFromFlatSubconfig( 
  LeAudioDataPathConfiguration path;



  // Translate into LeAudioAseConfiguration

  populateAseConfiguration(name, ase, flat_subconfig, qos_cfg,

                           configurationFlags);

  populateAseConfiguration(ase, flat_subconfig, qos_cfg, configurationFlags);



  // Translate into LeAudioAseQosConfiguration

  populateAseQosConfiguration(qos, qos_cfg, ase,
@@ -553,15 +546,14 @@ AudioSetConfigurationProviderJson::SetConfigurationFromFlatSubconfig( 
// Parse into AseDirectionConfiguration and the ConfigurationFlags

// and put them in the given list.

void AudioSetConfigurationProviderJson::processSubconfig(

    const std::string& name,

    const le_audio::AudioSetSubConfiguration* subconfig,

    const le_audio::QosConfiguration* qos_cfg,

    std::vector<std::optional<AseDirectionConfiguration>>&

        directionAseConfiguration,

    CodecLocation location, ConfigurationFlags& configurationFlags) {

  auto ase_cnt = subconfig->ase_cnt();

  auto config = SetConfigurationFromFlatSubconfig(name, subconfig, qos_cfg,

                                                  location, configurationFlags);

  auto config = SetConfigurationFromFlatSubconfig(subconfig, qos_cfg, location,

                                                  configurationFlags);

  directionAseConfiguration.push_back(config);

  // Put the same setting again.

  if (ase_cnt == 2) directionAseConfiguration.push_back(config);
@@ -646,11 +638,11 @@ void AudioSetConfigurationProviderJson::PopulateAseConfigurationFromFlat( 
    /* Load subconfigurations */

    for (auto subconfig : *codec_cfg->subconfigurations()) {

      if (subconfig->direction() == kLeAudioDirectionSink) {

        processSubconfig(flat_cfg->name()->str(), subconfig, qos_sink_cfg,

                         sinkAseConfiguration, location, configurationFlags);

        processSubconfig(subconfig, qos_sink_cfg, sinkAseConfiguration,

                         location, configurationFlags);

      } else {

        processSubconfig(flat_cfg->name()->str(), subconfig, qos_source_cfg,

                         sourceAseConfiguration, location, configurationFlags);

        processSubconfig(subconfig, qos_source_cfg, sourceAseConfiguration,

                         location, configurationFlags);

      }

    }
@@ -860,7 +852,7 @@ bool AudioSetConfigurationProviderJson::LoadScenariosFromFiles( 
      setting.flags = flags;

      // Add to list of setting

      LOG(DEBUG) << "Pushing configuration to list: " << config_name;

      ase_configuration_settings_.push_back(setting);

      ase_configuration_settings_.push_back({config_name, setting});

    }

  }