@stream-io/video-react-native-sdk 1.21.2 → 1.22.1-alpha.0

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

@@ -0,0 +1,250 @@
+/*
+ *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+package com.streamvideo.reactnative.audio.utils
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.media.AudioDeviceInfo
+import android.media.AudioFormat
+import android.media.AudioManager
+import android.media.MediaRecorder
+import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.ReactContext
+
+/** Utilities for implementations of `AudioDeviceModule`, mostly for logging.  */
+object WebRtcAudioUtils {
+    /** Helper method for building a string of thread information.  */
+    fun threadInfo(): String {
+            val current = Thread.currentThread()
+            return "@[name=" + current.name + ", id=" + current.id + "]"
+    }
+
+    /** Returns true if we're running on emulator.  */
+    fun runningOnEmulator(): Boolean {
+        // Hardware type of qemu1 is goldfish and qemu2 is ranchu.
+        return Build.HARDWARE == "goldfish" || Build.HARDWARE == "ranchu"
+    }
+
+    /** Information about the current build, taken from system properties.  */
+    private fun logDeviceInfo(tag: String) {
+        Log.d(
+            tag,
+            (("Android SDK: " + Build.VERSION.SDK_INT)
+                    + (", Release: " + Build.VERSION.RELEASE)
+                    + (", Brand: " + Build.BRAND)
+                    + (", Device: " + Build.DEVICE)
+                    + (", Id: " + Build.ID)
+                    + (", Hardware: " + Build.HARDWARE)
+                    + (", Manufacturer: " + Build.MANUFACTURER)
+                    + (", Model: " + Build.MODEL)
+                    + (", Product: " + Build.PRODUCT))
+        )
+    }
+
+    /**
+     * Logs information about the current audio state. The idea is to call this method when errors are
+     * detected to log under what conditions the error occurred. Hopefully it will provide clues to
+     * what might be the root cause.
+     */
+    fun logAudioState(tag: String, reactContext: ReactContext) {
+        reactContext.currentActivity?.let {
+            Log.d(tag, "volumeControlStream: " + streamTypeToString(it.volumeControlStream))
+        }
+        val audioManager = reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        logDeviceInfo(tag)
+        logAudioStateBasic(tag, reactContext, audioManager)
+        logAudioStateVolume(tag, audioManager)
+        logAudioDeviceInfo(tag, audioManager)
+    }
+
+    /** Converts AudioDeviceInfo types to local string representation.  */
+    private fun deviceTypeToString(type: Int): String {
+        return when (type) {
+            AudioDeviceInfo.TYPE_AUX_LINE -> "TYPE_AUX_LINE"
+            AudioDeviceInfo.TYPE_BLE_BROADCAST -> "TYPE_BLE_BROADCAST"
+            AudioDeviceInfo.TYPE_BLE_HEADSET -> "TYPE_BLE_HEADSET"
+            AudioDeviceInfo.TYPE_BLE_SPEAKER -> "TYPE_BLE_SPEAKER"
+            AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> "TYPE_BLUETOOTH_A2DP"
+            AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> "TYPE_BLUETOOTH_SCO"
+            AudioDeviceInfo.TYPE_BUILTIN_EARPIECE -> "TYPE_BUILTIN_EARPIECE"
+            AudioDeviceInfo.TYPE_BUILTIN_MIC -> "TYPE_BUILTIN_MIC"
+            AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> "TYPE_BUILTIN_SPEAKER"
+            AudioDeviceInfo.TYPE_BUILTIN_SPEAKER_SAFE -> "TYPE_BUILTIN_SPEAKER_SAFE"
+            AudioDeviceInfo.TYPE_BUS -> "TYPE_BUS"
+            AudioDeviceInfo.TYPE_DOCK -> "TYPE_DOCK"
+            AudioDeviceInfo.TYPE_DOCK_ANALOG -> "TYPE_DOCK_ANALOG"
+            AudioDeviceInfo.TYPE_FM -> "TYPE_FM"
+            AudioDeviceInfo.TYPE_FM_TUNER -> "TYPE_FM_TUNER"
+            AudioDeviceInfo.TYPE_HDMI -> "TYPE_HDMI"
+            AudioDeviceInfo.TYPE_HDMI_ARC -> "TYPE_HDMI_ARC"
+            AudioDeviceInfo.TYPE_HDMI_EARC -> "TYPE_HDMI_EARC"
+            AudioDeviceInfo.TYPE_HEARING_AID -> "TYPE_HEARING_AID"
+            AudioDeviceInfo.TYPE_IP -> "TYPE_IP"
+            AudioDeviceInfo.TYPE_LINE_ANALOG -> "TYPE_LINE_ANALOG"
+            AudioDeviceInfo.TYPE_LINE_DIGITAL -> "TYPE_LINE_DIGITAL"
+            AudioDeviceInfo.TYPE_REMOTE_SUBMIX -> "TYPE_REMOTE_SUBMIX"
+            AudioDeviceInfo.TYPE_TELEPHONY -> "TYPE_TELEPHONY"
+            AudioDeviceInfo.TYPE_TV_TUNER -> "TYPE_TV_TUNER"
+            AudioDeviceInfo.TYPE_UNKNOWN -> "TYPE_UNKNOWN"
+            AudioDeviceInfo.TYPE_USB_ACCESSORY -> "TYPE_USB_ACCESSORY"
+            AudioDeviceInfo.TYPE_USB_DEVICE -> "TYPE_USB_DEVICE"
+            AudioDeviceInfo.TYPE_USB_HEADSET -> "TYPE_USB_HEADSET"
+            AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> "TYPE_WIRED_HEADPHONES"
+            AudioDeviceInfo.TYPE_WIRED_HEADSET -> "TYPE_WIRED_HEADSET"
+            else -> "TYPE_UNKNOWN($type)"
+        }
+    }
+
+    fun audioSourceToString(source: Int): String {
+        return when (source) {
+            MediaRecorder.AudioSource.DEFAULT -> "DEFAULT"
+            MediaRecorder.AudioSource.MIC -> "MIC"
+            MediaRecorder.AudioSource.VOICE_UPLINK -> "VOICE_UPLINK"
+            MediaRecorder.AudioSource.VOICE_DOWNLINK -> "VOICE_DOWNLINK"
+            MediaRecorder.AudioSource.VOICE_CALL -> "VOICE_CALL"
+            MediaRecorder.AudioSource.CAMCORDER -> "CAMCORDER"
+            MediaRecorder.AudioSource.VOICE_RECOGNITION -> "VOICE_RECOGNITION"
+            MediaRecorder.AudioSource.VOICE_COMMUNICATION -> "VOICE_COMMUNICATION"
+            MediaRecorder.AudioSource.UNPROCESSED -> "UNPROCESSED"
+            MediaRecorder.AudioSource.VOICE_PERFORMANCE -> "VOICE_PERFORMANCE"
+            else -> "INVALID"
+        }
+    }
+
+    fun channelMaskToString(mask: Int): String {
+        // For input or AudioRecord, the mask should be AudioFormat#CHANNEL_IN_MONO or
+        // AudioFormat#CHANNEL_IN_STEREO. AudioFormat#CHANNEL_IN_MONO is guaranteed to work on all
+        // devices.
+        return when (mask) {
+            AudioFormat.CHANNEL_IN_STEREO -> "IN_STEREO"
+            AudioFormat.CHANNEL_IN_MONO -> "IN_MONO"
+            else -> "INVALID"
+        }
+    }
+
+    fun audioEncodingToString(enc: Int): String {
+        return when (enc) {
+            AudioFormat.ENCODING_INVALID -> "INVALID"
+            AudioFormat.ENCODING_PCM_16BIT -> "PCM_16BIT"
+            AudioFormat.ENCODING_PCM_8BIT -> "PCM_8BIT"
+            AudioFormat.ENCODING_PCM_FLOAT -> "PCM_FLOAT"
+            AudioFormat.ENCODING_AC3 -> "AC3"
+            AudioFormat.ENCODING_E_AC3 -> "AC3"
+            AudioFormat.ENCODING_DTS -> "DTS"
+            AudioFormat.ENCODING_DTS_HD -> "DTS_HD"
+            AudioFormat.ENCODING_MP3 -> "MP3"
+            else -> "Invalid encoding: $enc"
+        }
+    }
+
+    /** Reports basic audio statistics.  */
+    private fun logAudioStateBasic(tag: String, context: Context, audioManager: AudioManager) {
+        Log.d(
+            tag,
+            ("Audio State: "
+                    + ("audio mode: " + modeToString(audioManager.mode))
+                    + (", has mic: " + hasMicrophone(context))
+                    + (", mic muted: " + audioManager.isMicrophoneMute)
+                    + (", music active: " + audioManager.isMusicActive)
+                    + (", speakerphone: " + audioManager.isSpeakerphoneOn)
+                    + (", BT SCO: " + audioManager.isBluetoothScoOn))
+        )
+    }
+
+    /** Adds volume information for all possible stream types.  */
+    private fun  logAudioStateVolume(tag: String, audioManager: AudioManager) {
+        val streams = intArrayOf(
+            AudioManager.STREAM_VOICE_CALL,
+            AudioManager.STREAM_MUSIC,
+            AudioManager.STREAM_RING,
+            AudioManager.STREAM_ALARM,
+            AudioManager.STREAM_NOTIFICATION,
+            AudioManager.STREAM_SYSTEM
+        )
+        Log.d(tag, "Audio State: ")
+        // Some devices may not have volume controls and might use a fixed volume.
+        val fixedVolume = audioManager.isVolumeFixed
+        Log.d(tag, "  fixed volume=$fixedVolume")
+        if (!fixedVolume) {
+            for (stream in streams) {
+                val info = StringBuilder()
+                info.append("  " + streamTypeToString(stream) + ": ")
+                info.append("volume=").append(audioManager.getStreamVolume(stream))
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                    info.append(", min=").append(audioManager.getStreamMinVolume(stream))
+                }
+                info.append(", max=").append(audioManager.getStreamMaxVolume(stream))
+                info.append(", muted=").append(audioManager.isStreamMute(stream))
+                Log.d(tag, info.toString())
+            }
+        }
+    }
+
+    private fun logAudioDeviceInfo(tag: String, audioManager: AudioManager) {
+        val inputDevices = audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)
+        val outputDevices = audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS)
+        val devices = inputDevices + outputDevices
+        if (devices.isEmpty()) {
+            return
+        }
+        Log.d(tag, "Audio Devices: ")
+        for (device in devices) {
+            val info = StringBuilder()
+            info.append("  ").append(deviceTypeToString(device.type))
+            info.append(if (device.isSource) "(in): " else "(out): ")
+            // An empty array indicates that the device supports arbitrary channel counts.
+            if (device.channelCounts.size > 0) {
+                info.append("channels=").append(device.channelCounts.contentToString())
+                info.append(", ")
+            }
+            if (device.encodings.size > 0) {
+                // Examples: ENCODING_PCM_16BIT = 2, ENCODING_PCM_FLOAT = 4.
+                info.append("encodings=").append(device.encodings.contentToString())
+                info.append(", ")
+            }
+            if (device.sampleRates.size > 0) {
+                info.append("sample rates=").append(device.sampleRates.contentToString())
+                info.append(", ")
+            }
+            info.append("id=").append(device.id)
+            Log.d(tag, info.toString())
+        }
+    }
+
+    /** Converts media.AudioManager modes into local string representation.  */
+    fun modeToString(mode: Int): String {
+        return when (mode) {
+            AudioManager.MODE_IN_CALL -> "MODE_IN_CALL"
+            AudioManager.MODE_IN_COMMUNICATION -> "MODE_IN_COMMUNICATION"
+            AudioManager.MODE_NORMAL -> "MODE_NORMAL"
+            AudioManager.MODE_RINGTONE -> "MODE_RINGTONE"
+            else -> "MODE_INVALID"
+        }
+    }
+
+    private fun streamTypeToString(stream: Int): String {
+        return when (stream) {
+            AudioManager.STREAM_VOICE_CALL -> "STREAM_VOICE_CALL"
+            AudioManager.STREAM_MUSIC -> "STREAM_MUSIC"
+            AudioManager.STREAM_RING -> "STREAM_RING"
+            AudioManager.STREAM_ALARM -> "STREAM_ALARM"
+            AudioManager.STREAM_NOTIFICATION -> "STREAM_NOTIFICATION"
+            AudioManager.STREAM_SYSTEM -> "STREAM_SYSTEM"
+            else -> "STREAM_INVALID"
+        }
+    }
+
+    /** Returns true if the device can record audio via a microphone.  */
+    private fun hasMicrophone(context: Context): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_MICROPHONE)
+    }
+
+}

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

