GetStream · PratimMallick · Sep 11, 2026 · Aug 26, 2026 · Aug 27, 2026 · Aug 27, 2026
@@ -181,6 +181,13 @@ fun CallStats(call: Call) {
             val publisherCodecLabel = if (publisherVideoCodec.isNotEmpty()) "($publisherVideoCodec)" else ""
             val subscriberVideoCodec by call.state.stats.subscriber.videoCodec.collectAsStateWithLifecycle()
             val subscriberCodecLabel = if (subscriberVideoCodec.isNotEmpty()) "($subscriberVideoCodec)" else ""
+            val publisherAudioBitrate by call.state.stats.publisher.audioBitrateKbps
+                .collectAsStateWithLifecycle()
+            val subscriberAudioBitrate by call.state.stats.subscriber.audioBitrateKbps
+                .collectAsStateWithLifecycle()
+            val audioCodec by call.state.stats.publisher.audioCodec.collectAsStateWithLifecycle()
+            val audioTargetBitrate by call.state.stats.publisher.audioTargetBitrateKbps
+                .collectAsStateWithLifecycle()
 
             LatencyOrJitter(title = "Latency", value = latency)
             Spacer(modifier = Modifier.size(16.dp))
@@ -199,9 +206,19 @@ fun CallStats(call: Call) {
                 value = subscriberResolution,
             )
             Spacer(modifier = Modifier.size(16.dp))
-            StatItem(title = "Publish bitrate", value = "$publisherBitrate Kbps")
+            // These two are the connection's bandwidth estimate, not a transmitted rate — named
+            // accordingly so they stop being read as "what we are sending".
+            StatItem(title = "Available outgoing bitrate", value = "$publisherBitrate Kbps")
             Spacer(modifier = Modifier.size(16.dp))
-            StatItem(title = "Receiving bitrate", value = "$subscriberBitrate Kbps")
+            StatItem(title = "Available incoming bitrate", value = "$subscriberBitrate Kbps")
+            Spacer(modifier = Modifier.size(16.dp))
+            StatItem(title = "Audio target", value = "%.0f Kbps".format(audioTargetBitrate))
+            Spacer(modifier = Modifier.size(16.dp))
+            StatItem(title = "Audio sent", value = "%.1f Kbps".format(publisherAudioBitrate))
+            Spacer(modifier = Modifier.size(16.dp))
+            StatItem(title = "Audio received", value = "%.1f Kbps".format(subscriberAudioBitrate))
+            Spacer(modifier = Modifier.size(16.dp))
+            StatItem(title = "Audio codec", value = audioCodec)
         }
     }
 }

@@ -31,6 +31,7 @@ import androidx.compose.material.icons.filled.ClosedCaptionOff
 import androidx.compose.material.icons.filled.Crop
 import androidx.compose.material.icons.filled.CropFree
 import androidx.compose.material.icons.filled.Feedback
+import androidx.compose.material.icons.filled.MusicNote
 import androidx.compose.material.icons.filled.Person
 import androidx.compose.material.icons.filled.RadioButtonChecked
 import androidx.compose.material.icons.filled.RawOff
