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

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

@@ -0,0 +1,192 @@
+/*
+ * 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.audio.utils
+
+import android.media.AudioDeviceInfo
+import android.util.Log
+import com.streamvideo.reactnative.model.AudioDeviceEndpoint
+import com.streamvideo.reactnative.model.AudioDeviceEndpoint.Companion.EndpointType
+
+internal class AudioDeviceEndpointUtils {
+
+    companion object {
+        const val BLUETOOTH_DEVICE_DEFAULT_NAME = "Bluetooth Device"
+        const val EARPIECE = "Earpiece"
+        const val SPEAKER = "Speaker"
+        const val WIRED_HEADSET = "Wired Headset"
+        const val UNKNOWN = "Unknown"
+
+        private val TAG: String = AudioDeviceEndpointUtils::class.java.simpleName.toString()
+
+        /** Gets the endpoints from AudioDeviceInfos.
+         * IMPORTANT: eliminates Earpiece if Headset is found
+         * */
+        fun getEndpointsFromAudioDeviceInfo(
+            adiArr: List<AudioDeviceInfo>?,
+        ): List<AudioDeviceEndpoint> {
+            if (adiArr == null) {
+                return listOf()
+            }
+            val endpoints: MutableList<AudioDeviceEndpoint> = mutableListOf()
+            var foundWiredHeadset = false
+            val omittedDevices = StringBuilder("omitting devices =[")
+            adiArr.toList().forEach { audioDeviceInfo ->
+                val endpoint = getEndpointFromAudioDeviceInfo(audioDeviceInfo)
+                if (endpoint.type != AudioDeviceEndpoint.TYPE_UNKNOWN) {
+                    if (endpoint.type == AudioDeviceEndpoint.TYPE_WIRED_HEADSET) {
+                        foundWiredHeadset = true
+                    }
+                    endpoints.add(endpoint)
+                } else {
+                    omittedDevices.append(
+                        "(type=[${audioDeviceInfo.type}]," +
+                            " name=[${audioDeviceInfo.productName}]),"
+                    )
+                }
+            }
+            omittedDevices.append("]")
+            Log.i(TAG, omittedDevices.toString())
+            if (foundWiredHeadset) {
+                endpoints.removeIf { it.type == AudioDeviceEndpoint.TYPE_EARPIECE }
+            }
+            // Sort by endpoint type.  The first element has the highest priority!
+            endpoints.sort()
+            return endpoints
+        }
+
+
+        private fun getEndpointFromAudioDeviceInfo(
+            adi: AudioDeviceInfo,
+        ): AudioDeviceEndpoint {
+            val endpointDeviceName = remapAudioDeviceNameToEndpointDeviceName(adi)
+            val endpointType = remapAudioDeviceTypeToCallEndpointType(adi.type)
+            val newEndpoint =
+                AudioDeviceEndpoint(
+                    endpointDeviceName,
+                    endpointType,
+                    adi,
+                )
+            return newEndpoint
+        }
+
+        internal fun remapAudioDeviceNameToEndpointDeviceName(
+            audioDeviceInfo: AudioDeviceInfo,
+        ): String {
+            return when (audioDeviceInfo.type) {
+                AudioDeviceInfo.TYPE_BUILTIN_EARPIECE ->
+                    EARPIECE
+                AudioDeviceInfo.TYPE_BUILTIN_SPEAKER ->
+                    SPEAKER
+                AudioDeviceInfo.TYPE_WIRED_HEADSET,
+                AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+                AudioDeviceInfo.TYPE_USB_DEVICE,
+                AudioDeviceInfo.TYPE_USB_ACCESSORY,
+                AudioDeviceInfo.TYPE_USB_HEADSET ->
+                    WIRED_HEADSET
+                else -> audioDeviceInfo.productName.toString()
+            }
+        }
+
+        internal fun remapAudioDeviceTypeToCallEndpointType(
+            audioDeviceInfoType: Int
+        ): (@EndpointType Int) {
+            return when (audioDeviceInfoType) {
+                AudioDeviceInfo.TYPE_BUILTIN_EARPIECE -> AudioDeviceEndpoint.TYPE_EARPIECE
+                AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> AudioDeviceEndpoint.TYPE_SPEAKER
+                // Wired Headset Devices
+                AudioDeviceInfo.TYPE_WIRED_HEADSET,
+                AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+                AudioDeviceInfo.TYPE_USB_DEVICE,
+                AudioDeviceInfo.TYPE_USB_ACCESSORY,
+                AudioDeviceInfo.TYPE_USB_HEADSET -> AudioDeviceEndpoint.TYPE_WIRED_HEADSET
+                // Bluetooth Devices
+                AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
+                AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+                AudioDeviceInfo.TYPE_HEARING_AID,
+                AudioDeviceInfo.TYPE_BLE_HEADSET,
+                AudioDeviceInfo.TYPE_BLE_SPEAKER,
+                AudioDeviceInfo.TYPE_BLE_BROADCAST -> AudioDeviceEndpoint.TYPE_BLUETOOTH
+                // Everything else is defaulted to TYPE_UNKNOWN
+                else -> AudioDeviceEndpoint.TYPE_UNKNOWN
+            }
+        }
+
+        fun getSpeakerEndpoint(endpoints: List<AudioDeviceEndpoint>): AudioDeviceEndpoint? {
+            for (e in endpoints) {
+                if (e.type == AudioDeviceEndpoint.TYPE_SPEAKER) {
+                    return e
+                }
+            }
+            return null
+        }
+
+        fun isBluetoothAvailable(endpoints: List<AudioDeviceEndpoint>): Boolean {
+            for (e in endpoints) {
+                if (e.type == AudioDeviceEndpoint.TYPE_BLUETOOTH) {
+                    return true
+                }
+            }
+            return false
+        }
+
+        fun isEarpieceEndpoint(endpoint: AudioDeviceEndpoint?): Boolean {
+            if (endpoint == null) {
+                return false
+            }
+            return endpoint.type == AudioDeviceEndpoint.TYPE_EARPIECE
+        }
+
+        fun isSpeakerEndpoint(endpoint: AudioDeviceEndpoint?): Boolean {
+            if (endpoint == null) {
+                return false
+            }
+            return endpoint.type == AudioDeviceEndpoint.TYPE_SPEAKER
+        }
+
+        fun isWiredHeadsetOrBtEndpoint(endpoint: AudioDeviceEndpoint?): Boolean {
+            if (endpoint == null) {
+                return false
+            }
+            return endpoint.type == AudioDeviceEndpoint.TYPE_BLUETOOTH ||
+                endpoint.type == AudioDeviceEndpoint.TYPE_WIRED_HEADSET
+        }
+
+        private fun isBluetoothType(type: Int): Boolean {
+            return type == AudioDeviceEndpoint.TYPE_BLUETOOTH
+        }
+
+        fun endpointTypeToString(@EndpointType endpointType: Int): String {
+            return when (endpointType) {
+                AudioDeviceEndpoint.TYPE_EARPIECE -> EARPIECE
+                AudioDeviceEndpoint.TYPE_BLUETOOTH -> BLUETOOTH_DEVICE_DEFAULT_NAME
+                AudioDeviceEndpoint.TYPE_WIRED_HEADSET -> WIRED_HEADSET
+                AudioDeviceEndpoint.TYPE_SPEAKER -> SPEAKER
+                else -> UNKNOWN
+            }
+        }
+
+        fun endpointStringToType(endpointName: String): Int {
+            return when (endpointName) {
+                EARPIECE -> AudioDeviceEndpoint.TYPE_EARPIECE
+                WIRED_HEADSET -> AudioDeviceEndpoint.TYPE_WIRED_HEADSET
+                SPEAKER -> AudioDeviceEndpoint.TYPE_SPEAKER
+                BLUETOOTH_DEVICE_DEFAULT_NAME -> AudioDeviceEndpoint.TYPE_BLUETOOTH
+                else -> AudioDeviceEndpoint.TYPE_UNKNOWN
+            }
+        }
+    }
+}

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

