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

Commit f609a972 authored by Jakub Tyszkowski's avatar Jakub Tyszkowski
Browse files

LeAudio: Improve context type management function naming 

While the previous change was focused on the data type
system used for passing audio contexts, this one takes the
code logic into the account and improves the naming scheme
for better context awareness and code readability.

It renames functions around the context type management.
The 'active context' term was ambigious and was replaced
with 'available context', which the BT spec. is using.
Functions now use more coherent naming scheme and since
some of them were returning a bit masks which were
not bit-tested but logically ANDed with other booleans,
they now return boolean type to avoid the confusion and
implicit conversion bugs to happen.

Test: atest --host bluetooth_le_audio_test bluetooth_le_audio_client_test bluetooth_test_broadcaster bluetooth_test_broadcaster_state_machine  --no-bazel-mode
Bug: 249737696
Tag: #refactor
Change-Id: I4305dc64c04bedb904d5e23ef29f5282a27a2860
parent 97f2d3a8

system/bta/le_audio/client.cc

+38 −37
Original line number Diff line number Diff line
@@ -392,14 +392,14 @@ class LeAudioClientImpl : public LeAudioClient { 
    auto location_update = group->ReloadAudioLocations();

    group->ReloadAudioDirections();



    std::optional<AudioContexts> new_group_updated_contexts =

        group->UpdateActiveContextsMap(leAudioDevice->GetAvailableContexts());

    auto contexts_updated = group->UpdateAudioContextTypeAvailability(

        leAudioDevice->GetAvailableContexts());



    if (new_group_updated_contexts || location_update) {

    if (contexts_updated || location_update) {

      callbacks_->OnAudioConf(group->audio_directions_, group->group_id_,

                              group->snk_audio_locations_.to_ulong(),

                              group->src_audio_locations_.to_ulong(),

                              group->GetActiveContexts().value());

                              group->GetAvailableContexts().value());

    }

  }
@@ -528,18 +528,18 @@ class LeAudioClientImpl : public LeAudioClient { 
    /* Group may be destroyed once moved its last node to new group */

    if (aseGroups_.FindById(old_group_id) != nullptr) {

      /* Removing node from group may touch its context integrity */

      std::optional<AudioContexts> old_group_updated_contexts =

          old_group->UpdateActiveContextsMap(old_group->GetActiveContexts());

      auto contexts_updated = old_group->UpdateAudioContextTypeAvailability(

          old_group->GetAvailableContexts());



      bool group_conf_changed = old_group->ReloadAudioLocations();

      group_conf_changed |= old_group->ReloadAudioDirections();

      group_conf_changed |= old_group_updated_contexts.has_value();

      group_conf_changed |= contexts_updated;



      if (group_conf_changed) {

        callbacks_->OnAudioConf(old_group->audio_directions_, old_group_id,

                                old_group->snk_audio_locations_.to_ulong(),

                                old_group->src_audio_locations_.to_ulong(),

                                old_group->GetActiveContexts().value());

                                old_group->GetAvailableContexts().value());

      }

    }