@@ -0,0 +1,191 @@
+package com.streamvideo.reactnative.callmanager
+
+import android.util.Log
+import android.view.WindowManager
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.UiThreadUtil
+import com.streamvideo.reactnative.audio.AudioDeviceManager
+import com.streamvideo.reactnative.audio.utils.CallAudioRole
+import com.streamvideo.reactnative.audio.utils.WebRtcAudioUtils
+import com.streamvideo.reactnative.model.AudioDeviceEndpoint
+import java.util.Locale
+
+
+class StreamInCallManagerModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
+
+    private var audioManagerActivated = false
+
+    private val mAudioDeviceManager = AudioDeviceManager(reactContext)
+
+
+    override fun getName(): String {
+        return TAG
+    }
+
+    init {
+        reactContext.addLifecycleEventListener(this)
+    }
+
+    // This method was removed upstream in react-native 0.74+, replaced with invalidate
+    // We will leave this stub here for older react-native versions compatibility
+    // ...but it will just delegate to the new invalidate method
+    @Deprecated("Deprecated in Java", ReplaceWith("invalidate()"))
+    @Suppress("removal")
+    override fun onCatalystInstanceDestroy() {
+        invalidate()
+    }
+
+    override fun invalidate() {
+        mAudioDeviceManager.close()
+        super.invalidate()
+    }
+
+    @ReactMethod
+    fun setAudioRole(audioRole: String) {
+        AudioDeviceManager.runInAudioThread {
+            if (audioManagerActivated) {
+                Log.e(TAG, "setAudioRole(): AudioManager is already activated and so Audio Role cannot be changed, current audio role is ${mAudioDeviceManager.callAudioRole}")
+                return@runInAudioThread
+            }
+            val role = audioRole.lowercase(Locale.getDefault())
+            Log.d(TAG, "setAudioRole(): $audioRole $role")
+            if (role == "listener") {
+                mAudioDeviceManager.callAudioRole = CallAudioRole.Listener
+            } else {
+                mAudioDeviceManager.callAudioRole = CallAudioRole.Communicator
+            }
+        }
+    }
+
+    @ReactMethod
+    fun setDefaultAudioDeviceEndpointType(endpointDeviceTypeName: String) {
+        AudioDeviceManager.runInAudioThread {
+            if (audioManagerActivated) {
+                Log.e(TAG, "setAudioRole(): AudioManager is already activated and so default audio device cannot be changed, current audio default device is ${mAudioDeviceManager.defaultAudioDevice}")
+                return@runInAudioThread
+            }
+            val endpointType = endpointDeviceTypeName.lowercase(Locale.getDefault())
+            Log.d(TAG, "runInAudioThread(): $endpointDeviceTypeName $endpointType")
+            if (endpointType == "earpiece") {
+                mAudioDeviceManager.defaultAudioDevice = AudioDeviceEndpoint.TYPE_EARPIECE
+            } else {
+                mAudioDeviceManager.defaultAudioDevice = AudioDeviceEndpoint.TYPE_SPEAKER
+            }
+        }
+    }
+
+    @ReactMethod
+    fun start() {
+        AudioDeviceManager.runInAudioThread {
+            if (!audioManagerActivated) {
+                reactApplicationContext.currentActivity?.let {
+                    Log.d(TAG, "start() mAudioDeviceManager")
+                    mAudioDeviceManager.start(it)
+                    setKeepScreenOn(true)
+                    audioManagerActivated = true
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun stop() {
+        AudioDeviceManager.runInAudioThread {
+            if (audioManagerActivated) {
+                Log.d(TAG, "stop() mAudioDeviceManager")
+                mAudioDeviceManager.stop()
+                setMicrophoneMute(false)
+                setKeepScreenOn(false)
+                audioManagerActivated = false
+            }
+        }
+    }
+
+    private fun setKeepScreenOn(enable: Boolean) {
+        Log.d(TAG, "setKeepScreenOn() $enable")
+        UiThreadUtil.runOnUiThread {
+            reactApplicationContext.currentActivity?.let {
+                val window = it.window
+                if (enable) {
+                    window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+                } else {
+                    window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+                }
+            }
+        }
+    }
+
+    @Suppress("unused")
+    @ReactMethod
+    fun setForceSpeakerphoneOn(enable: Boolean) {
+        if (mAudioDeviceManager.callAudioRole !== CallAudioRole.Communicator) {
+            Log.e(TAG, "setForceSpeakerphoneOn() is not supported when audio role is not Communicator")
+            return
+        }
+        mAudioDeviceManager.setSpeakerphoneOn(enable)
+    }
+
+    @ReactMethod
+    fun setMicrophoneMute(enable: Boolean) {
+        mAudioDeviceManager.setMicrophoneMute(enable)
+    }
+
+    @ReactMethod
+    fun logAudioState() {
+        WebRtcAudioUtils.logAudioState(
+            TAG,
+            reactApplicationContext,
+        )
+    }
+
+    @Suppress("unused")
+    @ReactMethod
+    fun chooseAudioDeviceEndpoint(endpointDeviceName: String) {
+        if (mAudioDeviceManager.callAudioRole !== CallAudioRole.Communicator) {
+            Log.e(TAG, "chooseAudioDeviceEndpoint() is not supported when audio role is not Communicator")
+            return
+        }
+        mAudioDeviceManager.switchDeviceFromDeviceName(
+            endpointDeviceName
+        )
+    }
+
+    @ReactMethod
+    fun muteAudioOutput() {
+        mAudioDeviceManager.muteAudioOutput()
+    }
+
+    @ReactMethod
+    fun unmuteAudioOutput() {
+        mAudioDeviceManager.unmuteAudioOutput()
+    }
+
+    override fun onHostResume() {
+    }
+
+    override fun onHostPause() {
+    }
+
+    override fun onHostDestroy() {
+        stop()
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String?) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int?) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    companion object {
+        const val TAG = "StreamInCallManager"
+    }
+}
+

package/android/src/main/java/com/streamvideo/reactnative/model/AudioDeviceEndpoint.kt

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 com.streamvideo.reactnative.model
+
+import android.media.AudioDeviceInfo
+import androidx.annotation.IntDef
+import androidx.annotation.RestrictTo
+import com.streamvideo.reactnative.audio.utils.AudioDeviceEndpointUtils
+import java.util.Objects
+
+/**
+ * Represents a single audio device endpoint.
+ * @param name The name of the device. Bluetooth devices have their proper names, everything else their endpoint name. See [AudioDeviceEndpointUtils.remapAudioDeviceNameToEndpointDeviceName]
+ * @param type The type of endpoint.
+ * @param deviceInfo The [AudioDeviceInfo] associated with the endpoint.
+ */
+public class AudioDeviceEndpoint(
+    public val name: String,
+    @EndpointType public val type: Int,
+    public val deviceInfo: AudioDeviceInfo,
+) : Comparable<AudioDeviceEndpoint> {
+
+    val deviceId = deviceInfo.id
+
+    override fun toString(): String {
+        return "CallEndpoint(" +
+            "name=[$name]," +
+            "type=[${
+                AudioDeviceEndpointUtils.endpointTypeToString(type)}]," +
+            "deviceId=[${deviceId}])"
+    }
+
+    /**
+     * Compares this [AudioDeviceEndpoint] to the other [AudioDeviceEndpoint] for order. Returns a
+     * positive number if this type rank is greater than the other value. Returns a negative number
+     * if this type rank is less than the other value. Sort the CallEndpoint by type. Ranking them
+     * by:
+     * 1. TYPE_WIRED_HEADSET
+     * 2. TYPE_BLUETOOTH
+     * 3. TYPE_SPEAKER
+     * 4. TYPE_EARPIECE
+     * 5. TYPE_UNKNOWN If two endpoints have the same type, the name is compared to determine the
+     *    value.
+     */
+    override fun compareTo(other: AudioDeviceEndpoint): Int {
+        // sort by type
+        val res = this.getTypeRank().compareTo(other.getTypeRank())
+        if (res != 0) {
+            return res
+        }
+        // break ties using alphabetic order
+        return this.name.toString().compareTo(other.name.toString())
+    }
+
+    override fun equals(other: Any?): Boolean {
+        return other is AudioDeviceEndpoint &&
+            name == other.name &&
+            type == other.type && deviceId == other.deviceId
+    }
+
+    override fun hashCode(): Int {
+        return Objects.hash(name, type, deviceId)
+    }
+
+    public companion object {
+        @RestrictTo(RestrictTo.Scope.LIBRARY)
+        @Retention(AnnotationRetention.SOURCE)
+        @IntDef(
+            TYPE_UNKNOWN,
+            TYPE_EARPIECE,
+            TYPE_BLUETOOTH,
+            TYPE_WIRED_HEADSET,
+            TYPE_SPEAKER,
+        )
+        @Target(AnnotationTarget.TYPE, AnnotationTarget.PROPERTY, AnnotationTarget.VALUE_PARAMETER)
+        public annotation class EndpointType
+
+        /** Indicates that the type of endpoint through which call media flows is unknown type. */
+        public const val TYPE_UNKNOWN: Int = -1
+
+        /** Indicates that the type of endpoint through which call media flows is an earpiece. */
+        public const val TYPE_EARPIECE: Int = 1
+
+        /** Indicates that the type of endpoint through which call media flows is a Bluetooth. */
+        public const val TYPE_BLUETOOTH: Int = 2
+
+        /**
+         * Indicates that the type of endpoint through which call media flows is a wired headset.
+         */
+        public const val TYPE_WIRED_HEADSET: Int = 3
+
+        /** Indicates that the type of endpoint through which call media flows is a speakerphone. */
+        public const val TYPE_SPEAKER: Int = 4
+
+    }
+
+    internal fun isBluetoothType(): Boolean {
+        return type == TYPE_BLUETOOTH
+    }
+
+    internal fun isSpeakerType(): Boolean {
+        return type == TYPE_SPEAKER
+    }
+
+    internal fun isWiredHeadsetType(): Boolean {
+        return type == TYPE_WIRED_HEADSET
+    }
+
+    internal fun isEarpieceType(): Boolean {
+        return type == TYPE_EARPIECE
+    }
+
+    private fun getTypeRank(): Int {
+        return when (this.type) {
+            TYPE_WIRED_HEADSET -> return 0
+            TYPE_BLUETOOTH -> return 1
+            TYPE_SPEAKER -> return 2
+            TYPE_EARPIECE -> return 3
+            else -> 4
+        }
+    }
+}

