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

Commit e19aa553 authored by Jakub Pawłowski's avatar Jakub Pawłowski Committed by Gerrit Code Review
Browse files

Merge changes Ic16de95a,Ic6759c06,Id262eb84,Id311bae1 into main

* changes:
  LeAudio: Minor unit test improvements
  LeAudio: Minor refactor using BidirectionalPair
  LeAudio: Fix various methods const correctness
  LeAudio: Fix not clearing the audio session metadata
parents be521e4b d68705ce
Loading
Loading
Loading
Loading
+51 −50
Original line number Diff line number Diff line
@@ -1181,7 +1181,7 @@ class LeAudioClientImpl : public LeAudioClient {
      if (alarm_is_scheduled(suspend_timeout_)) alarm_cancel(suspend_timeout_);

      StopAudio();
      ClientAudioIntefraceRelease();
      ClientAudioInterfaceRelease();

      GroupStop(group_id_to_close);
      callbacks_->OnGroupStatus(group_id_to_close, GroupStatus::INACTIVE);
@@ -1437,14 +1437,15 @@ class LeAudioClientImpl : public LeAudioClient {
          le_audio::types::kLeAudioDirectionSource;
    }

    leAudioDevice->SetSupportedContexts(
        AudioContexts(sink_supported_context_types),
        AudioContexts(source_supported_context_types));
    BidirectionalPair<AudioContexts> supported_contexts = {
        .sink = AudioContexts(sink_supported_context_types),
        .source = AudioContexts(source_supported_context_types),
    };

    leAudioDevice->SetSupportedContexts(supported_contexts);

    /* Use same as or supported ones for now. */
    leAudioDevice->SetAvailableContexts(
        AudioContexts(sink_supported_context_types),
        AudioContexts(source_supported_context_types));
    /* Use same as supported ones for now. */
    leAudioDevice->SetAvailableContexts(supported_contexts);

    if (!DeserializeHandles(leAudioDevice, handles)) {
      LOG_WARN("Could not load Handles");
@@ -1810,15 +1811,11 @@ class LeAudioClientImpl : public LeAudioClient {
       */
      UpdateLocationsAndContextsAvailability(leAudioDevice->group_id_);
    } else if (hdl == leAudioDevice->audio_avail_hdls_.val_hdl) {
      le_audio::client_parser::pacs::acs_available_audio_contexts
          avail_audio_contexts;
      le_audio::client_parser::pacs::ParseAvailableAudioContexts(
          avail_audio_contexts, len, value);

      auto updated_context_bits = leAudioDevice->SetAvailableContexts(
          avail_audio_contexts.snk_avail_cont,
          avail_audio_contexts.src_avail_cont);

      BidirectionalPair<AudioContexts> contexts;
      if (le_audio::client_parser::pacs::ParseAvailableAudioContexts(
              contexts, len, value)) {
        auto updated_context_bits =
            leAudioDevice->SetAvailableContexts(contexts);
        if (updated_context_bits.any()) {
          /* Update scenario map considering changed available context types */
          LeAudioDeviceGroup* group =
@@ -1838,23 +1835,23 @@ class LeAudioClientImpl : public LeAudioClient {
              return;
            }

          /* Available contexts change requires audio set config invalidation */
            /* Available contexts change requires audio set config invalidation
             */
            UpdateContexts(group, updated_context_bits);
          }
        }
      }
    } else if (hdl == leAudioDevice->audio_supp_cont_hdls_.val_hdl) {
      le_audio::client_parser::pacs::acs_supported_audio_contexts
          supp_audio_contexts;
      le_audio::client_parser::pacs::ParseSupportedAudioContexts(
          supp_audio_contexts, len, value);
      BidirectionalPair<AudioContexts> supp_audio_contexts;
      if (le_audio::client_parser::pacs::ParseSupportedAudioContexts(
              supp_audio_contexts, len, value)) {
        /* Just store if for now */
      leAudioDevice->SetSupportedContexts(supp_audio_contexts.snk_supp_cont,
                                          supp_audio_contexts.src_supp_cont);
        leAudioDevice->SetSupportedContexts(supp_audio_contexts);

        btif_storage_set_leaudio_supported_context_types(
          leAudioDevice->address_, supp_audio_contexts.snk_supp_cont.value(),
          supp_audio_contexts.src_supp_cont.value());

            leAudioDevice->address_, supp_audio_contexts.sink.value(),
            supp_audio_contexts.source.value());
      }
    } else if (hdl == leAudioDevice->ctp_hdls_.val_hdl) {
      auto ntf =
          std::make_unique<struct le_audio::client_parser::ascs::ctp_ntf>();
@@ -3708,7 +3705,7 @@ class LeAudioClientImpl : public LeAudioClient {
    if (active_group_id_ != bluetooth::groups::kGroupUnknown) {
      /* Bluetooth turned off while streaming */
      StopAudio();
      ClientAudioIntefraceRelease();
      ClientAudioInterfaceRelease();
    }
    groupStateMachine_->Cleanup();
    aseGroups_.Cleanup();
@@ -5453,16 +5450,20 @@ class LeAudioClientImpl : public LeAudioClient {

  base::WeakPtrFactory<LeAudioClientImpl> weak_factory_{this};

  void ClientAudioIntefraceRelease() {
  void ClientAudioInterfaceRelease() {
    if (le_audio_source_hal_client_) {
      le_audio_source_hal_client_->Stop();
      le_audio_source_hal_client_.reset();
    }
    metadata_context_types_.sink.clear();

    if (le_audio_sink_hal_client_) {
      le_audio_sink_hal_client_->Stop();
      le_audio_sink_hal_client_.reset();
    }
    metadata_context_types_.source.clear();
    configuration_context_type_ = LeAudioContextType::UNINITIALIZED;

    le_audio::MetricsCollector::Get()->OnStreamEnded(active_group_id_);
  }
};
+14 −16
Original line number Diff line number Diff line
@@ -661,40 +661,38 @@ bool ParseAudioLocations(types::AudioLocations& audio_locations, uint16_t len,
  return true;
}

bool ParseSupportedAudioContexts(struct acs_supported_audio_contexts& contexts,
                                 uint16_t len, const uint8_t* value) {
bool ParseSupportedAudioContexts(
    types::BidirectionalPair<types::AudioContexts>& contexts, uint16_t len,
    const uint8_t* value) {
  if (len != kAseAudioSuppContRspMinLen) {
    LOG(ERROR) << "Wrong len of Audio Supported Context characteristic";
    return false;
  }

  STREAM_TO_UINT16(contexts.snk_supp_cont.value_ref(), value);
  STREAM_TO_UINT16(contexts.src_supp_cont.value_ref(), value);
  STREAM_TO_UINT16(contexts.sink.value_ref(), value);
  STREAM_TO_UINT16(contexts.source.value_ref(), value);

  LOG(INFO) << "Supported Audio Contexts: "
            << "\n\tSupported Sink Contexts: "
            << contexts.snk_supp_cont.to_string()
            << "\n\tSupported Source Contexts: "
            << contexts.src_supp_cont.to_string();
            << "\n\tSupported Sink Contexts: " << contexts.sink.to_string()
            << "\n\tSupported Source Contexts: " << contexts.source.to_string();

  return true;
}

bool ParseAvailableAudioContexts(struct acs_available_audio_contexts& contexts,
                                 uint16_t len, const uint8_t* value) {
bool ParseAvailableAudioContexts(
    types::BidirectionalPair<types::AudioContexts>& contexts, uint16_t len,
    const uint8_t* value) {
  if (len != kAseAudioAvailRspMinLen) {
    LOG(ERROR) << "Wrong len of Audio Availability characteristic";
    return false;
  }

  STREAM_TO_UINT16(contexts.snk_avail_cont.value_ref(), value);
  STREAM_TO_UINT16(contexts.src_avail_cont.value_ref(), value);
  STREAM_TO_UINT16(contexts.sink.value_ref(), value);
  STREAM_TO_UINT16(contexts.source.value_ref(), value);

  LOG(INFO) << "Available Audio Contexts: "
            << "\n\tAvailable Sink Contexts: "
            << contexts.snk_avail_cont.to_string()
            << "\n\tAvailable Source Contexts: "
            << contexts.src_avail_cont.to_string();
            << "\n\tAvailable Sink Contexts: " << contexts.sink.to_string()
            << "\n\tAvailable Source Contexts: " << contexts.source.to_string();

  return true;
}
+6 −12
Original line number Diff line number Diff line
@@ -230,16 +230,8 @@ constexpr uint16_t kAcsPacDiscoverRspMinLen = 1;
constexpr uint16_t kAudioLocationsRspMinLen = 4;

constexpr uint16_t kAseAudioAvailRspMinLen = 4;
struct acs_available_audio_contexts {
  types::AudioContexts snk_avail_cont;
  types::AudioContexts src_avail_cont;
};

constexpr uint16_t kAseAudioSuppContRspMinLen = 4;
struct acs_supported_audio_contexts {
  types::AudioContexts snk_supp_cont;
  types::AudioContexts src_supp_cont;
};

int ParseSinglePac(std::vector<struct types::acs_ac_record>& pac_recs,
                   uint16_t len, const uint8_t* value);
@@ -247,10 +239,12 @@ bool ParsePacs(std::vector<struct types::acs_ac_record>& pac_recs, uint16_t len,
               const uint8_t* value);
bool ParseAudioLocations(types::AudioLocations& audio_locations, uint16_t len,
                         const uint8_t* value);
bool ParseAvailableAudioContexts(struct acs_available_audio_contexts& rsp,
                                 uint16_t len, const uint8_t* value);
bool ParseSupportedAudioContexts(struct acs_supported_audio_contexts& rsp,
                                 uint16_t len, const uint8_t* value);
bool ParseAvailableAudioContexts(
    types::BidirectionalPair<types::AudioContexts>& rsp, uint16_t len,
    const uint8_t* value);
bool ParseSupportedAudioContexts(
    types::BidirectionalPair<types::AudioContexts>& rsp, uint16_t len,
    const uint8_t* value);
}  // namespace pacs

namespace tmap {
+12 −12
Original line number Diff line number Diff line
@@ -522,7 +522,7 @@ TEST(LeAudioClientParserTest, testParseAudioLocations) {
}

TEST(LeAudioClientParserTest, testParseAvailableAudioContextsInvalidLength) {
  acs_available_audio_contexts avail_contexts;
  types::BidirectionalPair<types::AudioContexts> avail_contexts;
  const uint8_t value1[] = {
      // Sink available contexts
      0x01, 0x02,
@@ -530,12 +530,12 @@ TEST(LeAudioClientParserTest, testParseAvailableAudioContextsInvalidLength) {
  };

  ParseAvailableAudioContexts(avail_contexts, sizeof(value1), value1);
  ASSERT_EQ(avail_contexts.snk_avail_cont.value(), 0u);
  ASSERT_EQ(avail_contexts.src_avail_cont.value(), 0u);
  ASSERT_EQ(avail_contexts.sink.value(), 0u);
  ASSERT_EQ(avail_contexts.source.value(), 0u);
}

TEST(LeAudioClientParserTest, testParseAvailableAudioContexts) {
  acs_available_audio_contexts avail_contexts;
  types::BidirectionalPair<types::AudioContexts> avail_contexts;
  const uint8_t value1[] = {
      // Sink available contexts
      0x01,
@@ -546,12 +546,12 @@ TEST(LeAudioClientParserTest, testParseAvailableAudioContexts) {
  };

  ParseAvailableAudioContexts(avail_contexts, sizeof(value1), value1);
  ASSERT_EQ(avail_contexts.snk_avail_cont.value(), 0x0201u);
  ASSERT_EQ(avail_contexts.src_avail_cont.value(), 0x0403u);
  ASSERT_EQ(avail_contexts.sink.value(), 0x0201u);
  ASSERT_EQ(avail_contexts.source.value(), 0x0403u);
}

TEST(LeAudioClientParserTest, testParseSupportedAudioContextsInvalidLength) {
  acs_supported_audio_contexts supp_contexts;
  types::BidirectionalPair<types::AudioContexts> supp_contexts;
  const uint8_t value1[] = {
      // Sink supported contexts
      0x01, 0x02,
@@ -559,12 +559,12 @@ TEST(LeAudioClientParserTest, testParseSupportedAudioContextsInvalidLength) {
  };

  ParseSupportedAudioContexts(supp_contexts, sizeof(value1), value1);
  ASSERT_EQ(supp_contexts.snk_supp_cont.value(), 0u);
  ASSERT_EQ(supp_contexts.src_supp_cont.value(), 0u);
  ASSERT_EQ(supp_contexts.sink.value(), 0u);
  ASSERT_EQ(supp_contexts.source.value(), 0u);
}

TEST(LeAudioClientParserTest, testParseSupportedAudioContexts) {
  acs_supported_audio_contexts supp_contexts;
  types::BidirectionalPair<types::AudioContexts> supp_contexts;
  const uint8_t value1[] = {
      // Sink supported contexts
      0x01,
@@ -575,8 +575,8 @@ TEST(LeAudioClientParserTest, testParseSupportedAudioContexts) {
  };

  ParseSupportedAudioContexts(supp_contexts, sizeof(value1), value1);
  ASSERT_EQ(supp_contexts.snk_supp_cont.value(), 0x0201u);
  ASSERT_EQ(supp_contexts.src_supp_cont.value(), 0x0403u);
  ASSERT_EQ(supp_contexts.sink.value(), 0x0201u);
  ASSERT_EQ(supp_contexts.source.value(), 0x0403u);
}

}  // namespace pacs
+121 −94

File changed.

Preview size limit exceeded, changes collapsed.

Loading