@stream-io/video-react-native-sdk 1.44.0 → 1.45.1

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [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`
+  - **client:** isolate coordinator event listener errors from the dispatch loop ([#2404](https://github.com/GetStream/stream-video-js/issues/2404)) ([4ab49de](https://github.com/GetStream/stream-video-js/commit/4ab49decc4bbc70b0fc35d6b92f2bd18922a105c)), closes [GetStream/stream-chat-js#1850](https://github.com/GetStream/stream-chat-js/issues/1850)
+  - **client:** keep passive participants out of the spotlight ([#2405](https://github.com/GetStream/stream-video-js/issues/2405)) ([0713650](https://github.com/GetStream/stream-video-js/commit/0713650fa90caa8a82ce0bee75acf4dbaaad33e9))
+- `@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`
+- `@stream-io/video-react-bindings` updated to version `1.20.1`
+
+### Features
+
+- handle ring notification internally ([#2380](https://github.com/GetStream/stream-video-js/issues/2380)) ([0259217](https://github.com/GetStream/stream-video-js/commit/0259217ea2df613483bee5918ca2f93a68b6c3b9))
+- **react-sdk:** pre-call testing ([#2370](https://github.com/GetStream/stream-video-js/issues/2370)) ([3f4b62a](https://github.com/GetStream/stream-video-js/commit/3f4b62ab379d9d4203bc64b5d5e3658fba389efd))
+
+### Bug Fixes
+
+- do not allow empty android call display names ([#2392](https://github.com/GetStream/stream-video-js/issues/2392)) ([2ef3065](https://github.com/GetStream/stream-video-js/commit/2ef3065038fc293d0e2c96d2cc26feaf317e7b2d))
+- fixed ringing calls mute issue ([#2385](https://github.com/GetStream/stream-video-js/issues/2385)) ([b3bcdad](https://github.com/GetStream/stream-video-js/commit/b3bcdadc9f9f4eedf7dabde101b96e44863dcc64))
+
 ## [1.44.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-react-native-sdk-1.43.0...@stream-io/video-react-native-sdk-1.44.0) (2026-08-18)
 
 ### Dependency Updates
@@ -10,9 +45,6 @@ This file was generated using [@jscutlery/semver](https://github.com/jscutlery/s
 - `@stream-io/react-native-callingx` updated to version `0.10.0`
 - `@stream-io/video-filters-react-native` updated to version `0.16.0`
 - `@stream-io/video-client` updated to version `1.58.0`
-  - **client:** E2EE framing-version detection and event renames ([#2366](https://github.com/GetStream/stream-video-js/issues/2366)) ([050aebf](https://github.com/GetStream/stream-video-js/commit/050aebf6efea84089bee6ded5e62ba02ecc22716))
-  - **client:** granular E2EE key removal ([#2368](https://github.com/GetStream/stream-video-js/issues/2368)) ([8f52b9a](https://github.com/GetStream/stream-video-js/commit/8f52b9a6ff9b87382dcd5ebd7414388153be8a13)), closes [#2366](https://github.com/GetStream/stream-video-js/issues/2366)
-  - **client:** only deselect the speaker device on a real disconnect ([#2375](https://github.com/GetStream/stream-video-js/issues/2375)) ([d7f780d](https://github.com/GetStream/stream-video-js/commit/d7f780d0924471adfe9ba85accf42e889b01e20b))
 - `@stream-io/video-react-bindings` updated to version `1.20.0`
 
 ### Features

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