package/android/src/main/java/org/webrtc/audio/WebRtcAudioTrackHelper.kt

@@ -0,0 +1,12 @@
+package org.webrtc.audio
+
+import android.media.AudioAttributes
+
+object WebRtcAudioTrackHelper {
+    fun setAudioOutputAttributes(
+        adm: JavaAudioDeviceModule,
+        audioAttributes: AudioAttributes,
+    ) {
+        adm.audioOutput.audioAttributes = audioAttributes
+    }
+}

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

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.CallContent = void 0;
 var _react = _interopRequireWildcard(require("react"));
 var _reactNative = require("react-native");
-var _reactNativeIncallManager = _interopRequireDefault(require("react-native-incall-manager"));
 var _CallLayout = require("../CallLayout");
 var _CallControls = require("../CallControls");
 var _videoReactBindings = require("@stream-io/video-react-bindings");
@@ -18,7 +17,7 @@ var _contexts = require("../../../contexts");
 var _hooks2 = require("../../../hooks");
 var _ScreenShareOverlay = require("../../utility/ScreenShareOverlay");
 var _RTCViewPipIOS = require("./RTCViewPipIOS");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _PrevLibDetection = require("../../../modules/call-manager/PrevLibDetection");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
 const CallContent = ({
@@ -36,9 +35,9 @@ const CallContent = ({
   layout = 'grid',
   landscape = false,
   supportedReactions,
+  initialInCallManagerAudioMode = 'video',
   iOSPiPIncludeLocalParticipantVideo,
-  disablePictureInPicture,
-  initialInCallManagerAudioMode = 'video'
+  disablePictureInPicture
 }) => {
   const [showRemoteParticipantInFloatingView, setShowRemoteParticipantInFloatingView] = (0, _react.useState)(false);
   const styles = useStyles();
@@ -54,7 +53,6 @@ const CallContent = ({
     useLocalParticipant
   } = (0, _videoReactBindings.useCallStateHooks)();
   (0, _hooks2.useAutoEnterPiPEffect)(disablePictureInPicture);
-  const incallManagerModeRef = (0, _react.useRef)(initialInCallManagerAudioMode);
   const _remoteParticipants = useRemoteParticipants();
   const remoteParticipants = (0, _hooks.useDebouncedValue)(_remoteParticipants, 300); // we debounce the remote participants to avoid unnecessary rerenders that happen when participant tracks are all subscribed simultaneously
   const localParticipant = useLocalParticipant();
@@ -85,11 +83,17 @@ const CallContent = ({
   /**
    * This hook is used to handle IncallManager specs of the application.
    */
+  const incallManagerModeRef = (0, _react.useRef)(initialInCallManagerAudioMode);
   (0, _react.useEffect)(() => {
-    _reactNativeIncallManager.default.start({
-      media: incallManagerModeRef.current
-    });
-    return () => _reactNativeIncallManager.default.stop();
+    const prevInCallManager = (0, _PrevLibDetection.getRNInCallManagerLibNoThrow)();
+    if (prevInCallManager) {
+      prevInCallManager.start({
+        media: incallManagerModeRef.current
+      });
+      return () => {
+        prevInCallManager.stop();
+      };
+    }
   }, []);
   const handleFloatingViewParticipantSwitch = () => {
     if (remoteParticipants.length !== 1) {