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

Commit c24ac8b3 authored by Jakub Pawłowski's avatar Jakub Pawłowski Committed by Automerger Merge Worker
Browse files

Merge "LeAudio: Add missing direction contexts for metadata passing" am: 064c98b7 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/2430732



Change-Id: I8136b17d33da429e1306a4012909fbeaf1b491b2
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 24458366 064c98b7

system/bta/le_audio/client.cc

+130 −135
Original line number Diff line number Diff line
@@ -314,8 +314,7 @@ class LeAudioClientImpl : public LeAudioClient { 


    LOG_DEBUG("new_configuration_context= %s",

              ToString(new_configuration_context).c_str());

    ReconfigureOrUpdateMetadata(group, new_configuration_context,

                                metadata_context_types_.sink);

    ReconfigureOrUpdateMetadata(group, new_configuration_context);

  }



  void StartVbcCloseTimeout() {
@@ -792,13 +791,12 @@ class LeAudioClientImpl : public LeAudioClient { 
    return AudioContexts(LeAudioContextType::UNSPECIFIED);

  }



  bool GroupStream(const int group_id, LeAudioContextType context_type,

                   AudioContexts metadata_context_type) {

  bool GroupStream(

      const int group_id, LeAudioContextType context_type,

      const BidirectionalPair<AudioContexts>& metadata_context_types) {

    LeAudioDeviceGroup* group = aseGroups_.FindById(group_id);

    auto final_context_type = context_type;



    auto adjusted_metadata_context_type =

        ChooseMetadataContextType(metadata_context_type);

    DLOG(INFO) << __func__;

    if (context_type >= LeAudioContextType::RFU) {

      LOG(ERROR) << __func__ << ", stream context type is not supported: "
@@ -851,17 +849,21 @@ class LeAudioClientImpl : public LeAudioClient { 
          bluetooth::common::time_get_os_boottime_us();

    }



    BidirectionalPair<std::vector<uint8_t>> ccids = {

        .sink = ContentControlIdKeeper::GetInstance()->GetAllCcids(

            metadata_context_types.sink),

        .source = ContentControlIdKeeper::GetInstance()->GetAllCcids(

            metadata_context_types.source)};

    bool result = groupStateMachine_->StartStream(

        group, final_context_type, adjusted_metadata_context_type,

        ContentControlIdKeeper::GetInstance()->GetAllCcids(

            adjusted_metadata_context_type));

        group, final_context_type, metadata_context_types, ccids);



    return result;

  }



  void GroupStream(const int group_id, const uint16_t context_type) override {

    GroupStream(group_id, LeAudioContextType(context_type),

                AudioContexts(context_type));

    BidirectionalPair<AudioContexts> initial_contexts = {

        AudioContexts(context_type), AudioContexts(context_type)};

    GroupStream(group_id, LeAudioContextType(context_type), initial_contexts);

  }



  void GroupSuspend(const int group_id) override {
@@ -3239,7 +3241,7 @@ class LeAudioClientImpl : public LeAudioClient { 
      return true;

    }

    return GroupStream(active_group_id_, configuration_context_type_,

                       get_bidirectional(metadata_context_types_));

                       metadata_context_types_);

  }



  void OnAudioSuspend() {
@@ -3707,40 +3709,14 @@ class LeAudioClientImpl : public LeAudioClient { 
              ToString(group->GetState()).c_str(),

              ToString(group->GetTargetState()).c_str());



    auto new_metadata_context_types_ = AudioContexts();



    /* If the local sink is started, ready to start or any direction is

     * reconfiguring to start sit remote source configuration, then take

     * into the account current context type. If the metadata seem

     * invalid, keep the old one, but verify against the availability.

     * Otherwise start empty and add the tracks contexts.

     */

    auto is_releasing_for_reconfiguration =

        (((audio_receiver_state_ == AudioState::RELEASING) ||

          (audio_sender_state_ == AudioState::RELEASING)) &&

         group->IsPendingConfiguration() &&

         IsDirectionAvailableForCurrentConfiguration(

             group, le_audio::types::kLeAudioDirectionSource));

    if (is_releasing_for_reconfiguration ||

        (audio_receiver_state_ == AudioState::STARTED) ||

        (audio_receiver_state_ == AudioState::READY_TO_START)) {

      LOG_DEBUG("Other direction is streaming. Taking its contexts %s",

                ToString(metadata_context_types_.source).c_str());

      new_metadata_context_types_ =

          ChooseMetadataContextType(metadata_context_types_.source);



    } else if (source_metadata.empty()) {

      LOG_DEBUG("Not a valid sink metadata update. Keeping the old contexts");

      new_metadata_context_types_ &= group->GetAvailableContexts();



    } else {

      LOG_DEBUG("No other direction is streaming. Start with empty contexts.");

    }

    // Make sure the other direction is tested against the available contexts

    metadata_context_types_.source &= group->GetAvailableContexts();



    /* Set the remote sink metadata context from the playback tracks metadata */

    metadata_context_types_.sink = GetAllowedAudioContextsFromSourceMetadata(

        source_metadata, group->GetAvailableContexts());

    new_metadata_context_types_ |= metadata_context_types_.sink;

    metadata_context_types_.sink =

        ChooseMetadataContextType(metadata_context_types_.sink);



    if (stack_config_get_interface()

            ->get_pts_force_le_audio_multiple_contexts_metadata()) {
@@ -3764,19 +3740,47 @@ class LeAudioClientImpl : public LeAudioClient { 
      LOG_DEBUG("new_configuration_context= %s.",

                ToString(new_configuration_context).c_str());

      GroupStream(active_group_id_, new_configuration_context,

                  metadata_context_types_.sink);

                  metadata_context_types_);

      return;

    }



    if (new_metadata_context_types_.none()) {

      LOG_WARN("invalid/unknown context metadata, using 'UNSPECIFIED' instead");

      new_metadata_context_types_ =

    // We expect at least some context when remote sink gets enabled

    if (metadata_context_types_.sink.none()) {

      LOG_WARN(

          "invalid/unknown sink context metadata, using 'UNSPECIFIED' instead");

      metadata_context_types_.sink =

          AudioContexts(LeAudioContextType::UNSPECIFIED);

    }



    /* Choose the right configuration context */

    /* Start with only this direction context metadata */

    auto configuration_context_candidates = metadata_context_types_.sink;



    /* If the local sink is started, ready to start or any direction is

     * reconfiguring when the remote sink configuration is active, then take

     * into the account current context type for this direction when

     * configuration context is selected.

     */

    auto is_releasing_for_reconfiguration =

        (((audio_receiver_state_ == AudioState::RELEASING) ||

          (audio_sender_state_ == AudioState::RELEASING)) &&

         group->IsPendingConfiguration() &&

         IsDirectionAvailableForCurrentConfiguration(

             group, le_audio::types::kLeAudioDirectionSource));

    if (is_releasing_for_reconfiguration ||

        (audio_receiver_state_ == AudioState::STARTED) ||

        (audio_receiver_state_ == AudioState::READY_TO_START)) {

      LOG_DEBUG("Other direction is streaming. Taking its contexts %s",

                ToString(metadata_context_types_.source).c_str());

      configuration_context_candidates =

          ChooseMetadataContextType(get_bidirectional(metadata_context_types_));

    }

    LOG_DEBUG("configuration_context_candidates= %s",

              ToString(configuration_context_candidates).c_str());



    auto new_configuration_context =

        ChooseConfigurationContextType(new_metadata_context_types_);

        ChooseConfigurationContextType(configuration_context_candidates);

    LOG_DEBUG("new_configuration_context= %s",

              ToString(new_configuration_context).c_str());



    /* For the following contexts we don't actually need HQ audio:

     * LeAudioContextType::NOTIFICATIONS
@@ -3791,19 +3795,21 @@ class LeAudioClientImpl : public LeAudioClient { 
        LeAudioContextType::NOTIFICATIONS | LeAudioContextType::SOUNDEFFECTS |

        LeAudioContextType::INSTRUCTIONAL | LeAudioContextType::ALERTS |

        LeAudioContextType::EMERGENCYALARM;

    if ((new_metadata_context_types_ & ~no_reconfigure_contexts).none() &&

    if ((configuration_context_candidates & ~no_reconfigure_contexts).none() &&

        IsDirectionAvailableForCurrentConfiguration(

            group, le_audio::types::kLeAudioDirectionSink)) {

      LOG_INFO(

          "There is no need to reconfigure for the sonification events. Keep "

          "the configuration unchanged.");

          "There is no need to reconfigure for the sonification events, "

          "staying with the existing configuration context of %s",

          ToString(configuration_context_type_).c_str());

      new_configuration_context = configuration_context_type_;

    }



    LOG_DEBUG("new_configuration_context= %s",

              ToString(new_configuration_context).c_str());

    ReconfigureOrUpdateMetadata(group, new_configuration_context,

                                std::move(new_metadata_context_types_));

    LOG_DEBUG("metadata_context_types_.sink= %s",

              ToString(metadata_context_types_.sink).c_str());

    LOG_DEBUG("metadata_context_types_.source= %s",

              ToString(metadata_context_types_.source).c_str());

    ReconfigureOrUpdateMetadata(group, new_configuration_context);

  }



  void OnLocalAudioSinkMetadataUpdate(
@@ -3824,39 +3830,14 @@ class LeAudioClientImpl : public LeAudioClient { 
              ToString(group->GetState()).c_str(),

              ToString(group->GetTargetState()).c_str());



    auto new_metadata_context_types = AudioContexts();



    /* If the local source is started, ready to start or any direction is

     * reconfiguring to start sit remote sink configuration, then take

     * into the account current context type. If the metadata seem

     * invalid, keep the old one, but verify against the availability.

     * Otherwise start empty and add the tracks contexts.

     */

    auto is_releasing_for_reconfiguration =

        (((audio_receiver_state_ == AudioState::RELEASING) ||

          (audio_sender_state_ == AudioState::RELEASING)) &&

         group->IsPendingConfiguration() &&

         IsDirectionAvailableForCurrentConfiguration(

             group, le_audio::types::kLeAudioDirectionSink));

    if (is_releasing_for_reconfiguration ||

        (audio_sender_state_ == AudioState::STARTED) ||

        (audio_sender_state_ == AudioState::READY_TO_START)) {

      LOG_DEBUG("Other direction is streaming. Taking its contexts %s",

                ToString(metadata_context_types_.sink).c_str());

      new_metadata_context_types =

          ChooseMetadataContextType(metadata_context_types_.sink);



    } else if (sink_metadata.empty()) {

      LOG_DEBUG("Not a valid sink metadata update. Keeping the old contexts");

      new_metadata_context_types &= group->GetAvailableContexts();



    } else {

      LOG_DEBUG("No other direction is streaming. Start with empty contexts.");

    }

    // Make sure the other direction is tested against the available contexts

    metadata_context_types_.sink &= group->GetAvailableContexts();



    /* Set remote source metadata context from the recording tracks metadata */

    metadata_context_types_.source = GetAllowedAudioContextsFromSinkMetadata(

        sink_metadata, group->GetAvailableContexts());

    metadata_context_types_.source =

        ChooseMetadataContextType(metadata_context_types_.source);



    /* Make sure we have CONVERSATIONAL when in a call */

    if (in_call_) {
@@ -3865,44 +3846,67 @@ class LeAudioClientImpl : public LeAudioClient { 
          AudioContexts(LeAudioContextType::CONVERSATIONAL);

    }



    /* Append the remote source context types */

    new_metadata_context_types |= metadata_context_types_.source;



    if (stack_config_get_interface()

            ->get_pts_force_le_audio_multiple_contexts_metadata()) {

      // Use common audio stream contexts exposed by the PTS

      new_metadata_context_types = AudioContexts(0xFFFF);

      metadata_context_types_.source = AudioContexts(0xFFFF);

      for (auto device = group->GetFirstDevice(); device != nullptr;

           device = group->GetNextDevice(device)) {

        new_metadata_context_types &= device->GetAvailableContexts();

        metadata_context_types_.source &= device->GetAvailableContexts();

      }

      if (new_metadata_context_types.value() == 0xFFFF) {

        new_metadata_context_types =

      if (metadata_context_types_.source.value() == 0xFFFF) {

        metadata_context_types_.source =

            AudioContexts(LeAudioContextType::UNSPECIFIED);

      }

      LOG_WARN("Overriding new_metadata_context_types with: %su",

               new_metadata_context_types.to_string().c_str());

      LOG_WARN("Overriding metadata_context_types_.source with: %su",

               metadata_context_types_.source.to_string().c_str());



      /* Choose the right configuration context */

      const auto new_configuration_context =

          ChooseConfigurationContextType(new_metadata_context_types);

          ChooseConfigurationContextType(metadata_context_types_.source);



      LOG_DEBUG("new_configuration_context= %s.",

                ToString(new_configuration_context).c_str());

      new_metadata_context_types.set(new_configuration_context);

      metadata_context_types_.source.set(new_configuration_context);

    }



    if (new_metadata_context_types.none()) {

      LOG_WARN("invalid/unknown context metadata, using 'UNSPECIFIED' instead");

      new_metadata_context_types =

    // We expect at least some context when remote source gets enabled

    if (metadata_context_types_.source.none()) {

      LOG_WARN(

          "invalid/unknown source context metadata, using 'UNSPECIFIED' "

          "instead");

      metadata_context_types_.source =

          AudioContexts(LeAudioContextType::UNSPECIFIED);

    }



    /* Start with only this direction context metadata */

    auto configuration_context_candidates = metadata_context_types_.source;



    /* If the local source is started, ready to start or any direction is

     * reconfiguring when the remote sink configuration is active, then take

     * into the account current context type for this direction when

     * configuration context is selected.

     */

    auto is_releasing_for_reconfiguration =

        (((audio_receiver_state_ == AudioState::RELEASING) ||

          (audio_sender_state_ == AudioState::RELEASING)) &&

         group->IsPendingConfiguration() &&

         IsDirectionAvailableForCurrentConfiguration(

             group, le_audio::types::kLeAudioDirectionSink));

    if (is_releasing_for_reconfiguration ||

        (audio_sender_state_ == AudioState::STARTED) ||

        (audio_sender_state_ == AudioState::READY_TO_START)) {

      configuration_context_candidates =

          ChooseMetadataContextType(get_bidirectional(metadata_context_types_));

      LOG_DEBUG("Other direction is streaming. Taking its contexts %s",

                ToString(metadata_context_types_.sink).c_str());

    }

    LOG_DEBUG("configuration_context_candidates= %s",

              ToString(configuration_context_candidates).c_str());



    /* Choose the right configuration context */

    const auto new_configuration_context =

        ChooseConfigurationContextType(new_metadata_context_types);

    LOG_DEBUG("new_configuration_context= %s",

              ToString(new_configuration_context).c_str());

    auto new_configuration_context =

        ChooseConfigurationContextType(configuration_context_candidates);



    /* Do nothing if audio source is not valid for the new configuration */

    const auto is_audio_source_context =
@@ -3931,27 +3935,22 @@ class LeAudioClientImpl : public LeAudioClient { 
          "context in %s. Not switching to %s right now.",

          ToString(configuration_context_type_).c_str(),

          ToString(new_configuration_context).c_str());

      return;

      new_configuration_context = configuration_context_type_;

    }



    ReconfigureOrUpdateMetadata(group, new_configuration_context,

                                std::move(new_metadata_context_types));

    LOG_DEBUG("metadata_context_types_.sink= %s",

              ToString(metadata_context_types_.sink).c_str());

    LOG_DEBUG("metadata_context_types_.source= %s",

              ToString(metadata_context_types_.source).c_str());

    ReconfigureOrUpdateMetadata(group, new_configuration_context);

  }



  void ReconfigureOrUpdateMetadata(LeAudioDeviceGroup* group,

                                   LeAudioContextType new_configuration_context,

                                   AudioContexts new_metadata_context_types) {

  void ReconfigureOrUpdateMetadata(

      LeAudioDeviceGroup* group, LeAudioContextType new_configuration_context) {

    if (new_configuration_context != configuration_context_type_) {

      LOG_DEBUG(

          "Changing configuration context from %s to %s, new "

          "metadata_contexts: %s",

      LOG_DEBUG("Changing configuration context from %s to %s",

                ToString(configuration_context_type_).c_str(),

          ToString(new_configuration_context).c_str(),

          ToString(new_metadata_context_types).c_str());

      // TODO: This should also cache the combined metadata context for the

      //       reconfiguration, so that once the group reaches IDLE state and

      //       is about to reconfigure, we would know if we reconfigure with

      //       sink or source or both metadata.

                ToString(new_configuration_context).c_str());

      if (SetConfigurationAndStopStreamWhenNeeded(group,

                                                  new_configuration_context)) {

        return;
@@ -3960,13 +3959,13 @@ class LeAudioClientImpl : public LeAudioClient { 


    if (group->GetTargetState() == AseState::BTA_LE_AUDIO_ASE_STATE_STREAMING) {

      LOG_DEBUG(

          "The %s configuration did not change. Changing only the metadata "

          "contexts from %s to %s",

          "The %s configuration did not change. Updating the metadata to "

          "sink=%s, source=%s",

          ToString(configuration_context_type_).c_str(),

          ToString(get_bidirectional(metadata_context_types_)).c_str(),

          ToString(new_metadata_context_types).c_str());

      GroupStream(group->group_id_, new_configuration_context,

                  new_metadata_context_types);

          ToString(metadata_context_types_.sink).c_str(),

          ToString(metadata_context_types_.source).c_str());

      GroupStream(group->group_id_, configuration_context_type_,

                  metadata_context_types_);

    }

  }
@@ -4336,18 +4335,14 @@ class LeAudioClientImpl : public LeAudioClient { 
      case GroupStreamStatus::IDLE: {

        if (group && group->IsPendingConfiguration()) {

          SuspendedForReconfiguration();

          // TODO: It is not certain to which directions we will

          //       reconfigure. We would have know the exact

          //       configuration but this is yet to be selected or have

          //       the metadata cached from earlier when reconfiguration

          //       was scheduled.

          auto adjusted_metedata_context_type = ChooseMetadataContextType(

              get_bidirectional(metadata_context_types_));

          BidirectionalPair<std::vector<uint8_t>> ccids = {

              .sink = ContentControlIdKeeper::GetInstance()->GetAllCcids(

                  metadata_context_types_.sink),

              .source = ContentControlIdKeeper::GetInstance()->GetAllCcids(

                  metadata_context_types_.source)};

          if (groupStateMachine_->ConfigureStream(

                  group, configuration_context_type_,

                  adjusted_metedata_context_type,

                  ContentControlIdKeeper::GetInstance()->GetAllCcids(

                      adjusted_metedata_context_type))) {

                  group, configuration_context_type_, metadata_context_types_,

                  ccids)) {

            /* If configuration succeed wait for new status. */

            return;

          }