Merge "SpatialAudio: Set low latency allowed signal at startSession The logic is that to send FREE and LOW_LATENCY to audio at startSession, if bt receives setLowLatencyModeAllowed(true) before start session. If the parameter false, or bt doesn't receive the signal at all, then bt sends FREE to audio."

2026-02-02 05:56:34 +00:00 · 2022-02-16 19:38:24 +00:00
parent 0f7d419136 c92270e1d6
commit 5cde687f02
15 changed files with 88 additions and 42 deletions
--- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
@@ -35,7 +35,7 @@ package android.hardware.bluetooth.audio;
@VintfStability
 interface IBluetoothAudioProvider {
  void endSession();
-  android.hardware.common.fmq.MQDescriptor<byte,android.hardware.common.fmq.SynchronizedReadWrite> startSession(in android.hardware.bluetooth.audio.IBluetoothAudioPort hostIf, in android.hardware.bluetooth.audio.AudioConfiguration audioConfig);
+  android.hardware.common.fmq.MQDescriptor<byte,android.hardware.common.fmq.SynchronizedReadWrite> startSession(in android.hardware.bluetooth.audio.IBluetoothAudioPort hostIf, in android.hardware.bluetooth.audio.AudioConfiguration audioConfig, in android.hardware.bluetooth.audio.LatencyMode[] supportedLatencyModes);
  void streamStarted(in android.hardware.bluetooth.audio.BluetoothAudioStatus status);
  void streamSuspended(in android.hardware.bluetooth.audio.BluetoothAudioStatus status);
  void updateAudioConfiguration(in android.hardware.bluetooth.audio.AudioConfiguration audioConfig);
--- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
@@ -19,6 +19,7 @@ package android.hardware.bluetooth.audio;
 import android.hardware.bluetooth.audio.AudioConfiguration;
 import android.hardware.bluetooth.audio.BluetoothAudioStatus;
 import android.hardware.bluetooth.audio.IBluetoothAudioPort;
+import android.hardware.bluetooth.audio.LatencyMode;
 import android.hardware.common.fmq.MQDescriptor;
 import android.hardware.common.fmq.SynchronizedReadWrite;

@@ -50,6 +51,8 @@ interface IBluetoothAudioProvider {
     *    device. The PCM parameters are set if software based encoding,
     *    otherwise the correct codec configuration is used for hardware
     *    encoding.
+     * @param supportedLatencyModes latency modes supported by the active
+     * remote device
     *
     * @return The fast message queue for audio data from/to this
     *    provider. Audio data will be in PCM format as specified by the
@@ -57,8 +60,8 @@ interface IBluetoothAudioProvider {
     *    from/to hardware or on failure
     */
    MQDescriptor<byte, SynchronizedReadWrite> startSession(
-            in IBluetoothAudioPort hostIf, in AudioConfiguration audioConfig);
-
+            in IBluetoothAudioPort hostIf, in AudioConfiguration audioConfig,
+            in LatencyMode[] supportedLatencyModes);
    /**
     * Callback for IBluetoothAudioPort.startStream()
     *
--- a/bluetooth/audio/aidl/default/A2dpOffloadAudioProvider.cpp
+++ b/bluetooth/audio/aidl/default/A2dpOffloadAudioProvider.cpp
@@ -38,7 +38,10 @@ bool A2dpOffloadAudioProvider::isValid(const SessionType& session_type) {

 ndk::ScopedAStatus A2dpOffloadAudioProvider::startSession(
    const std::shared_ptr<IBluetoothAudioPort>& host_if,
-    const AudioConfiguration& audio_config, DataMQDesc* _aidl_return) {
+    const AudioConfiguration& audio_config,
+    const std::vector<LatencyMode>& latency_modes,
+    DataMQDesc* _aidl_return) {
+  latency_modes_ = latency_modes;
  if (audio_config.getTag() != AudioConfiguration::a2dpConfig) {
    LOG(WARNING) << __func__ << " - Invalid Audio Configuration="
                 << audio_config.toString();
@@ -52,8 +55,8 @@ ndk::ScopedAStatus A2dpOffloadAudioProvider::startSession(
    *_aidl_return = DataMQDesc();
    return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
  }
-  return BluetoothAudioProvider::startSession(host_if, audio_config,
-                                              _aidl_return);
+  return BluetoothAudioProvider::startSession(
+      host_if, audio_config, latency_modes, _aidl_return);
 }

 ndk::ScopedAStatus A2dpOffloadAudioProvider::onSessionReady(
--- a/bluetooth/audio/aidl/default/A2dpOffloadAudioProvider.h
+++ b/bluetooth/audio/aidl/default/A2dpOffloadAudioProvider.h
@@ -32,7 +32,9 @@ class A2dpOffloadAudioProvider : public BluetoothAudioProvider {

  ndk::ScopedAStatus startSession(
      const std::shared_ptr<IBluetoothAudioPort>& host_if,
-      const AudioConfiguration& audio_config, DataMQDesc* _aidl_return);
+      const AudioConfiguration& audio_config,
+      const std::vector<LatencyMode>& latency_modes,
+      DataMQDesc* _aidl_return);

 private:
  ndk::ScopedAStatus onSessionReady(DataMQDesc* _aidl_return) override;
--- a/bluetooth/audio/aidl/default/A2dpSoftwareAudioProvider.cpp
+++ b/bluetooth/audio/aidl/default/A2dpSoftwareAudioProvider.cpp
@@ -61,7 +61,10 @@ bool A2dpSoftwareAudioProvider::isValid(const SessionType& sessionType) {

 ndk::ScopedAStatus A2dpSoftwareAudioProvider::startSession(
    const std::shared_ptr<IBluetoothAudioPort>& host_if,
-    const AudioConfiguration& audio_config, DataMQDesc* _aidl_return) {
+    const AudioConfiguration& audio_config,
+    const std::vector<LatencyMode>& latency_modes,
+    DataMQDesc* _aidl_return) {
+  latency_modes_ = latency_modes;
  if (audio_config.getTag() != AudioConfiguration::pcmConfig) {
    LOG(WARNING) << __func__ << " - Invalid Audio Configuration="
                 << audio_config.toString();
@@ -77,8 +80,8 @@ ndk::ScopedAStatus A2dpSoftwareAudioProvider::startSession(
    return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
  }

-  return BluetoothAudioProvider::startSession(host_if, audio_config,
-                                              _aidl_return);
+  return BluetoothAudioProvider::startSession(
+      host_if, audio_config, latency_modes, _aidl_return);
 }

 ndk::ScopedAStatus A2dpSoftwareAudioProvider::onSessionReady(
--- a/bluetooth/audio/aidl/default/A2dpSoftwareAudioProvider.h
+++ b/bluetooth/audio/aidl/default/A2dpSoftwareAudioProvider.h
@@ -32,7 +32,9 @@ class A2dpSoftwareAudioProvider : public BluetoothAudioProvider {

  ndk::ScopedAStatus startSession(
      const std::shared_ptr<IBluetoothAudioPort>& host_if,
-      const AudioConfiguration& audio_config, DataMQDesc* _aidl_return);
+      const AudioConfiguration& audio_config,
+      const std::vector<LatencyMode>& latency_modes,
+      DataMQDesc* _aidl_return);

 private:
  // audio data queue for software encoding
--- a/bluetooth/audio/aidl/default/BluetoothAudioProvider.cpp
+++ b/bluetooth/audio/aidl/default/BluetoothAudioProvider.cpp
@@ -34,11 +34,15 @@ BluetoothAudioProvider::BluetoothAudioProvider() {

 ndk::ScopedAStatus BluetoothAudioProvider::startSession(
    const std::shared_ptr<IBluetoothAudioPort>& host_if,
-    const AudioConfiguration& audio_config, DataMQDesc* _aidl_return) {
+    const AudioConfiguration& audio_config,
+    const std::vector<LatencyMode>& latencyModes,
+    DataMQDesc* _aidl_return) {
  if (host_if == nullptr) {
    *_aidl_return = DataMQDesc();
    return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
  }
+
+  latency_modes_ = latencyModes;
  audio_config_ = std::make_unique<AudioConfiguration>(audio_config);
  stack_iface_ = host_if;

--- a/bluetooth/audio/aidl/default/BluetoothAudioProvider.h
+++ b/bluetooth/audio/aidl/default/BluetoothAudioProvider.h
@@ -16,6 +16,7 @@
 #pragma once

 #include <aidl/android/hardware/bluetooth/audio/BnBluetoothAudioProvider.h>
+#include <aidl/android/hardware/bluetooth/audio/LatencyMode.h>
 #include <aidl/android/hardware/bluetooth/audio/SessionType.h>
 #include <fmq/AidlMessageQueue.h>

@@ -37,10 +38,11 @@ namespace audio {
 class BluetoothAudioProvider : public BnBluetoothAudioProvider {
 public:
  BluetoothAudioProvider();
-
  ndk::ScopedAStatus startSession(
      const std::shared_ptr<IBluetoothAudioPort>& host_if,
-      const AudioConfiguration& audio_config, DataMQDesc* _aidl_return);
+      const AudioConfiguration& audio_config,
+      const std::vector<LatencyMode>& latency_modes,
+      DataMQDesc* _aidl_return);
  ndk::ScopedAStatus endSession();
  ndk::ScopedAStatus streamStarted(BluetoothAudioStatus status);
  ndk::ScopedAStatus streamSuspended(BluetoothAudioStatus status);
@@ -59,6 +61,7 @@ class BluetoothAudioProvider : public BnBluetoothAudioProvider {
  std::shared_ptr<IBluetoothAudioPort> stack_iface_;
  std::unique_ptr<AudioConfiguration> audio_config_ = nullptr;
  SessionType session_type_;
+  std::vector<LatencyMode> latency_modes_;
 };

 }  // namespace audio
--- a/bluetooth/audio/aidl/default/HearingAidAudioProvider.cpp
+++ b/bluetooth/audio/aidl/default/HearingAidAudioProvider.cpp
@@ -56,7 +56,10 @@ bool HearingAidAudioProvider::isValid(const SessionType& sessionType) {

 ndk::ScopedAStatus HearingAidAudioProvider::startSession(
    const std::shared_ptr<IBluetoothAudioPort>& host_if,
-    const AudioConfiguration& audio_config, DataMQDesc* _aidl_return) {
+    const AudioConfiguration& audio_config,
+    const std::vector<LatencyMode>& latency_modes,
+    DataMQDesc* _aidl_return) {
+  latency_modes_ = latency_modes;
  if (audio_config.getTag() != AudioConfiguration::pcmConfig) {
    LOG(WARNING) << __func__ << " - Invalid Audio Configuration="
                 << audio_config.toString();
@@ -71,8 +74,8 @@ ndk::ScopedAStatus HearingAidAudioProvider::startSession(
    return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
  }

-  return BluetoothAudioProvider::startSession(host_if, audio_config,
-                                              _aidl_return);
+  return BluetoothAudioProvider::startSession(
+      host_if, audio_config, latency_modes, _aidl_return);
 }

 ndk::ScopedAStatus HearingAidAudioProvider::onSessionReady(
--- a/bluetooth/audio/aidl/default/HearingAidAudioProvider.h
+++ b/bluetooth/audio/aidl/default/HearingAidAudioProvider.h
@@ -32,7 +32,9 @@ class HearingAidAudioProvider : public BluetoothAudioProvider {

  ndk::ScopedAStatus startSession(
      const std::shared_ptr<IBluetoothAudioPort>& host_if,
-      const AudioConfiguration& audio_config, DataMQDesc* _aidl_return);
+      const AudioConfiguration& audio_config,
+      const std::vector<LatencyMode>& latency_modes,
+      DataMQDesc* _aidl_return);

 private:
  // audio data queue for software encoding
--- a/bluetooth/audio/aidl/default/LeAudioOffloadAudioProvider.cpp
+++ b/bluetooth/audio/aidl/default/LeAudioOffloadAudioProvider.cpp
@@ -53,7 +53,10 @@ bool LeAudioOffloadAudioProvider::isValid(const SessionType& sessionType) {

 ndk::ScopedAStatus LeAudioOffloadAudioProvider::startSession(
    const std::shared_ptr<IBluetoothAudioPort>& host_if,
-    const AudioConfiguration& audio_config, DataMQDesc* _aidl_return) {
+    const AudioConfiguration& audio_config,
+    const std::vector<LatencyMode>& latency_modes,
+    DataMQDesc* _aidl_return) {
+  latency_modes_ = latency_modes;
  if (audio_config.getTag() != AudioConfiguration::leAudioConfig) {
    LOG(WARNING) << __func__ << " - Invalid Audio Configuration="
                 << audio_config.toString();
@@ -70,8 +73,8 @@ ndk::ScopedAStatus LeAudioOffloadAudioProvider::startSession(
    return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
  }

-  return BluetoothAudioProvider::startSession(host_if, audio_config,
-                                              _aidl_return);
+  return BluetoothAudioProvider::startSession(
+      host_if, audio_config, latency_modes, _aidl_return);
 }

 ndk::ScopedAStatus LeAudioOffloadAudioProvider::onSessionReady(
--- a/bluetooth/audio/aidl/default/LeAudioOffloadAudioProvider.h
+++ b/bluetooth/audio/aidl/default/LeAudioOffloadAudioProvider.h
@@ -32,7 +32,9 @@ class LeAudioOffloadAudioProvider : public BluetoothAudioProvider {

  ndk::ScopedAStatus startSession(
      const std::shared_ptr<IBluetoothAudioPort>& host_if,
-      const AudioConfiguration& audio_config, DataMQDesc* _aidl_return);
+      const AudioConfiguration& audio_config,
+      const std::vector<LatencyMode>& latency_modes,
+      DataMQDesc* _aidl_return);

 private:
  ndk::ScopedAStatus onSessionReady(DataMQDesc* _aidl_return) override;
--- a/bluetooth/audio/aidl/default/LeAudioSoftwareAudioProvider.cpp
+++ b/bluetooth/audio/aidl/default/LeAudioSoftwareAudioProvider.cpp
@@ -69,7 +69,10 @@ bool LeAudioSoftwareAudioProvider::isValid(const SessionType& sessionType) {

 ndk::ScopedAStatus LeAudioSoftwareAudioProvider::startSession(
    const std::shared_ptr<IBluetoothAudioPort>& host_if,
-    const AudioConfiguration& audio_config, DataMQDesc* _aidl_return) {
+    const AudioConfiguration& audio_config,
+    const std::vector<LatencyMode>& latency_modes,
+    DataMQDesc* _aidl_return) {
+  latency_modes_ = latency_modes;
  if (audio_config.getTag() != AudioConfiguration::pcmConfig) {
    LOG(WARNING) << __func__ << " - Invalid Audio Configuration="
                 << audio_config.toString();
@@ -119,8 +122,8 @@ ndk::ScopedAStatus LeAudioSoftwareAudioProvider::startSession(
  }
  data_mq_ = std::move(temp_data_mq);

-  return BluetoothAudioProvider::startSession(host_if, audio_config,
-                                              _aidl_return);
+  return BluetoothAudioProvider::startSession(
+      host_if, audio_config, latency_modes, _aidl_return);
 }

 ndk::ScopedAStatus LeAudioSoftwareAudioProvider::onSessionReady(
--- a/bluetooth/audio/aidl/default/LeAudioSoftwareAudioProvider.h
+++ b/bluetooth/audio/aidl/default/LeAudioSoftwareAudioProvider.h
@@ -32,7 +32,9 @@ class LeAudioSoftwareAudioProvider : public BluetoothAudioProvider {

  ndk::ScopedAStatus startSession(
      const std::shared_ptr<IBluetoothAudioPort>& host_if,
-      const AudioConfiguration& audio_config, DataMQDesc* _aidl_return);
+      const AudioConfiguration& audio_config,
+      const std::vector<LatencyMode>& latency_modes,
+      DataMQDesc* _aidl_return);

 private:
  // audio data queue for software encoding
--- a/bluetooth/audio/aidl/vts/VtsHalBluetoothAudioTargetTest.cpp
+++ b/bluetooth/audio/aidl/vts/VtsHalBluetoothAudioTargetTest.cpp
@@ -88,7 +88,7 @@ static constexpr CodecType a2dp_codec_types[] = {
    CodecType::UNKNOWN, CodecType::SBC,          CodecType::AAC,
    CodecType::APTX,    CodecType::APTX_HD,      CodecType::LDAC,
    CodecType::LC3,     CodecType::APTX_ADAPTIVE};
-
+static std::vector<LatencyMode> latency_modes = {LatencyMode::FREE};
 // Helpers

 template <typename T>
@@ -381,7 +381,8 @@ TEST_P(BluetoothAudioProviderA2dpSoftwareAidl,
        bool is_codec_config_valid = IsPcmConfigSupported(pcm_config);
        DataMQDesc mq_desc;
        auto aidl_retval = audio_provider_->startSession(
-            audio_port_, AudioConfiguration(pcm_config), &mq_desc);
+            audio_port_, AudioConfiguration(pcm_config), latency_modes,
+            &mq_desc);
        DataMQ data_mq(mq_desc);

        EXPECT_EQ(aidl_retval.isOk(), is_codec_config_valid);
@@ -673,7 +674,7 @@ TEST_P(BluetoothAudioProviderA2dpHardwareAidl,
    copy_codec_specific(codec_config.config, codec_specific);
    DataMQDesc mq_desc;
    auto aidl_retval = audio_provider_->startSession(
-        audio_port_, AudioConfiguration(codec_config), &mq_desc);
+        audio_port_, AudioConfiguration(codec_config), latency_modes, &mq_desc);

    ASSERT_TRUE(aidl_retval.isOk());
    EXPECT_TRUE(audio_provider_->endSession().isOk());
@@ -703,7 +704,7 @@ TEST_P(BluetoothAudioProviderA2dpHardwareAidl,
    copy_codec_specific(codec_config.config, codec_specific);
    DataMQDesc mq_desc;
    auto aidl_retval = audio_provider_->startSession(
-        audio_port_, AudioConfiguration(codec_config), &mq_desc);
+        audio_port_, AudioConfiguration(codec_config), latency_modes, &mq_desc);

    ASSERT_TRUE(aidl_retval.isOk());
    EXPECT_TRUE(audio_provider_->endSession().isOk());
@@ -733,7 +734,7 @@ TEST_P(BluetoothAudioProviderA2dpHardwareAidl,
    copy_codec_specific(codec_config.config, codec_specific);
    DataMQDesc mq_desc;
    auto aidl_retval = audio_provider_->startSession(
-        audio_port_, AudioConfiguration(codec_config), &mq_desc);
+        audio_port_, AudioConfiguration(codec_config), latency_modes, &mq_desc);

    ASSERT_TRUE(aidl_retval.isOk());
    EXPECT_TRUE(audio_provider_->endSession().isOk());
@@ -763,7 +764,7 @@ TEST_P(BluetoothAudioProviderA2dpHardwareAidl,
    copy_codec_specific(codec_config.config, codec_specific);
    DataMQDesc mq_desc;
    auto aidl_retval = audio_provider_->startSession(
-        audio_port_, AudioConfiguration(codec_config), &mq_desc);
+        audio_port_, AudioConfiguration(codec_config), latency_modes, &mq_desc);

    ASSERT_TRUE(aidl_retval.isOk());
    EXPECT_TRUE(audio_provider_->endSession().isOk());
@@ -797,7 +798,8 @@ TEST_P(BluetoothAudioProviderA2dpHardwareAidl,
      copy_codec_specific(codec_config.config, codec_specific);
      DataMQDesc mq_desc;
      auto aidl_retval = audio_provider_->startSession(
-          audio_port_, AudioConfiguration(codec_config), &mq_desc);
+          audio_port_, AudioConfiguration(codec_config), latency_modes,
+          &mq_desc);

      ASSERT_TRUE(aidl_retval.isOk());
      EXPECT_TRUE(audio_provider_->endSession().isOk());
@@ -858,7 +860,8 @@ TEST_P(BluetoothAudioProviderA2dpHardwareAidl,
      copy_codec_specific(codec_config.config, codec_specific);
      DataMQDesc mq_desc;
      auto aidl_retval = audio_provider_->startSession(
-          audio_port_, AudioConfiguration(codec_config), &mq_desc);
+          audio_port_, AudioConfiguration(codec_config), latency_modes,
+          &mq_desc);

      // AIDL call should fail on invalid codec
      ASSERT_FALSE(aidl_retval.isOk());
@@ -917,7 +920,8 @@ TEST_P(BluetoothAudioProviderHearingAidSoftwareAidl,
        bool is_codec_config_valid = IsPcmConfigSupported(pcm_config);
        DataMQDesc mq_desc;
        auto aidl_retval = audio_provider_->startSession(
-            audio_port_, AudioConfiguration(pcm_config), &mq_desc);
+            audio_port_, AudioConfiguration(pcm_config), latency_modes,
+            &mq_desc);
        DataMQ data_mq(mq_desc);

        EXPECT_EQ(aidl_retval.isOk(), is_codec_config_valid);
@@ -989,7 +993,8 @@ TEST_P(BluetoothAudioProviderLeAudioOutputSoftwareAidl,
              IsPcmConfigSupported(pcm_config) && pcm_config.dataIntervalUs > 0;
          DataMQDesc mq_desc;
          auto aidl_retval = audio_provider_->startSession(
-              audio_port_, AudioConfiguration(pcm_config), &mq_desc);
+              audio_port_, AudioConfiguration(pcm_config), latency_modes,
+              &mq_desc);
          DataMQ data_mq(mq_desc);

          EXPECT_EQ(aidl_retval.isOk(), is_codec_config_valid);
@@ -1061,7 +1066,8 @@ TEST_P(BluetoothAudioProviderLeAudioInputSoftwareAidl,
              IsPcmConfigSupported(pcm_config) && pcm_config.dataIntervalUs > 0;
          DataMQDesc mq_desc;
          auto aidl_retval = audio_provider_->startSession(
-              audio_port_, AudioConfiguration(pcm_config), &mq_desc);
+              audio_port_, AudioConfiguration(pcm_config), latency_modes,
+              &mq_desc);
          DataMQ data_mq(mq_desc);

          EXPECT_EQ(aidl_retval.isOk(), is_codec_config_valid);
@@ -1194,7 +1200,8 @@ TEST_P(BluetoothAudioProviderLeAudioOutputHardwareAidl,
        .set<LeAudioCodecConfiguration::lc3Config>(lc3_config);
    DataMQDesc mq_desc;
    auto aidl_retval = audio_provider_->startSession(
-        audio_port_, AudioConfiguration(le_audio_config), &mq_desc);
+        audio_port_, AudioConfiguration(le_audio_config), latency_modes,
+        &mq_desc);

    ASSERT_TRUE(aidl_retval.isOk());
    EXPECT_TRUE(audio_provider_->endSession().isOk());
@@ -1226,7 +1233,8 @@ TEST_P(BluetoothAudioProviderLeAudioOutputHardwareAidl,
        .set<LeAudioCodecConfiguration::lc3Config>(lc3_config);
    DataMQDesc mq_desc;
    auto aidl_retval = audio_provider_->startSession(
-        audio_port_, AudioConfiguration(le_audio_config), &mq_desc);
+        audio_port_, AudioConfiguration(le_audio_config), latency_modes,
+        &mq_desc);

    // AIDL call should fail on invalid codec
    ASSERT_FALSE(aidl_retval.isOk());
@@ -1302,7 +1310,8 @@ TEST_P(BluetoothAudioProviderLeAudioInputHardwareAidl,
        .set<LeAudioCodecConfiguration::lc3Config>(lc3_config);
    DataMQDesc mq_desc;
    auto aidl_retval = audio_provider_->startSession(
-        audio_port_, AudioConfiguration(le_audio_config), &mq_desc);
+        audio_port_, AudioConfiguration(le_audio_config), latency_modes,
+        &mq_desc);

    ASSERT_TRUE(aidl_retval.isOk());
    EXPECT_TRUE(audio_provider_->endSession().isOk());
@@ -1335,7 +1344,8 @@ TEST_P(BluetoothAudioProviderLeAudioInputHardwareAidl,

    DataMQDesc mq_desc;
    auto aidl_retval = audio_provider_->startSession(
-        audio_port_, AudioConfiguration(le_audio_config), &mq_desc);
+        audio_port_, AudioConfiguration(le_audio_config), latency_modes,
+        &mq_desc);

    // AIDL call should fail on invalid codec
    ASSERT_FALSE(aidl_retval.isOk());
@@ -1403,7 +1413,8 @@ TEST_P(BluetoothAudioProviderLeAudioBroadcastSoftwareAidl,
              IsPcmConfigSupported(pcm_config) && pcm_config.dataIntervalUs > 0;
          DataMQDesc mq_desc;
          auto aidl_retval = audio_provider_->startSession(
-              audio_port_, AudioConfiguration(pcm_config), &mq_desc);
+              audio_port_, AudioConfiguration(pcm_config), latency_modes,
+              &mq_desc);
          DataMQ data_mq(mq_desc);

          EXPECT_EQ(aidl_retval.isOk(), is_codec_config_valid);