@@ -0,0 +1,62 @@
+package com.streamvideo.reactnative.audio.utils
+
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.os.Build
+import com.facebook.react.bridge.ReactContext
+import com.oney.WebRTCModule.WebRTCModule
+import org.webrtc.audio.JavaAudioDeviceModule
+import org.webrtc.audio.WebRtcAudioTrackHelper
+
+enum class CallAudioRole {
+    /* high quality audio output is prioritised */
+    Listener,
+
+    /* low latency audio output is prioritised */
+    Communicator
+}
+
+class AudioFocusUtil(
+    private val audioManager: AudioManager,
+    private val audioFocusChangeListener: AudioManager.OnAudioFocusChangeListener,
+) {
+
+    private lateinit var request: AudioFocusRequest
+
+
+
+    fun requestFocus(mode: CallAudioRole, reactContext: ReactContext) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val audioAttributes = AudioAttributes.Builder()
+                .setUsage(if (mode == CallAudioRole.Communicator) AudioAttributes.USAGE_VOICE_COMMUNICATION else AudioAttributes.USAGE_MEDIA)
+                .setContentType(if (mode == CallAudioRole.Communicator) AudioAttributes.CONTENT_TYPE_SPEECH else AudioAttributes.CONTENT_TYPE_MUSIC)
+                .build()
+
+            // 1. set audio attributes to webrtc
+            val webRTCModule = reactContext.getNativeModule(WebRTCModule::class.java)!!
+            val adm = webRTCModule.audioDeviceModule as JavaAudioDeviceModule
+            WebRtcAudioTrackHelper.setAudioOutputAttributes(adm, audioAttributes)
+
+            // 2. request the audio focus with the audio attributes
+            request = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
+                .setAudioAttributes(audioAttributes).setAcceptsDelayedFocusGain(true)
+                .setOnAudioFocusChangeListener(audioFocusChangeListener).build()
+            audioManager.requestAudioFocus(request)
+        } else {
+            audioManager.requestAudioFocus(
+                audioFocusChangeListener,
+                if (mode == CallAudioRole.Communicator) AudioManager.STREAM_VOICE_CALL else AudioManager.STREAM_MUSIC,
+                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT,
+            )
+        }
+    }
+
+    fun abandonFocus() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            audioManager.abandonAudioFocusRequest(request)
+        } else {
+            audioManager.abandonAudioFocus(audioFocusChangeListener)
+        }
+    }
+}

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

