@stream-io/video-react-native-sdk 1.45.0 → 1.45.2

package/CHANGELOG.md

@@ -2,20 +2,44 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.45.2](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-react-native-sdk-1.45.1...@stream-io/video-react-native-sdk-1.45.2) (2026-09-11)
+
+### Dependency Updates
+
+- `@stream-io/noise-cancellation-react-native` updated to version `0.11.1`
+- `@stream-io/react-native-callingx` updated to version `0.11.4`
+- `@stream-io/video-filters-react-native` updated to version `0.16.1`
+- `@stream-io/video-client` updated to version `1.60.0`
+  - **client:** identify the SDK and version on SFU RPCs ([#2425](https://github.com/GetStream/stream-video-js/issues/2425)) ([107ff39](https://github.com/GetStream/stream-video-js/commit/107ff390c706beca4417d4ef5e2c7ec9bbbc321d))
+  - **client:** poll ring state to reconcile a dropped ring outcome ([#2393](https://github.com/GetStream/stream-video-js/issues/2393)) ([4605ac1](https://github.com/GetStream/stream-video-js/commit/4605ac1daf603382b7d3a6267e4852ac9fbfc0eb)), closes [#2422](https://github.com/GetStream/stream-video-js/issues/2422)
+- `@stream-io/video-react-bindings` updated to version `1.20.3`
+
+### Bug Fixes
+
+- **android:** skip explicit Kotlin plugin when AGP registers the kotlin extension ([#2417](https://github.com/GetStream/stream-video-js/issues/2417)) ([6d7ae7f](https://github.com/GetStream/stream-video-js/commit/6d7ae7f15f33dafab5a017597462cba29547187f)), closes [RevenueCat/react-native-purchases#1934](https://github.com/RevenueCat/react-native-purchases/issues/1934)
+
+## [1.45.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-react-native-sdk-1.45.0...@stream-io/video-react-native-sdk-1.45.1) (2026-09-04)
+
+### Dependency Updates
+
+- `@stream-io/react-native-callingx` updated to version `0.11.3`
+- `@stream-io/video-client` updated to version `1.59.1`
+- `@stream-io/video-react-bindings` updated to version `1.20.2`
+
+### Bug Fixes
+
+- **callingx:** don't tear down concurrent calls on stop service ([#2394](https://github.com/GetStream/stream-video-js/issues/2394)) ([d6e9deb](https://github.com/GetStream/stream-video-js/commit/d6e9debbe98ae91cc349f010eb92f76b35a3f932))
+- **rn:** auto-leave previous callingx calls on new join ([#2402](https://github.com/GetStream/stream-video-js/issues/2402)) ([5a3dfdd](https://github.com/GetStream/stream-video-js/commit/5a3dfddd8ddbfacf6e8ea109656be82da91a3436))
+- **rn:** wrong expo plugin Android call-alive foreground service detection ([#2398](https://github.com/GetStream/stream-video-js/issues/2398)) ([eac10b5](https://github.com/GetStream/stream-video-js/commit/eac10b5a390f6949b25535d2b4c4cf9bc3d5f065))
+- workaround for android non-telecom path MODE_IN_COMMUNICATION reset edge-case ([#2360](https://github.com/GetStream/stream-video-js/issues/2360)) ([65a1fb7](https://github.com/GetStream/stream-video-js/commit/65a1fb766461f95a3b70fe221e9ace0caad6c64b))
+
 ## [1.45.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-react-native-sdk-1.44.0...@stream-io/video-react-native-sdk-1.45.0) (2026-08-28)
 
 ### Dependency Updates
 
 - `@stream-io/react-native-callingx` updated to version `0.11.0`
 - `@stream-io/video-client` updated to version `1.59.0`
-  - do not end callingx service without call leave ([#2396](https://github.com/GetStream/stream-video-js/issues/2396)) ([15d6abb](https://github.com/GetStream/stream-video-js/commit/15d6abbfa9f4cc2a47c01d8fc8204016a2f8a448))
-  - **client:** keep devices disabled when querying calls ([#2382](https://github.com/GetStream/stream-video-js/issues/2382)) ([1c69755](https://github.com/GetStream/stream-video-js/commit/1c6975546dd70baf991410300fbf6de5ddfd9c65))
-  - **client:** Prevent concurrent joins ([#2386](https://github.com/GetStream/stream-video-js/issues/2386)) ([92b2cf6](https://github.com/GetStream/stream-video-js/commit/92b2cf62a719ffb98156250eeffa706841c6781c))
-  - **client:** refresh live call state on reconnect re-watch ([#2383](https://github.com/GetStream/stream-video-js/issues/2383)) ([d28067e](https://github.com/GetStream/stream-video-js/commit/d28067e543592e9ab8d8219fcaa9250d938dbc70))
-  - **client:** use generated call reporting types and remove unused fields ([#2377](https://github.com/GetStream/stream-video-js/issues/2377)) ([2eab662](https://github.com/GetStream/stream-video-js/commit/2eab66293c41c8e1d6467f2536525511186862e2))
-  - missing own capabilities for incoming call ([#2388](https://github.com/GetStream/stream-video-js/issues/2388)) ([0a04d34](https://github.com/GetStream/stream-video-js/commit/0a04d34a258d7ab3702348a1f929f87e62531875))
 - `@stream-io/video-react-bindings` updated to version `1.20.1`
-  - emit per-module ESM builds for the React packages ([#2378](https://github.com/GetStream/stream-video-js/issues/2378)) ([9c937f4](https://github.com/GetStream/stream-video-js/commit/9c937f4b5845aa0e8108a218b1c84b7acb249d77))
 
 ### Features
 

package/android/build.gradle

@@ -19,7 +19,13 @@ def isNewArchitectureEnabled() {
 }
 
 apply plugin: "com.android.library"
-apply plugin: "kotlin-android"
+// AGP 9 ships built-in Kotlin support and registers the `kotlin` extension
+// itself. Applying the Kotlin plugin on top of it fails configuration with
+// "Cannot add extension with name 'kotlin'". Only apply it when nothing has
+// registered that extension yet.
+if (project.extensions.findByName('kotlin') == null) {
+    apply plugin: "kotlin-android"
+}
 
 if (isNewArchitectureEnabled()) {
     apply plugin: "com.facebook.react"

package/android/src/main/java/com/streamvideo/reactnative/audio/AudioDeviceManager.kt

@@ -107,6 +107,30 @@ class AudioDeviceManager(
      */
     var telecomManagedMode: Boolean = false
 
+    /**
+     * Opt-out for the Android 11+ communication-mode keep-alive. Sticky developer preference —
+     * intentionally NOT reset in [stop], unlike the per-call fields above.
+     */
+    var disableCommunicationModeWorkaround: Boolean = false
+
+    /**
+     * True once [stop]/[close] have torn routing down, until the next [start].
+     *
+     * [updateAudioDeviceState] is enqueued from off-thread sources (Bluetooth receivers,
+     * audio-focus and device callbacks), so a task can still land after teardown. Re-routing
+     * then would re-assert MODE_IN_COMMUNICATION via AudioManagerUtil, undoing the
+     * MODE_NORMAL restore in [stop]. Audio-thread confined.
+     */
+    private var routingStopped = false
+
+    /** Keeps MODE_IN_COMMUNICATION owned for the whole Communicator call on Android 11+. */
+    private val communicationModeKeepAlive: CommunicationModeKeepAlive =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            SilentPlaybackKeepAlive(mReactContext)
+        } else {
+            NoCommunicationModeKeepAlive
+        }
+
     val bluetoothManager = BluetoothManager(mReactContext, this)
 
     private val proximityManager by lazy { ProximityManager(mReactContext, this) }
@@ -130,53 +154,64 @@ class AudioDeviceManager(
         audioFocusUtil.setup(callAudioRole, mReactContext)
     }
 
+    /** Runs inline; callers must already be on the audio thread (see [runInAudioThread]). */
     fun start(activity: Activity) {
-        runInAudioThread {
-            setup()
-            selectedAudioDeviceEndpoint = null
-            if (callAudioRole == CallAudioRole.Communicator) {
-                // Audio routing is manually controlled by the SDK in communication media mode
-                // and local microphone can be published
-                activity.volumeControlStream = AudioManager.STREAM_VOICE_CALL
-                if (!telecomManagedMode) {
-                    // Telecom owns routing/focus; only run our own routing when not Telecom-managed.
-                    bluetoothManager.start()
-                    mAudioManager.registerAudioDeviceCallback(this, null)
-                    updateAudioDeviceState()
-                }
-                proximityManager.start()
-            } else {
-                activity.volumeControlStream = AudioManager.USE_DEFAULT_STREAM_TYPE
-            }
+        routingStopped = false
+        setup()
+        selectedAudioDeviceEndpoint = null
+        if (callAudioRole == CallAudioRole.Communicator) {
+            // Audio routing is manually controlled by the SDK in communication media mode
+            // and local microphone can be published
+            activity.volumeControlStream = AudioManager.STREAM_VOICE_CALL
             if (!telecomManagedMode) {
-                audioFocusUtil.requestFocus(callAudioRole, mReactContext)
+                // Telecom owns routing/focus; only run our own routing when not Telecom-managed.
+                bluetoothManager.start()
+                mAudioManager.registerAudioDeviceCallback(this, null)
+                updateAudioDeviceState()
             }
+            proximityManager.start()
+        } else {
+            activity.volumeControlStream = AudioManager.USE_DEFAULT_STREAM_TYPE
+        }
+        if (!telecomManagedMode) {
+            audioFocusUtil.requestFocus(callAudioRole, mReactContext)
+        }
+        // Started last, after focus/routing, so the silent track uses the correct route.
+        if (callAudioRole == CallAudioRole.Communicator &&
+            !telecomManagedMode &&
+            !disableCommunicationModeWorkaround
+        ) {
+            communicationModeKeepAlive.start()
         }
     }
 
-    fun stop(activity: Activity) {
-        runInAudioThread {
-            if (callAudioRole == CallAudioRole.Communicator) {
-                if (!telecomManagedMode) {
-                    // Only tear down what we set up ourselves; Telecom owns its own teardown.
-                    if (Build.VERSION.SDK_INT >= 31) {
-                        mAudioManager.clearCommunicationDevice()
-                    } else {
-                        mAudioManager.setSpeakerphoneOn(false)
-                    }
-                    bluetoothManager.stop()
-                }
-                callAudioRole = CallAudioRole.Communicator
-                enableStereo = false
-                defaultAudioDevice = AudioDeviceEndpoint.TYPE_SPEAKER
-                proximityManager.stop()
-            }
-            activity.volumeControlStream = AudioManager.USE_DEFAULT_STREAM_TYPE
+    /** Runs inline; callers must already be on the audio thread (see [runInAudioThread]). */
+    fun stop(activity: Activity?) {
+        routingStopped = true
+        communicationModeKeepAlive.stop()
+        if (callAudioRole == CallAudioRole.Communicator) {
             if (!telecomManagedMode) {
-                audioFocusUtil.abandonFocus()
+                // Only tear down what we set up ourselves; Telecom owns its own teardown.
+                if (Build.VERSION.SDK_INT >= 31) {
+                    mAudioManager.clearCommunicationDevice()
+                } else {
+                    mAudioManager.setSpeakerphoneOn(false)
+                }
+                bluetoothManager.stop()
+                // Restore the mode set in setup(); it was previously left at
+                // MODE_IN_COMMUNICATION, holding the device in in-call routing.
+                mAudioManager.mode = AudioManager.MODE_NORMAL
             }
-            telecomManagedMode = false
+            callAudioRole = CallAudioRole.Communicator
+            enableStereo = false
+            defaultAudioDevice = AudioDeviceEndpoint.TYPE_SPEAKER
+            proximityManager.stop()
         }
+        activity?.volumeControlStream = AudioManager.USE_DEFAULT_STREAM_TYPE
+        if (!telecomManagedMode) {
+            audioFocusUtil.abandonFocus()
+        }
+        telecomManagedMode = false
     }
 
     fun setMicrophoneMute(enable: Boolean) {
@@ -228,6 +263,9 @@ class AudioDeviceManager(
     }
 
     private fun switchDeviceEndpointType(@EndpointType deviceType: Int) {
+        // Sole sink for routing changes, and AudioManagerUtil re-asserts MODE_IN_COMMUNICATION
+        // here — so late work of any origin must not reach it after teardown.
+        if (routingStopped) return
         val newDevice = AudioManagerUtil.switchDeviceEndpointType(
             deviceType,
             mEndpointMaps,
@@ -237,38 +275,49 @@ class AudioDeviceManager(
         this.selectedAudioDeviceEndpoint = newDevice
     }
 
+    /** Runs inline; callers must already be on the audio thread (see [runInAudioThread]). */
     fun switchDeviceById(
         deviceId: String
     ) {
         Log.d(TAG, "switchDeviceById: deviceId = $deviceId")
-        runInAudioThread {
-            val btDevice = mEndpointMaps.bluetoothEndpoints[deviceId]
-            if (btDevice != null) {
-                if (Build.VERSION.SDK_INT >= 31) {
-                    mAudioManager.setCommunicationDevice(btDevice.deviceInfo)
-                    bluetoothManager.updateDevice()
-                    this.selectedAudioDeviceEndpoint = btDevice
-                } else {
-                    switchDeviceEndpointType(
-                        AudioDeviceEndpoint.TYPE_BLUETOOTH
-                    )
-                }
+        // Guarded here too: the branch below sets the communication device directly rather
+        // than going through switchDeviceEndpointType().
+        if (routingStopped) return
+        val btDevice = mEndpointMaps.bluetoothEndpoints[deviceId]
+        if (btDevice != null) {
+            if (Build.VERSION.SDK_INT >= 31) {
+                mAudioManager.setCommunicationDevice(btDevice.deviceInfo)
+                bluetoothManager.updateDevice()
+                this.selectedAudioDeviceEndpoint = btDevice
             } else {
-                val endpoint = nonBluetoothEndpointById(deviceId)
-                if (endpoint != null) {
-                    switchDeviceEndpointType(endpoint.type)
-                } else {
-                    Log.e(TAG, "switchDeviceById: no endpoint found for id $deviceId")
-                }
+                switchDeviceEndpointType(
+                    AudioDeviceEndpoint.TYPE_BLUETOOTH
+                )
+            }
+        } else {
+            val endpoint = nonBluetoothEndpointById(deviceId)
+            if (endpoint != null) {
+                switchDeviceEndpointType(endpoint.type)
+            } else {
+                Log.e(TAG, "switchDeviceById: no endpoint found for id $deviceId")
             }
         }
     }
 
     override fun close() {
-        mAudioManager.unregisterAudioDeviceCallback(this)
-        proximityManager.onDestroy()
+        // Unlike start()/stop(), this is called straight from the module, so it must be queued
+        // to land after any start/stop already pending on the audio thread.
+        runInAudioThread {
+            routingStopped = true
+            communicationModeKeepAlive.release()
+            mAudioManager.unregisterAudioDeviceCallback(this)
+            proximityManager.onDestroy()
+        }
     }
 
+    /** Short description of the keep-alive state, for the audio debug log. */
+    fun communicationModeKeepAliveState(): String = communicationModeKeepAlive.describeState()
+
     override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>?) {
         if (addedDevices != null) {
             runInAudioThread {
@@ -423,6 +472,9 @@ class AudioDeviceManager(
      */
     fun updateAudioDeviceState() {
         runInAudioThread {
+            // Bail early: on API < 31 bluetoothState survives stop(), so a late pass could
+            // still start SCO after the call ended.
+            if (routingStopped) return@runInAudioThread
             if (telecomManagedMode) {
                 // Telecom is the single source of truth for routing/endpoints in this mode.
                 return@runInAudioThread

package/android/src/main/java/com/streamvideo/reactnative/audio/CommunicationModeKeepAlive.kt

@@ -0,0 +1,247 @@
+package com.streamvideo.reactnative.audio
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.Context.AUDIO_SERVICE
+import android.media.AudioAttributes
+import android.media.AudioFormat
+import android.media.AudioManager
+import android.media.AudioTrack
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import com.streamvideo.reactnative.callmanager.StreamInCallManagerModule
+import java.nio.ByteBuffer
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.TimeUnit
+
+/**
+ * Holds the audio system in [AudioManager.MODE_IN_COMMUNICATION] for the duration
+ * of a communicator-role call.
+ *
+ * Why this is needed: from Android 11 (API 30) the platform demotes the
+ * audio mode back to `MODE_NORMAL` about six seconds after `setMode()` unless the
+ * call is actively playing or recording on the voice-communication path.
+ * During a call whose microphone is muted and that has no inbound audio yet,
+ * neither condition is met, so routing silently falls back to the media path and
+ * hardware echo cancellation is switched off.
+ * Details: https://issuetracker.google.com/issues/209493718
+ *
+ * We satisfy the "actively playing" condition by continuously looping an inaudible
+ * audo track on the voice-communication stream, which keeps the platform counting us
+ * as an active player and therefore keeps the mode in place.
+ */
+interface CommunicationModeKeepAlive {
+    /** Begin holding the communication mode. Idempotent. */
+    fun start()
+
+    /** Stop holding the communication mode. Idempotent; the instance can be started again. */
+    fun stop()
+
+    /** Permanently release all resources. The instance must not be used afterwards. */
+    fun release()
+
+    /** Short human-readable state, surfaced in the audio-state debug log. */
+    fun describeState(): String
+}
+
+/** No-op variant used on platforms where the mode reset does not occur (Android API < 30). */
+object NoCommunicationModeKeepAlive : CommunicationModeKeepAlive {
+    override fun start() {}
+    override fun stop() {}
+    override fun release() {}
+    override fun describeState(): String = "disabled (android platform API < 30)"
+}
+
+/**
+ * Default implementation backed by a silent, looping voice-communication
+ * [AudioTrack]. If the silent player cannot be created on a given device, it
+ * degrades to a lightweight poller that re-applies the mode whenever the platform
+ * has reset it.
+ *
+ * All lifecycle transitions and every access to [track] are serialized on [gate],
+ * so a play/pause can never overlap a release. The poller only ever touches the
+ * audio mode (never the track), so it runs lock-free.
+ *
+ * @suppress
+ */
+@RequiresApi(Build.VERSION_CODES.R)
+internal class SilentPlaybackKeepAlive(
+    private val context: Context,
+) : CommunicationModeKeepAlive {
+
+    private val gate = Any()
+
+    private var track: AudioTrack? = null
+
+    /** Whether we currently intend the silent player to be running. */
+    private var engaged = false
+
+    /** Read by the poller (off-gate) to drop ticks that were queued before we stopped. */
+    @Volatile
+    private var live = false
+
+    private var modePoller: ScheduledExecutorService? = null
+
+    override fun start(): Unit = synchronized(gate) {
+        live = true
+        if (engaged) return
+        engaged = true
+
+        val player = track ?: createSilentTrack()?.also { track = it }
+        if (player != null && player.state == AudioTrack.STATE_INITIALIZED && play(player)) {
+            return
+        }
+        // No usable silent player on this device — fall back to reactive repair.
+        player?.release()
+        track = null
+        startModePoller()
+    }
+
+    /**
+     * Starts playback, reporting whether the track actually entered the playing state.
+     * `play()` can throw or leave the track stopped even from STATE_INITIALIZED; treating
+     * that as success would strand the keep-alive with neither a track nor the poller.
+     */
+    private fun play(player: AudioTrack): Boolean =
+        try {
+            player.play()
+            player.playState == AudioTrack.PLAYSTATE_PLAYING
+        } catch (e: IllegalStateException) {
+            Log.w(TAG, "Silent keep-alive track refused to start.", e)
+            false
+        }
+
+    override fun stop() = synchronized(gate) {
+        live = false
+        if (engaged) {
+            engaged = false
+            track?.takeIf { it.state == AudioTrack.STATE_INITIALIZED }?.pause()
+        }
+        stopModePoller()
+    }
+
+    override fun release() = synchronized(gate) {
+        live = false
+        engaged = false
+        stopModePoller()
+        track?.let {
+            if (it.state == AudioTrack.STATE_INITIALIZED) it.pause()
+            it.release()
+        }
+        track = null
+    }
+
+    override fun describeState(): String = synchronized(gate) {
+        val playing = track?.playState == AudioTrack.PLAYSTATE_PLAYING
+        "enabled, engaged=$engaged, built=${track != null}, playing=$playing, " +
+            "modePoller=${modePoller != null}"
+    }
+
+    @SuppressLint("Range")
+    private fun createSilentTrack(): AudioTrack? {
+        return try {
+            val audioManager = context.getSystemService(AUDIO_SERVICE) as AudioManager
+            val sampleRate = positiveOrDefault(
+                audioManager.getProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE)?.toIntOrNull(),
+                DEFAULT_SAMPLE_RATE,
+            )
+            // One buffer worth of frames is enough — we loop it forever.
+            val frameCount = positiveOrDefault(
+                audioManager.getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER)
+                    ?.toIntOrNull(),
+                sampleRate / 100, // ~10 ms
+            )
+            val bufferBytes = frameCount * BYTES_PER_FRAME
+            // A freshly allocated direct buffer is zero-filled, i.e. pure silence.
+            val silence = ByteBuffer.allocateDirect(bufferBytes)
+
+            val player = AudioTrack.Builder()
+                .setAudioAttributes(
+                    AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                        .build(),
+                )
+                .setAudioFormat(
+                    AudioFormat.Builder()
+                        .setEncoding(ENCODING)
+                        .setSampleRate(sampleRate)
+                        .setChannelMask(AudioFormat.CHANNEL_OUT_MONO)
+                        .build(),
+                )
+                .setBufferSizeInBytes(bufferBytes)
+                .setTransferMode(AudioTrack.MODE_STATIC)
+                .setSessionId(AudioManager.AUDIO_SESSION_ID_GENERATE)
+                .build()
+
+            val written = player.write(silence, silence.remaining(), AudioTrack.WRITE_BLOCKING)
+            val loopResult = player.setLoopPoints(0, frameCount - 1, -1)
+            val ready = player.state == AudioTrack.STATE_INITIALIZED &&
+                written >= 0 &&
+                loopResult == AudioTrack.SUCCESS
+            if (ready) {
+                player
+            } else {
+                Log.w(
+                    TAG,
+                    "Silent keep-alive track not usable " +
+                        "(state=${player.state}, written=$written, loop=$loopResult); discarding.",
+                )
+                player.release()
+                null
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not create silent keep-alive track.", e)
+            null
+        }
+    }
+
+    private fun startModePoller() {
+        if (modePoller != null) return
+        modePoller = Executors.newSingleThreadScheduledExecutor().also { poller ->
+            poller.scheduleWithFixedDelay(
+                ::reapplyModeIfReset,
+                MODE_POLL_INTERVAL_MS,
+                MODE_POLL_INTERVAL_MS,
+                TimeUnit.MILLISECONDS,
+            )
+        }
+    }
+
+    private fun reapplyModeIfReset() {
+        // Read/write the mode on the shared audio thread so it can't race routing changes.
+        AudioDeviceManager.runInAudioThread {
+            if (!live) return@runInAudioThread
+            val audioManager = context.getSystemService(AUDIO_SERVICE) as AudioManager
+            if (audioManager.mode != AudioManager.MODE_IN_COMMUNICATION) {
+                Log.d(TAG, "Re-applying MODE_IN_COMMUNICATION after a platform reset.")
+                audioManager.mode = AudioManager.MODE_IN_COMMUNICATION
+            }
+        }
+    }
+
+    private fun stopModePoller() {
+        modePoller?.shutdownNow()
+        modePoller = null
+    }
+
+    private fun positiveOrDefault(value: Int?, default: Int): Int =
+        if (value != null && value > 0) value else default
+
+    companion object {
+        private const val TAG = StreamInCallManagerModule.TAG
+        private const val DEFAULT_SAMPLE_RATE = 16000
+        private const val ENCODING = AudioFormat.ENCODING_PCM_16BIT
+
+        // We always emit mono 16-bit PCM, so a frame is exactly 2 bytes.
+        private const val BYTES_PER_FRAME = 2
+
+        // Fallback poll cadence. Deliberately shorter than AOSP's ~6s reset window: the
+        // interval bounds only the worst-case wrong-routing gap (<= interval), while the
+        // real setMode/HAL transition rate stays governed by the OS re-arm, so polling
+        // faster only costs cheap reads and shortens the recovery latency.
+        private const val MODE_POLL_INTERVAL_MS = 2000L
+    }
+}

package/android/src/main/java/com/streamvideo/reactnative/callmanager/StreamInCallManagerModule.kt

@@ -75,6 +75,18 @@ class StreamInCallManagerModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun setDisableCommunicationModeWorkaround(disabled: Boolean) {
+        AudioDeviceManager.runInAudioThread {
+            if (audioManagerActivated) {
+                Log.e(TAG, "setDisableCommunicationModeWorkaround(): AudioManager is already activated and so it cannot be changed")
+                return@runInAudioThread
+            }
+            Log.d(TAG, "setDisableCommunicationModeWorkaround(): $disabled")
+            mAudioDeviceManager.disableCommunicationModeWorkaround = disabled
+        }
+    }
+
     @ReactMethod
     fun setDefaultAudioDeviceEndpointType(endpointDeviceTypeName: String) {
         AudioDeviceManager.runInAudioThread {
@@ -129,10 +141,8 @@ class StreamInCallManagerModule(reactContext: ReactApplicationContext) :
         AudioDeviceManager.runInAudioThread {
             if (audioManagerActivated) {
                 Log.d(TAG, "stop() mAudioDeviceManager")
-                reactApplicationContext.currentActivity?.let {
-                    mAudioDeviceManager.stop(it)
-                    audioManagerActivated = false
-                }
+                mAudioDeviceManager.stop(reactApplicationContext.currentActivity)
+                audioManagerActivated = false
                 setMicrophoneMute(false)
                 setKeepScreenOn(false)
             }
@@ -185,7 +195,8 @@ class StreamInCallManagerModule(reactContext: ReactApplicationContext) :
 
     @ReactMethod(isBlockingSynchronousMethod = true)
     fun getAudioStateLog(): String {
-        return WebRtcAudioUtils.getAudioStateLog(reactApplicationContext)
+        return WebRtcAudioUtils.getAudioStateLog(reactApplicationContext) +
+            "Communication mode keep-alive: ${mAudioDeviceManager.communicationModeKeepAliveState()}\n"
     }
 
     @Suppress("unused")