@@ -96,6 +97,8 @@ fun defaultStreamMenu(
     onToggleAudioUsage: () -> Unit = {},
     selectedRecordingTypes: Set<RecordingType> = emptySet(),
     onSelectRecordingType: (RecordingType) -> Unit = {},
+    isMusicAudioProfile: Boolean = false,
+    onToggleAudioProfile: () -> Unit = {},
 ) = buildList<MenuItem> {
     if (noiseCancellationFeatureEnabled) {
         add(
@@ -175,6 +178,8 @@ fun defaultStreamMenu(
                     onToggleAudioUsage,
                     selectedRecordingTypes,
                     onSelectRecordingType,
+                    isMusicAudioProfile,
+                    onToggleAudioProfile,
                 ),
             ),
         )
@@ -358,7 +363,15 @@ fun debugSubmenu(
     onToggleAudioUsage: () -> Unit,
     selectedRecordingTypes: Set<RecordingType>,
     onSelectRecordingType: (RecordingType) -> Unit,
+    isMusicAudioProfile: Boolean = false,
+    onToggleAudioProfile: () -> Unit = {},
 ) = listOf(
+    ActionMenuItem(
+        title = if (isMusicAudioProfile) "Music mode: On" else "Music mode: Off",
+        icon = Icons.Default.MusicNote,
+        highlight = isMusicAudioProfile,
+        action = onToggleAudioProfile,
+    ),
     DynamicSubMenuItem(
         title = "List Transcriptions",
         icon = Icons.AutoMirrored.Filled.ReceiptLong,

@@ -74,6 +74,7 @@ import io.getstream.video.android.ui.menu.base.MenuItem
 import io.getstream.video.android.ui.menu.transcriptions.TranscriptionUiStateManager
 import io.getstream.video.android.util.filters.SampleAudioFilter
 import kotlinx.coroutines.launch
+import stream.video.sfu.models.AudioBitrateProfile
 import java.nio.ByteBuffer
 
 @OptIn(ExperimentalPermissionsApi::class)
@@ -114,6 +115,36 @@ internal fun SettingsMenu(
         call.speaker.setAudioUsage(newAudioUsage)
     }
 
+    val audioBitrateProfile by call.microphone.audioBitrateProfile.collectAsStateWithLifecycle()
+    val isMusicAudioProfile =
+        audioBitrateProfile == AudioBitrateProfile.AUDIO_BITRATE_PROFILE_MUSIC_HIGH_QUALITY
+
+    val onToggleAudioProfile: () -> Unit = {
+        val next = if (isMusicAudioProfile) {
+            AudioBitrateProfile.AUDIO_BITRATE_PROFILE_VOICE_STANDARD_UNSPECIFIED
+        } else {
+            AudioBitrateProfile.AUDIO_BITRATE_PROFILE_MUSIC_HIGH_QUALITY
+        }
+        val turningOn = !isMusicAudioProfile
+        scope.launch {
+            call.microphone.setAudioBitrateProfile(next)
+                .onSuccess {
+                    Toast.makeText(
+                        context,
+                        if (turningOn) "Music mode on" else "Music mode off",
+                        Toast.LENGTH_LONG,
+                    ).show()
+                }
+                .onFailure {
+                    Toast.makeText(
+                        context,
+                        "Music mode not changed: ${it.message}",
+                        Toast.LENGTH_LONG,
+                    ).show()
+                }
+        }
+    }
+
     val onToggleAudioFilterClick: () -> Unit = {
         if (call.audioFilter == null) {
             call.audioFilter = object : InputAudioFilter {
@@ -360,6 +391,8 @@ internal fun SettingsMenu(
                 onToggleAudioUsage = onToggleAudioUsage,
                 selectedRecordingTypes = enabledRecordingTypes,
                 onSelectRecordingType = onSelectRecordingType,
+                isMusicAudioProfile = isMusicAudioProfile,
+                onToggleAudioProfile = onToggleAudioProfile,
             ),
         )
     }

@@ -49,7 +49,7 @@ tink = "1.9.0"
 turbine = "0.13.0"
 itu = "1.7.3"
 
-streamWebRTC = "145.17.0"
+streamWebRTC = "145.19.0"
 streamNoiseCancellation = "3.0.0"
 streamResult = "1.3.0"
 streamChat = "6.10.0"

@@ -9657,6 +9657,9 @@ public final class io/getstream/video/android/core/ParticipantState$Video : io/g
 
 public final class io/getstream/video/android/core/PeerConnectionStats {
 	public fun <init> (Lkotlinx/coroutines/CoroutineScope;)V
+	public final fun getAudioBitrateKbps ()Lkotlinx/coroutines/flow/StateFlow;
+	public final fun getAudioCodec ()Lkotlinx/coroutines/flow/StateFlow;
+	public final fun getAudioTargetBitrateKbps ()Lkotlinx/coroutines/flow/StateFlow;
 	public final fun getBitrateKbps ()Lkotlinx/coroutines/flow/StateFlow;
 	public final fun getJitterInMs ()Lkotlinx/coroutines/flow/StateFlow;
 	public final fun getLatency ()Lkotlinx/coroutines/flow/StateFlow;

@@ -93,6 +93,16 @@ android {
         unitTests {
             isIncludeAndroidResources = true
             isReturnDefaultValues = true
+
+            all {
+                // Robolectric builds a full Android sandbox per SDK level named in @Config, and
+                // this module's suite spans six of them in one JVM — nothing sets forkEvery here,
+                // so they accumulate. On CI that runs out of heap while loading an android-all
+                // jar, and which class reports it depends on execution order, which is why the
+                // telecom and notification tests kept getting blamed. The Xmx in
+                // gradle.properties is the daemon's, not the test JVM's, so it never applied.
+                it.maxHeapSize = "2g"
+            }
         }
 
         managedDevices {

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2014-2026 Stream.io Inc. All rights reserved.
+ *
+ * Licensed under the Stream License;
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://github.com/GetStream/stream-video-android/blob/main/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.getstream.video.android.core
+
+import stream.video.sfu.models.AudioBitrateProfile
+
+/**
+ * What [MicrophoneManager.setAudioBitrateProfile] managed to change, for logging and for naming
+ * the stages in a failure. Internal: callers get the profile back on
+ * [MicrophoneManager.audioBitrateProfile] and a failure when it did not take.
+ *
+ * A stage reports true when it matches [profile] *or* when there is nothing for it to move —
+ * no live capture, no sender, no such hardware. False means a live stage refused, and the reason
+ * is logged.
+ *
+ * @property audioMaxBitrateBps The bitrate now on the live audio sender, or null when the
+ * SFU-negotiated one stands.
+ */
+internal data class AudioProfileResult(
+    val profile: AudioBitrateProfile,
+    val audioMaxBitrateBps: Int?,
+    val noiseCancellationApplied: Boolean,
+    val platformNoiseSuppressorApplied: Boolean,
+    val platformAcousticEchoCancelerApplied: Boolean,
+    val softwareAudioProcessingApplied: Boolean,
+    val audioMaxBitrateApplied: Boolean,
+    val captureAudioSourceApplied: Boolean,
+) {
+    /** Stages that are still processing audio the previous profile's way. */
+    val missedStages: List<String>
+        get() = buildList {
+            if (!noiseCancellationApplied) add("noise cancellation")
+            if (!platformNoiseSuppressorApplied) add("hardware noise suppressor")
+            if (!platformAcousticEchoCancelerApplied) add("hardware echo canceller")
+            if (!softwareAudioProcessingApplied) add("software audio processing")
+            if (!audioMaxBitrateApplied) add("max bitrate")
+            if (!captureAudioSourceApplied) add("capture audio source")
+        }
+
+    /** Every stage reached. */
+    val complete: Boolean get() = missedStages.isEmpty()
+}
@@ -121,7 +121,7 @@
        "fastReconnectDeadlineSeconds. This constant will be removed in a future release.",
    level = DeprecationLevel.WARNING,
 )
 const val sfuReconnectTimeoutMillis = 30_000

 /**
 * The call class gives you access to all call level API calls
@@ -160,7 +160,7 @@
     * `StreamVideoClient`, `ActiveStateGate`, the media session controller and [Debug]. Components
     * under `call.components` take [CallSessionManager] directly rather than reading it from here.
     */
    // TODO(v2): hand those consumers the CallSessionManager and drop this accessor. Blocked on
    //  binary compatibility today: CallStats' constructor is published ABI, and adding a parameter
    //  replaces it rather than overloading it (defaults are source-level only). CallSessionManager
    //  is also internal, so it cannot appear in a public signature at all.
@@ -173,7 +173,7 @@
        }

    // Unit-test only hook for replacing RtcSession construction.
    // TODO(v2): replace this with a proper dependency injection boundary.
    internal var unitTestRtcSessionFactory: (() -> RtcSession)? = null

    /**
@@ -264,9 +264,9 @@
    /** Delegate that owns the event flow, subscriptions and event dispatch. */
    private val eventManager = CallEventManager(type, id, scope, reconnector = { reconnector })

    // Must be initialized before `state` — CallState → SortedParticipantsState
    // launches a coroutine that reads `call.events` (leaking-this race).
    val events: MutableSharedFlow<VideoEvent> = eventManager.events

    /** The call state contains all state such as the participant list, reactions etc */
    val state = CallState(client, this, user, scope)
@@ -853,7 +853,7 @@
        message = "Deprecated in favor of the `events` flow.",
        replaceWith = ReplaceWith("events.collect { }"),
    )
    public fun unsubscribe(eventSubscription: EventSubscription) =
        eventManager.unsubscribe(eventSubscription)

    public suspend fun blockUser(userId: String): Result<BlockUserResponse> =
@@ -921,7 +921,7 @@
    }

    @VisibleForTesting
    internal suspend fun joinRequest(
        create: CreateCallOptions? = null,
        location: String,
        migratingFrom: String? = null,
@@ -963,7 +963,7 @@
    /**
     * Should outlive both the call scope and the service scope and needs to be executed in the client-level scope.
     * Because the call scope or service scope may be cancelled or finished while the network request is still in flight
     * TODO: Run this in clientImpl.scope internally
     */
    suspend fun reject(reason: RejectReason? = null): Result<RejectCallResponse> =
        apiClient.reject(reason)
@@ -1040,6 +1040,53 @@
         notifyNoiseCancellationState(media.isAudioProcessingEnabledIfCreated())
     }
 
+    // Audio bitrate profile bridges. [MicrophoneManager.setAudioBitrateProfile] is the public
+    // entry point and can reach neither the media component nor the session from there.
+
+    internal fun setHardwareNoiseSuppressorEnabled(enabled: Boolean): Boolean =
+        media.setHardwareNoiseSuppressorEnabled(enabled)
+
+    internal fun setHardwareAcousticEchoCancelerEnabled(enabled: Boolean): Boolean =
+        media.setHardwareAcousticEchoCancelerEnabled(enabled)
+
+    /** Must not be called from the main thread: the module rebuilds AudioRecord. */
+    internal fun setCaptureAudioSource(audioSource: Int): Boolean =
+        media.setCaptureAudioSource(audioSource)
+
+    /**
+     * Rebuilds the audio source and track so audio-source constraints take effect mid-call. With
+     * no session the source is built lazily from current constraints, so the change already holds.
+     */
+    internal fun rebuildAudioCapturePipeline(): Boolean =
+        session.value?.rebuildAudioCapturePipeline() ?: true
+
+    internal fun setAudioMaxBitrate(maxBitrateBps: Int): Boolean =
+        session.value?.setAudioMaxBitrate(maxBitrateBps) ?: false
+
+    /** Whether an audio sender exists to take a live profile change. */
+    internal fun hasLiveAudioSender(): Boolean =
+        session.value?.hasLiveAudioSender() ?: false
+
+    internal fun audioMaxBitrate(): Int? = session.value?.audioMaxBitrate()
+
+    /** The audio bitrate the SFU negotiated at join, or null when nothing publishes audio. */
+    internal fun negotiatedAudioBitrate(): Int? = session.value?.negotiatedAudioBitrate()
+
+    /** The bitrate the SFU offers for [profile], or null when it named none. */
+    internal fun audioBitrateFor(profile: stream.video.sfu.models.AudioBitrateProfile): Int? =
+        session.value?.audioBitrateFor(profile)
+
+    /** Whether a noise-cancellation processor is wired in and can be turned on or off. */
+    internal fun isAudioProcessingReachable(): Boolean = media.isAudioProcessingReachable()
+
+    // Absent hardware is not the same as hardware that refused, so these are asked separately.
+
+    internal fun isHardwareNoiseSuppressorSupported(): Boolean =
+        media.isHardwareNoiseSuppressorSupported()
+
+    internal fun isHardwareAcousticEchoCancelerSupported(): Boolean =
+        media.isHardwareAcousticEchoCancelerSupported()
+
     fun toggleAudioProcessing(): Boolean {
         // Reads without building a factory: the gate runs before join, and a factory created
         // there would capture the pre-join audio bitrate profile.

@@ -69,6 +69,57 @@
 
     internal val _videoCodec: MutableStateFlow<String> = MutableStateFlow("")
     val videoCodec: StateFlow<String> = _videoCodec
+
+    internal val _audioBitrateKbps: MutableStateFlow<Float> = MutableStateFlow(0F)
+
+    /**
+     * Audio bitrate actually sent or received, measured from the RTP byte counters between two
+     * stats polls.
+     *
+     * Distinct from [bitrateKbps], which reports the connection's *available* bandwidth estimate
+     * rather than anything that was transmitted. This one moves when the encoder does.
+     */
+    val audioBitrateKbps: StateFlow<Float> = _audioBitrateKbps
+
+    internal val _audioCodec: MutableStateFlow<String> = MutableStateFlow("")
+    val audioCodec: StateFlow<String> = _audioCodec
+
+    internal val _audioTargetBitrateKbps: MutableStateFlow<Float> = MutableStateFlow(0F)
+
+    /**
+     * The bitrate the audio encoder is aiming for, as reported by `outbound-rtp`.
+     *
+     * The requested value, where [audioBitrateKbps] is what actually went out. Comparing the two
+     * is how you tell "we asked for more" from "we are sending more".
+     */
+    val audioTargetBitrateKbps: StateFlow<Float> = _audioTargetBitrateKbps
+
+    /** Byte counter and its timestamp from the previous poll, to derive a rate. */
+    internal var lastAudioBytes: Long? = null
+    internal var lastAudioTimestampUs: Double? = null
+
+    /**
+     * Derives the audio bitrate from the change in [bytes] since the previous poll.
+     *
+     * The first sample only seeds the baseline — a rate needs two points. A counter that went
+     * backwards means the stream was replaced, so the baseline is reset rather than reported as a
+     * negative rate.
+     */
+    internal fun updateAudioBitrate(bytes: Long?, timestampUs: Double) {
+        if (bytes == null) return
+        val previousBytes = lastAudioBytes
+        val previousTimestampUs = lastAudioTimestampUs
+        lastAudioBytes = bytes
+        lastAudioTimestampUs = timestampUs
+
+        if (previousBytes == null || previousTimestampUs == null) return
+        val elapsedUs = timestampUs - previousTimestampUs
+        val deltaBytes = bytes - previousBytes
+        if (elapsedUs <= 0 || deltaBytes < 0) return
+
+        val bitsPerSecond = deltaBytes * 8.0 * 1_000_000.0 / elapsedUs
+        _audioBitrateKbps.value = (bitsPerSecond / 1000).toFloat()
+    }
 }
 
 public data class LocalStats(
@@ -193,6 +244,55 @@
                     subscriber._resolution.value = "$width x $height @ $fps fps"
                 }
             }
+            // Audio send/receive rate, derived from the RTP byte counters. Nothing else reports
+            // what the audio encoder is actually doing — the candidate-pair numbers below are a
+            // bandwidth estimate, not a transmitted rate.
+            statGroups["outbound-rtp:audio"]?.firstOrNull()?.let {
+                publisher.updateAudioBitrate(
+                    bytes = it.members["bytesSent"] as? Long,
+                    timestampUs = it.timestampUs,
+                )
+                (it.members["targetBitrate"] as? Double)?.let { target ->
+                    publisher._audioTargetBitrateKbps.value = (target / 1000).toFloat()
+                }
+            }
+            statGroups["inbound-rtp:audio"]?.firstOrNull()?.let {
+                subscriber.updateAudioBitrate(
+                    bytes = it.members["bytesReceived"] as? Long,
+                    timestampUs = it.timestampUs,
+                )
+            }
+            // The publisher and the subscriber report are both fed through here, and each one
+            // describes only its own direction. Writing both sides from either report leaves
+            // whichever ran last showing on both, so the codec is resolved through the matching
+            // RTP statistic's own codecId — which also picks the right entry when a report
+            // carries more than one audio codec — and only that direction is updated.
+            val audioRtp = if (isPublisher) {
+                statGroups["outbound-rtp:audio"]
+            } else {
+                statGroups["inbound-rtp:audio"]
+            }?.firstOrNull()
+            val audioCodecStat = (audioRtp?.members?.get("codecId") as? String)
+                ?.let { codecId -> stats.origin.statsMap[codecId] }
+                ?: statGroups["codec:audio"]?.firstOrNull()
+            audioCodecStat?.let {
+                val mimeType = it.members["mimeType"] as? String
+                val clockRate = it.members["clockRate"] as? Long
+                val channels = it.members["channels"] as? Long
+                val fmtp = it.members["sdpFmtpLine"] as? String
+                val codec = listOfNotNull(
+                    mimeType,
+                    clockRate?.let { rate -> "$rate Hz" },
+                    channels?.let { count -> if (count > 1) "stereo" else "mono" },
+                    fmtp,
+                ).joinToString(" ")
+                if (isPublisher) {
+                    publisher._audioCodec.value = codec
+                } else {
+                    subscriber._audioCodec.value = codec
+                }
+            }
+
             statGroups["candidate-pair"]?.firstOrNull()?.let {
                 val latency = it.members["currentRoundTripTime"] as? Double
                 val outgoingBitrate = it.members["availableOutgoingBitrate"] as? Double
@@ -243,7 +343,7 @@
    }

    fun updateLocalStats() {
        val displayingAt = call.session.value?.subscriber?.value?.viewportDimensions() ?: emptyMap()
        val resolution = call.camera.resolution.value
        val availableResolutions = call.camera.availableResolutions.value
        val maxResolution = availableResolutions.maxByOrNull { it.width * it.height }