@@ -595,18 +595,18 @@ class LeAudioClientImpl : public LeAudioClient { 
    }



    /* Removing node from group touch its context integrity */

    std::optional<AudioContexts> updated_contexts =

        group->UpdateActiveContextsMap(group->GetActiveContexts());

    bool contexts_updated = group->UpdateAudioContextTypeAvailability(

        group->GetAvailableContexts());



    bool group_conf_changed = group->ReloadAudioLocations();

    group_conf_changed |= group->ReloadAudioDirections();

    group_conf_changed |= updated_contexts.has_value();

    group_conf_changed |= contexts_updated;



    if (group_conf_changed)

      callbacks_->OnAudioConf(group->audio_directions_, group->group_id_,

                              group->snk_audio_locations_.to_ulong(),

                              group->src_audio_locations_.to_ulong(),

                              group->GetActiveContexts().value());

                              group->GetAvailableContexts().value());

  }



  void GroupRemoveNode(const int group_id, const RawAddress& address) override {
@@ -695,7 +695,7 @@ class LeAudioClientImpl : public LeAudioClient { 
      return false;

    }



    if (!group->GetActiveContexts().test(context_type)) {

    if (!group->GetAvailableContexts().test(context_type)) {

      LOG(ERROR) << " Unsupported context type by remote device: "

                 << ToHexString(context_type) << ". Switching to unspecified";

      final_context_type = LeAudioContextType::UNSPECIFIED;
@@ -1279,17 +1279,17 @@ class LeAudioClientImpl : public LeAudioClient { 
      /* Update supported context types including internal capabilities */

      LeAudioDeviceGroup* group = aseGroups_.FindById(leAudioDevice->group_id_);



      /* Active context map should be considered to be updated in response to

      /* Available context map should be considered to be updated in response to

       * PACs update.

       * Read of available context during initial attribute discovery.

       * Group would be assigned once service search is completed.

       */

      if (group && group->UpdateActiveContextsMap(

      if (group && group->UpdateAudioContextTypeAvailability(

                       leAudioDevice->GetAvailableContexts())) {

        callbacks_->OnAudioConf(group->audio_directions_, group->group_id_,

                                group->snk_audio_locations_.to_ulong(),

                                group->src_audio_locations_.to_ulong(),

                                group->GetActiveContexts().value());

                                group->GetAvailableContexts().value());

      }

      if (notify) {

        btif_storage_leaudio_update_pacs_bin(leAudioDevice->address_);
@@ -1313,17 +1313,17 @@ class LeAudioClientImpl : public LeAudioClient { 
      /* Update supported context types including internal capabilities */

      LeAudioDeviceGroup* group = aseGroups_.FindById(leAudioDevice->group_id_);



      /* Active context map should be considered to be updated in response to

      /* Available context map should be considered to be updated in response to

       * PACs update.

       * Read of available context during initial attribute discovery.

       * Group would be assigned once service search is completed.

       */

      if (group && group->UpdateActiveContextsMap(

      if (group && group->UpdateAudioContextTypeAvailability(

                       leAudioDevice->GetAvailableContexts())) {

        callbacks_->OnAudioConf(group->audio_directions_, group->group_id_,

                                group->snk_audio_locations_.to_ulong(),

                                group->src_audio_locations_.to_ulong(),

                                group->GetActiveContexts().value());

                                group->GetAvailableContexts().value());

      }



      if (notify) {
@@ -1374,7 +1374,7 @@ class LeAudioClientImpl : public LeAudioClient { 
        callbacks_->OnAudioConf(group->audio_directions_, group->group_id_,

                                group->snk_audio_locations_.to_ulong(),

                                group->src_audio_locations_.to_ulong(),

                                group->GetActiveContexts().value());

                                group->GetAvailableContexts().value());

      }

    } else if (hdl == leAudioDevice->src_audio_locations_hdls_.val_hdl) {

      AudioLocations src_audio_locations;
@@ -1416,7 +1416,7 @@ class LeAudioClientImpl : public LeAudioClient { 
        callbacks_->OnAudioConf(group->audio_directions_, group->group_id_,

                                group->snk_audio_locations_.to_ulong(),

                                group->src_audio_locations_.to_ulong(),

                                group->GetActiveContexts().value());

                                group->GetAvailableContexts().value());

      }

    } else if (hdl == leAudioDevice->audio_avail_hdls_.val_hdl) {

      le_audio::client_parser::pacs::acs_available_audio_contexts
@@ -1429,7 +1429,7 @@ class LeAudioClientImpl : public LeAudioClient { 
          avail_audio_contexts.src_avail_cont);



      if (updated_avail_contexts.any()) {

        /* Update scenario map considering changed active context types */

        /* Update scenario map considering changed available context types */

        LeAudioDeviceGroup* group =

            aseGroups_.FindById(leAudioDevice->group_id_);

        /* Read of available context during initial attribute discovery.
@@ -1443,15 +1443,17 @@ class LeAudioClientImpl : public LeAudioClient { 
          if (group->IsInTransition() ||

              (group->GetState() ==

               AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING)) {

            group->SetPendingUpdateAvailableContexts(updated_avail_contexts);

            group->SetPendingAvailableContextsChange(updated_avail_contexts);

            return;

          }



          if (group->UpdateActiveContextsMap(updated_avail_contexts)) {

          auto contexts_updated =

              group->UpdateAudioContextTypeAvailability(updated_avail_contexts);

          if (contexts_updated) {

            callbacks_->OnAudioConf(group->audio_directions_, group->group_id_,

                                    group->snk_audio_locations_.to_ulong(),

                                    group->src_audio_locations_.to_ulong(),

                                    group->GetActiveContexts().value());

                                    group->GetAvailableContexts().value());

          }

        }

      }
@@ -3439,7 +3441,7 @@ class LeAudioClientImpl : public LeAudioClient { 
    }



    metadata_context_types_ |= GetAllowedAudioContextsFromSourceMetadata(

        source_metadata, group->GetActiveContexts());

        source_metadata, group->GetAvailableContexts());



    if (stack_config_get_interface()

            ->get_pts_force_le_audio_multiple_contexts_metadata()) {
@@ -3740,21 +3742,20 @@ class LeAudioClientImpl : public LeAudioClient { 
        rxUnreceivedPackets, duplicatePackets);

  }



  void HandlePendingAvailableContexts(LeAudioDeviceGroup* group) {

  void HandlePendingAvailableContextsChange(LeAudioDeviceGroup* group) {

    if (!group) return;



    /* Update group configuration with pending available context */

    std::optional<AudioContexts> pending_update_available_contexts =

        group->GetPendingUpdateAvailableContexts();

    if (pending_update_available_contexts) {

      if (group->UpdateActiveContextsMap(*pending_update_available_contexts)) {

    /* Update group configuration with pending available context change */

    auto contexts = group->GetPendingAvailableContextsChange();

    if (contexts.any()) {

      auto success = group->UpdateAudioContextTypeAvailability(contexts);

      if (success) {

        callbacks_->OnAudioConf(group->audio_directions_, group->group_id_,

                                group->snk_audio_locations_.to_ulong(),

                                group->src_audio_locations_.to_ulong(),

                                group->GetActiveContexts().value());

                                group->GetAvailableContexts().value());

      }



      group->SetPendingUpdateAvailableContexts(std::nullopt);

      group->ClearPendingAvailableContextsChange();

    }

  }
@@ -3883,7 +3884,7 @@ class LeAudioClientImpl : public LeAudioClient { 
         * so Audio HAL can Resume again.

         */

        CancelStreamingRequest();

        HandlePendingAvailableContexts(group);

        HandlePendingAvailableContextsChange(group);

        ReconfigurationComplete(previously_active_directions);

      } break;

      case GroupStreamStatus::CONFIGURED_AUTONOMOUS:
@@ -3911,7 +3912,7 @@ class LeAudioClientImpl : public LeAudioClient { 
        CancelStreamingRequest();

        if (group) {

          NotifyUpperLayerGroupTurnedIdleDuringCall(group->group_id_);

          HandlePendingAvailableContexts(group);

          HandlePendingAvailableContextsChange(group);

          HandlePendingDeviceDisconnection(group);

        }

        break;

system/bta/le_audio/devices.cc

+36 −36
Original line number Diff line number Diff line
@@ -720,32 +720,34 @@ uint16_t LeAudioDeviceGroup::GetRemoteDelay(uint8_t direction) { 
  return remote_delay_ms;

}



/* This method returns AudioContext value if support for any type has changed */

std::optional<AudioContexts> LeAudioDeviceGroup::UpdateActiveContextsMap(void) {

  LOG_DEBUG(" group id: %d, active contexts: %s", group_id_,

            active_contexts_mask_.to_string().c_str());

  return UpdateActiveContextsMap(active_contexts_mask_);

void LeAudioDeviceGroup::UpdateAudioContextTypeAvailability(void) {

  LOG_DEBUG(" group id: %d, available contexts: %s", group_id_,

            group_available_contexts_.to_string().c_str());

  UpdateAudioContextTypeAvailability(group_available_contexts_);

}



/* This method returns AudioContext value if support for any type has changed */

std::optional<AudioContexts> LeAudioDeviceGroup::UpdateActiveContextsMap(

/* Returns true if support for any type in the whole group has changed,

 * otherwise false. */

bool LeAudioDeviceGroup::UpdateAudioContextTypeAvailability(

    AudioContexts update_contexts) {

  auto contexts = AudioContexts();

  auto new_contexts = AudioContexts();

  bool active_contexts_has_been_modified = false;



  if (update_contexts.none()) {

    LOG_DEBUG("No context updated");

    return contexts;

    return false;

  }



  LOG_DEBUG("Updated context: %s", update_contexts.to_string().c_str());



  for (LeAudioContextType ctx_type : types::kLeAudioContextAllTypesArray) {

    LOG_DEBUG("Checking context: %s", ToHexString(ctx_type).c_str());



    if (!update_contexts.test(ctx_type)) {

      LOG_DEBUG("Configuration not in updated context");

      /* Fill context bitset for possible returned value if updated */

      if (active_context_to_configuration_map.count(ctx_type) > 0)

        contexts.set(ctx_type);

      if (available_context_to_configuration_map.count(ctx_type) > 0)

        new_contexts.set(ctx_type);



      continue;

    }
@@ -753,8 +755,8 @@ std::optional<AudioContexts> LeAudioDeviceGroup::UpdateActiveContextsMap( 
    auto new_conf = FindFirstSupportedConfiguration(ctx_type);



    bool ctx_previously_not_supported =

        (active_context_to_configuration_map.count(ctx_type) == 0 ||

         active_context_to_configuration_map[ctx_type] == nullptr);

        (available_context_to_configuration_map.count(ctx_type) == 0 ||

         available_context_to_configuration_map[ctx_type] == nullptr);

    /* Check if support for context type has changed */

    if (ctx_previously_not_supported) {

      /* Current configuration for context type is empty */
@@ -763,22 +765,22 @@ std::optional<AudioContexts> LeAudioDeviceGroup::UpdateActiveContextsMap( 
        continue;

      } else {

        /* Configuration changes from empty to some */

        contexts.set(ctx_type);

        new_contexts.set(ctx_type);

        active_contexts_has_been_modified = true;

      }

    } else {

      /* Current configuration for context type is not empty */

      if (new_conf == nullptr) {

        /* Configuration changed to empty */

        contexts.unset(ctx_type);

        new_contexts.unset(ctx_type);

        active_contexts_has_been_modified = true;

      } else if (new_conf != active_context_to_configuration_map[ctx_type]) {

      } else if (new_conf != available_context_to_configuration_map[ctx_type]) {

        /* Configuration changed to any other */

        contexts.set(ctx_type);

        new_contexts.set(ctx_type);

        active_contexts_has_been_modified = true;

      } else {

        /* Configuration is the same */

        contexts.set(ctx_type);

        new_contexts.set(ctx_type);

        continue;

      }

    }
@@ -787,20 +789,18 @@ std::optional<AudioContexts> LeAudioDeviceGroup::UpdateActiveContextsMap( 
        "updated context: %s, %s -> %s", ToHexString(ctx_type).c_str(),

        (ctx_previously_not_supported

             ? "empty"

             : active_context_to_configuration_map[ctx_type]->name.c_str()),

             : available_context_to_configuration_map[ctx_type]->name.c_str()),

        (new_conf != nullptr ? new_conf->name.c_str() : "empty"));



    active_context_to_configuration_map[ctx_type] = new_conf;

    available_context_to_configuration_map[ctx_type] = new_conf;

  }



  /* Some contexts have changed, return new active context bitset */

  /* Some contexts have changed, return new available context bitset */

  if (active_contexts_has_been_modified) {

    active_contexts_mask_ = contexts;

    return contexts;

    group_available_contexts_ = new_contexts;

  }



  /* Nothing has changed */

  return std::nullopt;

  return active_contexts_has_been_modified;

}



bool LeAudioDeviceGroup::ReloadAudioLocations(void) {
@@ -1600,21 +1600,21 @@ bool LeAudioDeviceGroup::ConfigureAses( 
  LOG(INFO) << "Choosed ASE Configuration for group: " << this->group_id_

            << " configuration: " << audio_set_conf->name;



  active_context_type_ = context_type;

  configuration_context_type_ = context_type;

  metadata_context_type_ = metadata_context_type;

  return true;

}



const set_configurations::AudioSetConfiguration*

LeAudioDeviceGroup::GetActiveConfiguration(void) {

  return active_context_to_configuration_map[active_context_type_];

  return available_context_to_configuration_map[configuration_context_type_];

}



std::optional<LeAudioCodecConfiguration>

LeAudioDeviceGroup::GetCodecConfigurationByDirection(

    types::LeAudioContextType group_context_type, uint8_t direction) {

  const set_configurations::AudioSetConfiguration* audio_set_conf =

      active_context_to_configuration_map[group_context_type];

      available_context_to_configuration_map[group_context_type];

  LeAudioCodecConfiguration group_config = {0, 0, 0, 0};

  if (!audio_set_conf) return std::nullopt;
@@ -1662,10 +1662,10 @@ LeAudioDeviceGroup::GetCodecConfigurationByDirection( 


bool LeAudioDeviceGroup::IsContextSupported(

    types::LeAudioContextType group_context_type) {

  auto iter = active_context_to_configuration_map.find(group_context_type);

  if (iter == active_context_to_configuration_map.end()) return false;

  auto iter = available_context_to_configuration_map.find(group_context_type);

  if (iter == available_context_to_configuration_map.end()) return false;



  return active_context_to_configuration_map[group_context_type] != nullptr;

  return available_context_to_configuration_map[group_context_type] != nullptr;

}



bool LeAudioDeviceGroup::IsMetadataChanged(
@@ -1872,14 +1872,14 @@ bool LeAudioDeviceGroup::Configure(LeAudioContextType context_type, 
                                   AudioContexts metadata_context_type,

                                   std::vector<uint8_t> ccid_list) {

  const set_configurations::AudioSetConfiguration* conf =

      active_context_to_configuration_map[context_type];

      available_context_to_configuration_map[context_type];



  DLOG(INFO) << __func__;



  if (!conf) {

    LOG(ERROR) << __func__ << ", requested context type: "

               << loghex(static_cast<uint16_t>(context_type))

               << ", is in mismatch with cached active contexts";

               << ", is in mismatch with cached available contexts";

    return false;

  }
@@ -1888,7 +1888,7 @@ bool LeAudioDeviceGroup::Configure(LeAudioContextType context_type, 
  if (!ConfigureAses(conf, context_type, metadata_context_type, ccid_list)) {

    LOG(ERROR) << __func__ << ", requested pick ASE config context type: "

               << loghex(static_cast<uint16_t>(context_type))

               << ", is in mismatch with cached active contexts";

               << ", is in mismatch with cached available contexts";

    return false;

  }
@@ -1910,9 +1910,9 @@ void LeAudioDeviceGroup::Dump(int fd, int active_group_id) { 
         << "      state: " << GetState()

         << ",\ttarget state: " << GetTargetState()

         << ",\tcig state: " << cig_state_ << "\n"

         << "      group available contexts: " << GetActiveContexts() << "\n"

         << "      group available contexts: " << GetAvailableContexts()

         << "      configuration context type: "

         << bluetooth::common::ToString(GetCurrentContextType()).c_str() << "\n"

         << bluetooth::common::ToString(GetConfigurationContextType()).c_str()

         << "      active configuration name: "

         << (active_conf ? active_conf->name : " not set") << "\n"

         << "      stream configuration: "

system/bta/le_audio/devices.h

+42 −23
Original line number Diff line number Diff line
@@ -234,10 +234,11 @@ class LeAudioDeviceGroup { 
        audio_directions_(0),

        transport_latency_mtos_us_(0),

        transport_latency_stom_us_(0),

        active_context_type_(types::LeAudioContextType::UNINITIALIZED),

        metadata_context_type_(0),

        active_contexts_mask_(0),

        pending_update_available_contexts_(std::nullopt),

        configuration_context_type_(types::LeAudioContextType::UNINITIALIZED),

        metadata_context_type_(types::LeAudioContextType::UNINITIALIZED),

        group_available_contexts_(types::LeAudioContextType::UNINITIALIZED),

        pending_group_available_contexts_change_(

            types::LeAudioContextType::UNINITIALIZED),

        target_state_(types::AseState::BTA_LE_AUDIO_ASE_STATE_IDLE),

        current_state_(types::AseState::BTA_LE_AUDIO_ASE_STATE_IDLE) {}

  ~LeAudioDeviceGroup(void);
@@ -300,9 +301,8 @@ class LeAudioDeviceGroup { 
  uint8_t GetTargetPhy(uint8_t direction);

  bool GetPresentationDelay(uint32_t* delay, uint8_t direction);

  uint16_t GetRemoteDelay(uint8_t direction);

  std::optional<types::AudioContexts> UpdateActiveContextsMap(

      types::AudioContexts contexts);

  std::optional<types::AudioContexts> UpdateActiveContextsMap(void);

  bool UpdateAudioContextTypeAvailability(types::AudioContexts contexts);

  void UpdateAudioContextTypeAvailability(void);

  bool ReloadAudioLocations(void);

  bool ReloadAudioDirections(void);

  const set_configurations::AudioSetConfiguration* GetActiveConfiguration(void);
@@ -334,25 +334,31 @@ class LeAudioDeviceGroup { 
    target_state_ = state;

  }



  inline std::optional<types::AudioContexts> GetPendingUpdateAvailableContexts()

      const {

    return pending_update_available_contexts_;

  /* Returns context types for which support was recently added or removed */

  inline types::AudioContexts GetPendingAvailableContextsChange() const {

    return pending_group_available_contexts_change_;

  }

  inline void SetPendingUpdateAvailableContexts(

      std::optional<types::AudioContexts> audio_contexts) {

    pending_update_available_contexts_ = audio_contexts;



  /* Set which context types were recently added or removed */

  inline void SetPendingAvailableContextsChange(

      types::AudioContexts audio_contexts) {

    pending_group_available_contexts_change_ = audio_contexts;

  }



  inline void ClearPendingAvailableContextsChange() {

    pending_group_available_contexts_change_.clear();

  }



  inline types::LeAudioContextType GetCurrentContextType(void) const {

    return active_context_type_;

  inline types::LeAudioContextType GetConfigurationContextType(void) const {

    return configuration_context_type_;

  }



  inline types::AudioContexts GetMetadataContextType(void) const {

  inline types::AudioContexts GetMetadataContexts(void) const {

    return metadata_context_type_;

  }



  inline types::AudioContexts GetActiveContexts(void) {

    return active_contexts_mask_;

  inline types::AudioContexts GetAvailableContexts(void) {

    return group_available_contexts_;

  }



  bool IsInTransition(void);
@@ -375,15 +381,28 @@ class LeAudioDeviceGroup { 
      types::LeAudioContextType context_type);

  uint32_t GetTransportLatencyUs(uint8_t direction);



  /* Mask and table of currently supported contexts */

  types::LeAudioContextType active_context_type_;

  /* Current configuration and metadata context types */

  types::LeAudioContextType configuration_context_type_;

  types::AudioContexts metadata_context_type_;

  types::AudioContexts active_contexts_mask_;



  std::optional<types::AudioContexts> pending_update_available_contexts_;

  /* Mask of contexts that the whole group can handle at it's current state

   * It's being updated each time group members connect, disconnect or their

   * individual available audio contexts are changed.

   */

  types::AudioContexts group_available_contexts_;



  /* A temporary mask for bits which were either added or removed when the

   * group available context type changes. It usually means we should refresh

   * our group configuration capabilities to clear this.

   */

  types::AudioContexts pending_group_available_contexts_change_;



  /* Possible configuration cache - refreshed on each group context availability

   * change

   */

  std::map<types::LeAudioContextType,

           const set_configurations::AudioSetConfiguration*>

      active_context_to_configuration_map;

      available_context_to_configuration_map;



  types::AseState target_state_;

  types::AseState current_state_;

system/bta/le_audio/devices_test.cc

+8 −7
Original line number Diff line number Diff line
@@ -515,8 +515,8 @@ class LeAudioAseConfigurationTest : public Test { 
      data[i].device->src_pacs_ = src_pac_builder.Get();

    }



    /* Stimulate update of active context map */

    group_->UpdateActiveContextsMap(AudioContexts(context_type));

    /* Stimulate update of available context map */

    group_->UpdateAudioContextTypeAvailability(AudioContexts(context_type));

    ASSERT_EQ(success_expected,

              group_->Configure(context_type, AudioContexts(context_type)));
@@ -586,8 +586,8 @@ class LeAudioAseConfigurationTest : public Test { 
          interesting_configuration = false;

        }

      }

      /* Stimulate update of active context map */

      group_->UpdateActiveContextsMap(AudioContexts(context_type));

      /* Stimulate update of available context map */

      group_->UpdateAudioContextTypeAvailability(AudioContexts(context_type));

      auto configuration_result =

          group_->Configure(context_type, AudioContexts(context_type));
@@ -699,8 +699,9 @@ class LeAudioAseConfigurationTest : public Test { 
              success_expected = false;

            }



            /* Stimulate update of active context map */

            group_->UpdateActiveContextsMap(AudioContexts(context_type));

            /* Stimulate update of available context map */

            group_->UpdateAudioContextTypeAvailability(

                AudioContexts(context_type));

            ASSERT_EQ(

                success_expected,

                group_->Configure(context_type, AudioContexts(context_type)));
@@ -976,7 +977,7 @@ TEST_F(LeAudioAseConfigurationTest, test_reconnection_media) { 
  std::vector<uint8_t> ccid_list;

  for (auto& ent : configuration->confs) {

    if (ent.direction == ::le_audio::types::kLeAudioDirectionSink) {

      left->ConfigureAses(ent, group_->GetCurrentContextType(),

      left->ConfigureAses(ent, group_->GetConfigurationContextType(),

                          &number_of_active_ases, group_snk_audio_location,

                          group_src_audio_location, false,

                          ::le_audio::types::AudioContexts(), ccid_list);

system/bta/le_audio/le_audio_client_test.cc

+2 −2
Original line number Diff line number Diff line
@@ -706,8 +706,8 @@ class UnicastTestNoInit : public Test { 
            return false;

          }



          group->Configure(group->GetCurrentContextType(),

                           group->GetMetadataContextType(), {});

          group->Configure(group->GetConfigurationContextType(),

                           group->GetMetadataContexts(), {});

          if (!group->CigAssignCisIds(leAudioDevice)) return false;

          group->CigAssignCisConnHandlesToAses(leAudioDevice);