@@ -0,0 +1,159 @@
+package com.streamvideo.reactnative.audio.utils
+
+import android.media.AudioDeviceInfo
+import android.media.AudioManager
+import android.os.Build
+import android.util.Log
+import androidx.annotation.DoNotInline
+import androidx.annotation.RequiresApi
+import com.streamvideo.reactnative.audio.BluetoothManager
+import com.streamvideo.reactnative.audio.EndpointMaps
+import com.streamvideo.reactnative.callmanager.StreamInCallManagerModule
+import com.streamvideo.reactnative.model.AudioDeviceEndpoint
+import com.streamvideo.reactnative.model.AudioDeviceEndpoint.Companion.EndpointType
+
+
+internal class AudioManagerUtil {
+    companion object {
+        private val TAG: String = StreamInCallManagerModule.TAG + ":" + AudioManagerUtil::class.java.simpleName.toString()
+
+        fun getAvailableAudioDevices(audioManager: AudioManager): List<AudioDeviceInfo> {
+            return if (Build.VERSION.SDK_INT >= 31) {
+                AudioManager31PlusImpl.getDevices(audioManager)
+            } else {
+                AudioManager23PlusImpl.getDevices(audioManager)
+            }
+        }
+
+        fun isSpeakerphoneOn(audioManager: AudioManager): Boolean {
+            return if (Build.VERSION.SDK_INT >= 31) {
+                AudioManager31PlusImpl.isSpeakerphoneOn(audioManager)
+            } else {
+                AudioManager23PlusImpl.isSpeakerphoneOn(audioManager)
+            }
+        }
+
+        /**
+         * Switch the device endpoint type.
+         * @return true if the device endpoint type is successfully switched.
+         */
+        fun switchDeviceEndpointType(@EndpointType deviceType: Int,
+                                     endpointMaps: EndpointMaps,
+                                     audioManager: AudioManager,
+                                     bluetoothManager: BluetoothManager): AudioDeviceEndpoint? {
+            return if (Build.VERSION.SDK_INT >= 31) {
+                AudioManager31PlusImpl.switchDeviceEndpointType(deviceType, endpointMaps, audioManager, bluetoothManager)
+            } else {
+                AudioManager23PlusImpl.switchDeviceEndpointType(deviceType, endpointMaps, audioManager, bluetoothManager)
+            }
+        }
+    }
+
+    @RequiresApi(31)
+    object AudioManager31PlusImpl {
+        @JvmStatic
+        @DoNotInline
+        fun getDevices(audioManager: AudioManager): List<AudioDeviceInfo> {
+            return audioManager.availableCommunicationDevices
+        }
+
+        @JvmStatic
+        @DoNotInline
+        fun isSpeakerphoneOn(audioManager: AudioManager): Boolean {
+            val endpoint = AudioDeviceEndpointUtils.remapAudioDeviceTypeToCallEndpointType(audioManager.communicationDevice?.type ?: AudioDeviceInfo.TYPE_UNKNOWN)
+            return endpoint == AudioDeviceEndpoint.TYPE_SPEAKER
+        }
+
+        @JvmStatic
+        @DoNotInline
+        fun switchDeviceEndpointType(@EndpointType deviceType: Int,
+                                     endpointMaps: EndpointMaps,
+                                     audioManager: AudioManager,
+                                     bluetoothManager: BluetoothManager): AudioDeviceEndpoint? {
+            audioManager.mode = AudioManager.MODE_IN_COMMUNICATION
+            when (deviceType) {
+                AudioDeviceEndpoint.TYPE_BLUETOOTH -> {
+                    val didSwitch = bluetoothManager.startScoAudio()
+                    if (didSwitch) {
+                        return endpointMaps.bluetoothEndpoints[bluetoothManager.getDeviceName()]
+                    }
+                    return null
+                }
+                AudioDeviceEndpoint.TYPE_WIRED_HEADSET, AudioDeviceEndpoint.TYPE_EARPIECE -> {
+                    endpointMaps.nonBluetoothEndpoints.values.firstOrNull {
+                        it.type == deviceType
+                    }?.let {
+                        audioManager.setCommunicationDevice(it.deviceInfo)
+                        bluetoothManager.updateDevice()
+                        return endpointMaps.nonBluetoothEndpoints[deviceType]
+                    }
+                    return null
+                }
+                AudioDeviceEndpoint.TYPE_SPEAKER -> {
+                    val speakerDevice = endpointMaps.nonBluetoothEndpoints[AudioDeviceEndpoint.TYPE_SPEAKER]
+                    speakerDevice?.let {
+                        audioManager.setCommunicationDevice(it.deviceInfo)
+                        bluetoothManager.updateDevice()
+                        return speakerDevice
+                    }
+                    return null
+                }
+                else -> {
+                    Log.e(TAG, "switchDeviceEndpointType(): unknown device type requested")
+                    return null
+                }
+            }
+        }
+    }
+
+    @Suppress("DEPRECATION")
+    object AudioManager23PlusImpl {
+        @JvmStatic
+        @DoNotInline
+        fun getDevices(audioManager: AudioManager): List<AudioDeviceInfo> {
+            return audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS).toList()
+        }
+
+        @JvmStatic
+        @DoNotInline
+        fun isSpeakerphoneOn(audioManager: AudioManager): Boolean {
+            return audioManager.isSpeakerphoneOn
+        }
+
+        @JvmStatic
+        @DoNotInline
+        fun switchDeviceEndpointType(@EndpointType deviceType: Int,
+                                     endpointMaps: EndpointMaps,
+                                     audioManager: AudioManager,
+                                     bluetoothManager: BluetoothManager): AudioDeviceEndpoint? {
+            audioManager.mode = AudioManager.MODE_IN_COMMUNICATION
+            when (deviceType) {
+                AudioDeviceEndpoint.TYPE_BLUETOOTH -> {
+                    audioManager.setSpeakerphoneOn(false)
+                    val didSwitch = bluetoothManager.startScoAudio()
+                    if (didSwitch) {
+                        // NOTE: SCO connection may fail after timeout, how to catch that on older platforms?
+                        return endpointMaps.bluetoothEndpoints[bluetoothManager.getDeviceName()]
+                    }
+                    return null
+                }
+                AudioDeviceEndpoint.TYPE_WIRED_HEADSET, AudioDeviceEndpoint.TYPE_EARPIECE -> {
+                    // NOTE: If wired headset is present,
+                    // earpiece is always omitted even if chosen
+                    bluetoothManager.stopScoAudio()
+                    audioManager.setSpeakerphoneOn(false)
+                    return endpointMaps.nonBluetoothEndpoints[deviceType]
+                }
+                AudioDeviceEndpoint.TYPE_SPEAKER -> {
+                    bluetoothManager.stopScoAudio()
+                    audioManager.setSpeakerphoneOn(true)
+                    return endpointMaps.nonBluetoothEndpoints[AudioDeviceEndpoint.TYPE_SPEAKER]
+                }
+                else -> {
+                    Log.e(TAG, "switchDeviceEndpointType(): unknown device type requested")
+                    return null
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+package com.streamvideo.reactnative.audio.utils
+
+import android.media.AudioManager
+import android.util.Log
+import com.facebook.react.bridge.ReactContext
+import com.streamvideo.reactnative.audio.AudioDeviceManager
+import com.streamvideo.reactnative.callmanager.StreamInCallManagerModule.Companion.TAG
+
+class AudioSetupStoreUtil(
+    private val mReactContext: ReactContext,
+    private val mAudioManager: AudioManager,
+    private val mAudioDeviceManager: AudioDeviceManager
+) {
+    private var isOrigAudioSetupStored = false
+    private var origIsSpeakerPhoneOn = false
+    private var origIsMicrophoneMute = false
+    private var origAudioMode = AudioManager.MODE_NORMAL
+
+    fun storeOriginalAudioSetup() {
+        if (!isOrigAudioSetupStored) {
+            origAudioMode = mAudioManager.mode
+            origIsSpeakerPhoneOn = AudioManagerUtil.isSpeakerphoneOn(mAudioManager)
+            origIsMicrophoneMute = mAudioManager.isMicrophoneMute
+            isOrigAudioSetupStored = true
+        }
+    }
+
+    fun restoreOriginalAudioSetup() {
+        if (isOrigAudioSetupStored) {
+            if (origIsSpeakerPhoneOn) {
+                mAudioDeviceManager.setSpeakerphoneOn(true)
+            }
+            mAudioManager.setMicrophoneMute(origIsMicrophoneMute)
+            mAudioManager.mode = origAudioMode
+            mReactContext.currentActivity?.apply {
+                volumeControlStream = AudioManager.USE_DEFAULT_STREAM_TYPE
+            }
+            isOrigAudioSetupStored = false
+        }
+    }
+}