@stream-io/video-react-native-sdk 2.0.0-beta.0 → 2.0.0-beta.2

package/CHANGELOG.md

@@ -2,6 +2,101 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [2.0.0-beta.2](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-react-native-sdk-2.0.0-beta.1...@stream-io/video-react-native-sdk-2.0.0-beta.2) (2026-09-28)
+
+### ⚠ BREAKING CHANGES
+
+- **react-native:** Requires React Native >=0.79.0 with the New
+  Architecture enabled. RN 0.79 provides the iOS module-provider
+  registration used by this implementation.
+
+### 📝 Implementation notes.
+
+### 1. Migration to React Native New Architecture and TurboModules
+
+- Updated documentation in `README.md` to specify that the package now
+  requires React Native 0.79+ with the New Architecture enabled, and only
+  supports TurboModule registration.
+- Refactored Android native module to use the TurboModule codegen
+  pattern, removing legacy code and simplifying the module/package
+  classes.
+- Refactored iOS implementation to use a new Objective-C host
+  (`NoiseCancellationReactNative.h`/`.mm`) delegating to a Swift
+  implementation, fully adopting the TurboModule spec and removing legacy
+  bridging code.
+
+### 2. Android build system modernization
+
+- Updated `build.gradle` to use AGP 8.7.2, Kotlin 2.0.21, Java 17, and
+  simplified/extensively cleaned up build logic, removing legacy property
+  indirection and supporting only the new namespace system.
+- Removed obsolete manifest files and properties.
+
+### 3. iOS native module refactoring
+
+- Removed old Swift implementation and replaced it with a new
+  implementation in `NoiseCancellationReactNativeImpl.swift`, with the
+  Objective-C wrapper delegating all logic to this class and conforming to
+  the TurboModule interface.
+
+### 4. JavaScript/TypeScript and testing improvements
+
+- Added contract tests (`__tests__/native-module.test.cjs`) to verify
+  the JS interface against a stubbed TurboModule registry, ensuring
+  correct JS-native interaction and error propagation.
+- Added a `test` script to `package.json` for running these contract
+  tests.
+
+🎫 Ticket: https://linear.app/stream/issue/XYZ-123
+
+📑 Docs: https://github.com/GetStream/docs-content/pull/<id>
+
+<!-- This is an auto-generated comment: release notes by coderabbit.ai
+-->
+
+## Summary by CodeRabbit
+
+- **New Features**
+- Noise-cancellation controls now provide synchronous status,
+  enablement, and device-support checks.
+- The React Native integration now supports the New Architecture through
+  TurboModules.
+- Noise-cancellation state and errors are handled more reliably in the
+  provider.
+
+- **Bug Fixes**
+- Checking whether noise cancellation is enabled before registration now
+  returns `false` instead of failing.
+
+- **Documentation**
+- Added setup requirements, native installation guidance, synchronous
+  API usage notes, and peer dependency information.
+- Updated SDK installation guidance to require React Native 0.79+ with
+  the New Architecture enabled.
+
+<!-- end of auto-generated comment: release notes by coderabbit.ai -->
+
+- **i18n:** adopt the shared @stream-io/i18n runtime (#2436)
+
+### Features
+
+- **i18n:** adopt the shared @stream-io/i18n runtime ([#2436](https://github.com/GetStream/stream-video-js/issues/2436)) ([2fcd426](https://github.com/GetStream/stream-video-js/commit/2fcd4269227d5db8f46342c597d17f2c7d835f88)), closes [stream-chat-react#3261](https://github.com/GetStream/stream-chat-react/issues/3261)
+- **react-native:** Migrate noise cancellation module to TurboModule architecture ([#2447](https://github.com/GetStream/stream-video-js/issues/2447)) ([2842986](https://github.com/GetStream/stream-video-js/commit/2842986f6d3adeef8617af243fa11a3076aae4b2))
+- **rn:** add end-to-end encryption support ([#2427](https://github.com/GetStream/stream-video-js/issues/2427)) ([fd70b35](https://github.com/GetStream/stream-video-js/commit/fd70b3597beb5867b21f254c76fd6d4e6e2e731b))
+
+### Bug Fixes
+
+- **android:** skip explicit Kotlin plugin when AGP registers the kotlin extension ([#2417](https://github.com/GetStream/stream-video-js/issues/2417)) ([1bff5e0](https://github.com/GetStream/stream-video-js/commit/1bff5e0f5b4a2f2bbe62ab5eff2a6457251f6350)), closes [RevenueCat/react-native-purchases#1934](https://github.com/RevenueCat/react-native-purchases/issues/1934)
+- **react-native-callingx:** use <packageName>:<callId> as the Android Telecom address ([#2453](https://github.com/GetStream/stream-video-js/issues/2453)) ([22d18d8](https://github.com/GetStream/stream-video-js/commit/22d18d8b55bab81946989d791b5fa18569428712)), closes [#2452](https://github.com/GetStream/stream-video-js/issues/2452) [#2452](https://github.com/GetStream/stream-video-js/issues/2452)
+- **react-native:** iOS Picture in Picture window size must be reported ([#2448](https://github.com/GetStream/stream-video-js/issues/2448)) ([b7e4165](https://github.com/GetStream/stream-video-js/commit/b7e4165113ad3277d2b32fab690ecef81b582b4a))
+- replaced RTCView with camera preview for outgoing call component ([#2450](https://github.com/GetStream/stream-video-js/issues/2450)) ([e8e360b](https://github.com/GetStream/stream-video-js/commit/e8e360b559309267177a64df58385bb67b8a90da))
+
+## [2.0.0-beta.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-react-native-sdk-2.0.0-beta.0...@stream-io/video-react-native-sdk-2.0.0-beta.1) (2026-09-04)
+
+### Bug Fixes
+
+- **react-native-sdk:** publish the corrected satellite peer ranges ([15172ec](https://github.com/GetStream/stream-video-js/commit/15172ec5a2e96ec7ad62c83be631776a9f315485)), closes [#2414](https://github.com/GetStream/stream-video-js/issues/2414)
+
 ## [2.0.0-beta.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-react-native-sdk-1.45.0...@stream-io/video-react-native-sdk-2.0.0-beta.0) (2026-09-04)
 
 ### Bug Fixes

package/README.md

@@ -79,6 +79,21 @@ The monorepo consists of multiple folders, the most important of which are `pack
 Before running this project please ensure you have set up your [development environment for React Native](https://reactnative.dev/docs/environment-setup).
 The Stream Video React Native SDK supports apps created with the React Native CLI.
 
+### Optional native add-ons
+
+Noise cancellation, video filters and CallKit/Telecom ringing ship as separate
+optional peer packages. On the `2.0.0-beta` line they are published on their own
+`1.0.0-beta` line under the `beta` npm tag, so install them from that tag:
+
+```sh
+yarn add @stream-io/noise-cancellation-react-native@beta # requires React Native >= 0.79 with the New Architecture enabled
+yarn add @stream-io/video-filters-react-native@beta
+yarn add @stream-io/react-native-callingx@beta
+```
+
+Installing the `latest` builds of these packages alongside the v2 beta pulls the
+v1 line and will report an unmet peer dependency.
+
 ## **Contributing** 🤝
 
 - How can I submit a sample app?

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")

package/dist/commonjs/components/Call/CallContent/CallContent.js

@@ -164,7 +164,7 @@ const CallContent = ({
     supportedReactions
   };
   return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
-    children: [!disablePictureInPicture && /*#__PURE__*/(0, _jsxRuntime.jsx)(_RTCViewPipIOS.RTCViewPipIOS, {
+    children: [_reactNative.Platform.OS === 'ios' && !disablePictureInPicture && /*#__PURE__*/(0, _jsxRuntime.jsx)(_RTCViewPipIOS.RTCViewPipIOS, {
       includeLocalParticipantVideo: iOSPiPIncludeLocalParticipantVideo,
       mirror: mirror
     }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {