Audio device selection (#106)

* Expose AudioSwitch controls

* fix build

@@ -16,5 +16,8 @@
     <inspection_tool class="PreviewNeedsComposableAnnotation" enabled="true" level="ERROR" enabled_by_default="true">
     <inspection_tool class="PreviewNeedsComposableAnnotation" enabled="true" level="ERROR" enabled_by_default="true">
       <option name="previewFile" value="true" />
       <option name="previewFile" value="true" />
     </inspection_tool>
     </inspection_tool>
+    <inspection_tool class="PreviewPickerAnnotation" enabled="true" level="ERROR" enabled_by_default="true">
+      <option name="previewFile" value="true" />
+    </inspection_tool>
   </profile>
   </profile>
 </component>
 </component>

@@ -113,7 +113,7 @@ dependencies {
     implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.1.0'
     implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.1.0'
     api 'com.github.webrtc-sdk:android:97.4692.04'
     api 'com.github.webrtc-sdk:android:97.4692.04'
     api "com.squareup.okhttp3:okhttp:4.9.1"
     api "com.squareup.okhttp3:okhttp:4.9.1"
-    implementation "com.twilio:audioswitch:1.1.5"
+    api "com.twilio:audioswitch:1.1.5"
     implementation "androidx.annotation:annotation:1.3.0"
     implementation "androidx.annotation:annotation:1.3.0"
     implementation "androidx.core:core:${versions.androidx_core}"
     implementation "androidx.core:core:${versions.androidx_core}"
     implementation "com.google.protobuf:protobuf-javalite:${versions.protobuf}"
     implementation "com.google.protobuf:protobuf-javalite:${versions.protobuf}"

@@ -40,7 +40,9 @@ data class LiveKitOverrides(
     val videoDecoderFactory: VideoDecoderFactory? = null,
     val videoDecoderFactory: VideoDecoderFactory? = null,
 
 
     /**
     /**
-     * Override the default [AudioHandler]. Use [NoAudioHandler] to turn off automatic audio handling.
+     * Override the default [AudioHandler].
+     *
+     * Use [NoAudioHandler] to turn off automatic audio handling.
      */
      */
 
 
     val audioHandler: AudioHandler? = null
     val audioHandler: AudioHandler? = null

 package io.livekit.android.audio
 package io.livekit.android.audio
 
 
 import android.content.Context
 import android.content.Context
+import android.media.AudioManager
+import com.twilio.audioswitch.AudioDevice
+import com.twilio.audioswitch.AudioDeviceChangeListener
 import com.twilio.audioswitch.AudioSwitch
 import com.twilio.audioswitch.AudioSwitch
 import javax.inject.Inject
 import javax.inject.Inject
 import javax.inject.Singleton
 import javax.inject.Singleton
@@ -8,14 +11,60 @@ import javax.inject.Singleton
 @Singleton
 @Singleton
 class AudioSwitchHandler
 class AudioSwitchHandler
 @Inject
 @Inject
-constructor(context: Context) : AudioHandler {
-    private val audioSwitch = AudioSwitch(context)
+constructor(private val context: Context) : AudioHandler {
+    var loggingEnabled = false
+    var audioDeviceChangeListener: AudioDeviceChangeListener? = null
+    var onAudioFocusChangeListener: AudioManager.OnAudioFocusChangeListener? = null
+    var preferredDeviceList: List<Class<out AudioDevice>>? = null
+
+    private var audioSwitch: AudioSwitch? = null
+
     override fun start() {
     override fun start() {
-        audioSwitch.start { _, _ -> }
-        audioSwitch.activate()
+        if (audioSwitch == null) {
+            val switch = AudioSwitch(
+                context = context,
+                loggingEnabled = loggingEnabled,
+                audioFocusChangeListener = onAudioFocusChangeListener ?: defaultOnAudioFocusChangeListener,
+                preferredDeviceList = preferredDeviceList ?: defaultPreferredDeviceList
+            )
+            audioSwitch = switch
+            switch.start(audioDeviceChangeListener ?: defaultAudioDeviceChangeListener)
+            switch.activate()
+        }
     }
     }
 
 
     override fun stop() {
     override fun stop() {
-        audioSwitch.stop()
+        audioSwitch?.stop()
+        audioSwitch = null
+    }
+
+    val selectedAudioDevice: AudioDevice?
+        get() = audioSwitch?.selectedAudioDevice
+
+    val availableAudioDevices: List<AudioDevice>
+        get() = audioSwitch?.availableAudioDevices ?: listOf()
+
+    fun selectDevice(audioDevice: AudioDevice?) {
+        audioSwitch?.selectDevice(audioDevice)
+    }
+
+    companion object {
+        private val defaultOnAudioFocusChangeListener by lazy(LazyThreadSafetyMode.NONE) {
+            AudioManager.OnAudioFocusChangeListener { }
+        }
+        private val defaultAudioDeviceChangeListener by lazy(LazyThreadSafetyMode.NONE) {
+            object : AudioDeviceChangeListener {
+                override fun invoke(audioDevices: List<AudioDevice>, selectedAudioDevice: AudioDevice?) {
+                }
+            }
+        }
+        private val defaultPreferredDeviceList by lazy(LazyThreadSafetyMode.NONE) {
+            listOf(
+                AudioDevice.BluetoothHeadset::class.java,
+                AudioDevice.WiredHeadset::class.java,
+                AudioDevice.Earpiece::class.java,
+                AudioDevice.Speakerphone::class.java
+            )
+        }
     }
     }
 }
 }

@@ -44,7 +44,7 @@ constructor(
     private val defaultDispatcher: CoroutineDispatcher,
     private val defaultDispatcher: CoroutineDispatcher,
     @Named(InjectionNames.DISPATCHER_IO)
     @Named(InjectionNames.DISPATCHER_IO)
     private val ioDispatcher: CoroutineDispatcher,
     private val ioDispatcher: CoroutineDispatcher,
-    private val audioHandler: AudioHandler,
+    val audioHandler: AudioHandler,
 ) : RTCEngine.Listener, ParticipantListener, ConnectivityManager.NetworkCallback() {
 ) : RTCEngine.Listener, ParticipantListener, ConnectivityManager.NetworkCallback() {
 
 
     private lateinit var coroutineScope: CoroutineScope
     private lateinit var coroutineScope: CoroutineScope

@@ -8,7 +8,9 @@ import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import androidx.lifecycle.viewModelScope
 import com.github.ajalt.timberkt.Timber
 import com.github.ajalt.timberkt.Timber
 import io.livekit.android.LiveKit
 import io.livekit.android.LiveKit
+import io.livekit.android.LiveKitOverrides
 import io.livekit.android.RoomOptions
 import io.livekit.android.RoomOptions
+import io.livekit.android.audio.AudioSwitchHandler
 import io.livekit.android.events.RoomEvent
 import io.livekit.android.events.RoomEvent
 import io.livekit.android.events.collect
 import io.livekit.android.events.collect
 import io.livekit.android.room.Room
 import io.livekit.android.room.Room
@@ -79,6 +81,7 @@ class CallViewModel(
     private val mutablePermissionAllowed = MutableStateFlow(true)
     private val mutablePermissionAllowed = MutableStateFlow(true)
     val permissionAllowed = mutablePermissionAllowed.hide()
     val permissionAllowed = mutablePermissionAllowed.hide()
 
 
+    val audioHandler = AudioSwitchHandler(application)
     init {
     init {
         viewModelScope.launch {
         viewModelScope.launch {
 
 
@@ -92,6 +95,7 @@ class CallViewModel(
                     url,
                     url,
                     token,
                     token,
                     roomOptions = RoomOptions(adaptiveStream = true, dynacast = true),
                     roomOptions = RoomOptions(adaptiveStream = true, dynacast = true),
+                    overrides = LiveKitOverrides(audioHandler = audioHandler)
                 )
                 )
 
 
                 // Create and publish audio/video tracks
                 // Create and publish audio/video tracks

-/*
- *  Copyright 2014 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.
- */
-@file:Suppress("unused")
-
-package io.livekit.android.sample.audio
-
-import android.annotation.SuppressLint
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.content.pm.PackageManager
-import android.media.AudioDeviceInfo
-import android.media.AudioManager
-import android.os.Build
-import io.livekit.android.sample.audio.AppRTCBluetoothManager.Companion.create
-import io.livekit.android.sample.audio.AppRTCProximitySensor.Companion.create
-import org.webrtc.ThreadUtils
-import timber.log.Timber
-import java.util.*
-
-/**
- * AppRTCAudioManager manages all audio related parts of the AppRTC demo.
- */
-@SuppressLint("BinaryOperationInTimber")
-class AppRTCAudioManager
-constructor(context: Context) {
-    /**
-     * AudioDevice is the names of possible audio devices that we currently
-     * support.
-     */
-    enum class AudioDevice {
-        SPEAKER_PHONE, WIRED_HEADSET, EARPIECE, BLUETOOTH, NONE
-    }
-
-    /** AudioManager state.  */
-    enum class AudioManagerState {
-        UNINITIALIZED, PREINITIALIZED, RUNNING
-    }
-
-    /** Selected audio device change event.  */
-    interface AudioManagerEvents {
-        // Callback fired once audio device is changed or list of available audio devices changed.
-        fun onAudioDeviceChanged(
-            selectedAudioDevice: AudioDevice?, availableAudioDevices: Set<AudioDevice>?
-        )
-    }
-
-    private val apprtcContext: Context
-    private val audioManager: AudioManager
-    private var audioManagerEvents: AudioManagerEvents? = null
-    private var amState: AudioManagerState
-    private var savedAudioMode = AudioManager.MODE_NORMAL
-    private var savedIsSpeakerPhoneOn = false
-    private var savedIsMicrophoneMute = false
-    private var hasWiredHeadset = false
-
-    // Default audio device; speaker phone for video calls or earpiece for audio
-    // only calls.
-    private var defaultAudioDevice: AudioDevice
-
-    // Contains the currently selected audio device.
-    // This device is changed automatically using a certain scheme where e.g.
-    // a wired headset "wins" over speaker phone. It is also possible for a
-    // user to explicitly select a device (and overrid any predefined scheme).
-    // See |userSelectedAudioDevice| for details.
-    private var selectedAudioDevice: AudioDevice? = null
-
-    // Contains the user-selected audio device which overrides the predefined
-    // selection scheme.
-    // TODO(henrika): always set to AudioDevice.NONE today. Add support for
-    // explicit selection based on choice by userSelectedAudioDevice.
-    private var userSelectedAudioDevice: AudioDevice? = null
-
-    // Contains speakerphone setting: auto, true or false
-    private val useSpeakerphone: String?
-
-    // Proximity sensor object. It measures the proximity of an object in cm
-    // relative to the view screen of a device and can therefore be used to
-    // assist device switching (close to ear <=> use headset earpiece if
-    // available, far from ear <=> use speaker phone).
-    private var proximitySensor: AppRTCProximitySensor?
-
-    // Handles all tasks related to Bluetooth headset devices.
-    private val bluetoothManager: AppRTCBluetoothManager
-
-    // Contains a list of available audio devices. A Set collection is used to
-    // avoid duplicate elements.
-    private var audioDevices: MutableSet<AudioDevice> = HashSet()
-
-    // Broadcast receiver for wired headset intent broadcasts.
-    private val wiredHeadsetReceiver: BroadcastReceiver
-
-    // Callback method for changes in audio focus.
-    private var audioFocusChangeListener: AudioManager.OnAudioFocusChangeListener? = null
-
-    /**
-     * This method is called when the proximity sensor reports a state change,
-     * e.g. from "NEAR to FAR" or from "FAR to NEAR".
-     */
-    private fun onProximitySensorChangedState() {
-        if (useSpeakerphone != SPEAKERPHONE_AUTO) {
-            return
-        }
-
-        // The proximity sensor should only be activated when there are exactly two
-        // available audio devices.
-        if (audioDevices.size == 2 && audioDevices.contains(AudioDevice.EARPIECE)
-            && audioDevices.contains(AudioDevice.SPEAKER_PHONE)
-        ) {
-            if (proximitySensor!!.sensorReportsNearState()) {
-                // Sensor reports that a "handset is being held up to a person's ear",
-                // or "something is covering the light sensor".
-                setAudioDeviceInternal(AudioDevice.EARPIECE)
-            } else {
-                // Sensor reports that a "handset is removed from a person's ear", or
-                // "the light sensor is no longer covered".
-                setAudioDeviceInternal(AudioDevice.SPEAKER_PHONE)
-            }
-        }
-    }
-
-    /* Receiver which handles changes in wired headset availability. */
-    private inner class WiredHeadsetReceiver : BroadcastReceiver() {
-        override fun onReceive(context: Context, intent: Intent) {
-            val state = intent.getIntExtra("state", STATE_UNPLUGGED)
-            val microphone = intent.getIntExtra("microphone", HAS_NO_MIC)
-            val name = intent.getStringExtra("name")
-            Timber.d(
-                "WiredHeadsetReceiver.onReceive" + AppRTCUtils.threadInfo + ": "
-                        + "a=" + intent.action + ", s="
-                        + (if (state == STATE_UNPLUGGED) "unplugged" else "plugged") + ", m="
-                        + (if (microphone == HAS_MIC) "mic" else "no mic") + ", n=" + name + ", sb="
-                        + isInitialStickyBroadcast
-            )
-            hasWiredHeadset = state == STATE_PLUGGED
-            updateAudioDeviceState()
-        }
-
-    }
-
-    // TODO(henrika): audioManager.requestAudioFocus() is deprecated.
-    fun start(audioManagerEvents: AudioManagerEvents?) {
-        Timber.d("start")
-        ThreadUtils.checkIsOnMainThread()
-        if (amState == AudioManagerState.RUNNING) {
-            Timber.e("AudioManager is already active")
-            return
-        }
-        // TODO(henrika): perhaps call new method called preInitAudio() here if UNINITIALIZED.
-        Timber.d("AudioManager starts...")
-        this.audioManagerEvents = audioManagerEvents
-        amState = AudioManagerState.RUNNING
-
-        // Store current audio state so we can restore it when stop() is called.
-        savedAudioMode = audioManager.mode
-        savedIsSpeakerPhoneOn = audioManager.isSpeakerphoneOn
-        savedIsMicrophoneMute = audioManager.isMicrophoneMute
-        hasWiredHeadset = hasWiredHeadset()
-
-        // Create an AudioManager.OnAudioFocusChangeListener instance.
-        audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
-
-            // Called on the listener to notify if the audio focus for this listener has been changed.
-            // The |focusChange| value indicates whether the focus was gained, whether the focus was lost,
-            // and whether that loss is transient, or whether the new focus holder will hold it for an
-            // unknown amount of time.
-            // TODO(henrika): possibly extend support of handling audio-focus changes. Only contains
-            // logging for now.
-            val typeOfChange = when (focusChange) {
-                AudioManager.AUDIOFOCUS_GAIN -> "AUDIOFOCUS_GAIN"
-                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT -> "AUDIOFOCUS_GAIN_TRANSIENT"
-                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE -> "AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE"
-                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK -> "AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK"
-                AudioManager.AUDIOFOCUS_LOSS -> "AUDIOFOCUS_LOSS"
-                AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> "AUDIOFOCUS_LOSS_TRANSIENT"
-                AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> "AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK"
-                else -> "AUDIOFOCUS_INVALID"
-            }
-            Timber.d("onAudioFocusChange: $typeOfChange")
-        }
-
-        // Request audio playout focus (without ducking) and install listener for changes in focus.
-        val result = audioManager.requestAudioFocus(
-            audioFocusChangeListener,
-            AudioManager.STREAM_VOICE_CALL,
-            AudioManager.AUDIOFOCUS_GAIN,
-        )
-        if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
-            Timber.d("Audio focus request granted for VOICE_CALL streams")
-        } else {
-            Timber.e("Audio focus request failed")
-        }
-
-        // Start by setting MODE_IN_COMMUNICATION as default audio mode. It is
-        // required to be in this mode when playout and/or recording starts for
-        // best possible VoIP performance.
-        audioManager.mode = AudioManager.MODE_IN_COMMUNICATION
-
-        // Always disable microphone mute during a WebRTC call.
-        setMicrophoneMute(false)
-
-        // Set initial device states.
-        userSelectedAudioDevice = AudioDevice.NONE
-        selectedAudioDevice = AudioDevice.NONE
-        audioDevices.clear()
-
-        // Initialize and start Bluetooth if a BT device is available or initiate
-        // detection of new (enabled) BT devices.
-        bluetoothManager.start()
-
-        // Do initial selection of audio device. This setting can later be changed
-        // either by adding/removing a BT or wired headset or by covering/uncovering
-        // the proximity sensor.
-        updateAudioDeviceState()
-
-        // Register receiver for broadcast intents related to adding/removing a
-        // wired headset.
-        registerReceiver(wiredHeadsetReceiver, IntentFilter(Intent.ACTION_HEADSET_PLUG))
-        Timber.d("AudioManager started")
-    }
-
-    // TODO(henrika): audioManager.abandonAudioFocus() is deprecated.
-    fun stop() {
-        Timber.d("stop")
-        ThreadUtils.checkIsOnMainThread()
-        if (amState != AudioManagerState.RUNNING) {
-            Timber.e("Trying to stop AudioManager in incorrect state: $amState")
-            return
-        }
-        amState = AudioManagerState.UNINITIALIZED
-        unregisterReceiver(wiredHeadsetReceiver)
-        bluetoothManager.stop()
-
-        // Restore previously stored audio states.
-        setSpeakerphoneOn(savedIsSpeakerPhoneOn)
-        setMicrophoneMute(savedIsMicrophoneMute)
-        audioManager.mode = savedAudioMode
-
-        // Abandon audio focus. Gives the previous focus owner, if any, focus.
-        audioManager.abandonAudioFocus(audioFocusChangeListener)
-        audioFocusChangeListener = null
-        Timber.d("Abandoned audio focus for VOICE_CALL streams")
-        if (proximitySensor != null) {
-            proximitySensor!!.stop()
-            proximitySensor = null
-        }
-        audioManagerEvents = null
-        Timber.d("AudioManager stopped")
-    }
-
-    /** Changes selection of the currently active audio device.  */
-    private fun setAudioDeviceInternal(device: AudioDevice) {
-        Timber.d("setAudioDeviceInternal(device=$device)")
-        AppRTCUtils.assertIsTrue(audioDevices.contains(device))
-        when (device) {
-            AudioDevice.SPEAKER_PHONE -> setSpeakerphoneOn(true)
-            AudioDevice.EARPIECE -> setSpeakerphoneOn(false)
-            AudioDevice.WIRED_HEADSET -> setSpeakerphoneOn(false)
-            AudioDevice.BLUETOOTH -> setSpeakerphoneOn(false)
-            else -> Timber.e("Invalid audio device selection")
-        }
-        selectedAudioDevice = device
-    }
-
-    /**
-     * Changes default audio device.
-     * TODO(henrika): add usage of this method in the AppRTCMobile client.
-     */
-    fun setDefaultAudioDevice(defaultDevice: AudioDevice?) {
-        ThreadUtils.checkIsOnMainThread()
-        when (defaultDevice) {
-            AudioDevice.SPEAKER_PHONE -> defaultAudioDevice = defaultDevice
-            AudioDevice.EARPIECE -> defaultAudioDevice = if (hasEarpiece()) {
-                defaultDevice
-            } else {
-                AudioDevice.SPEAKER_PHONE
-            }
-            else -> Timber.e("Invalid default audio device selection")
-        }
-        Timber.d("setDefaultAudioDevice(device=$defaultAudioDevice)")
-        updateAudioDeviceState()
-    }
-
-    /** Changes selection of the currently active audio device.  */
-    fun selectAudioDevice(device: AudioDevice) {
-        ThreadUtils.checkIsOnMainThread()
-        if (!audioDevices.contains(device)) {
-            Timber.e("Can not select $device from available $audioDevices")
-        }
-        userSelectedAudioDevice = device
-        updateAudioDeviceState()
-    }
-
-    /** Returns current set of available/selectable audio devices.  */
-    fun getAudioDevices(): Set<AudioDevice> {
-        ThreadUtils.checkIsOnMainThread()
-        return Collections.unmodifiableSet(HashSet(audioDevices))
-    }
-
-    /** Returns the currently selected audio device.  */
-    fun getSelectedAudioDevice(): AudioDevice? {
-        ThreadUtils.checkIsOnMainThread()
-        return selectedAudioDevice
-    }
-
-    /** Helper method for receiver registration.  */
-    private fun registerReceiver(receiver: BroadcastReceiver, filter: IntentFilter) {
-        apprtcContext.registerReceiver(receiver, filter)
-    }
-
-    /** Helper method for unregistration of an existing receiver.  */
-    private fun unregisterReceiver(receiver: BroadcastReceiver) {
-        apprtcContext.unregisterReceiver(receiver)
-    }
-
-    /** Sets the speaker phone mode.  */
-    private fun setSpeakerphoneOn(on: Boolean) {
-        val wasOn = audioManager.isSpeakerphoneOn
-        if (wasOn == on) {
-            return
-        }
-        audioManager.isSpeakerphoneOn = on
-    }
-
-    /** Sets the microphone mute state.  */
-    private fun setMicrophoneMute(on: Boolean) {
-        val wasMuted = audioManager.isMicrophoneMute
-        if (wasMuted == on) {
-            return
-        }
-        audioManager.isMicrophoneMute = on
-    }
-
-    /** Gets the current earpiece state.  */
-    private fun hasEarpiece(): Boolean {
-        return apprtcContext.packageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY)
-    }
-
-    /**
-     * Checks whether a wired headset is connected or not.
-     * This is not a valid indication that audio playback is actually over
-     * the wired headset as audio routing depends on other conditions. We
-     * only use it as an early indicator (during initialization) of an attached
-     * wired headset.
-     */
-    private fun hasWiredHeadset(): Boolean {
-        return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
-            @Suppress("DEPRECATION")
-            audioManager.isWiredHeadsetOn
-        } else {
-            val devices = audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS or AudioManager.GET_DEVICES_INPUTS)
-            for (device in devices) {
-                val type = device.type
-                if (type == AudioDeviceInfo.TYPE_WIRED_HEADSET) {
-                    Timber.d("hasWiredHeadset: found wired headset")
-                    return true
-                } else if (type == AudioDeviceInfo.TYPE_USB_DEVICE) {
-                    Timber.d("hasWiredHeadset: found USB audio device")
-                    return true
-                }
-            }
-            false
-        }
-    }
-
-    /**
-     * Updates list of possible audio devices and make new device selection.
-     * TODO(henrika): add unit test to verify all state transitions.
-     */
-    fun updateAudioDeviceState() {
-        ThreadUtils.checkIsOnMainThread()
-        Timber.d(
-            "--- updateAudioDeviceState: "
-                    + "wired headset=" + hasWiredHeadset + ", "
-                    + "BT state=" + bluetoothManager.state
-        )
-        Timber.d(
-            "Device status: "
-                    + "available=" + audioDevices + ", "
-                    + "selected=" + selectedAudioDevice + ", "
-                    + "user selected=" + userSelectedAudioDevice
-        )
-
-        // Check if any Bluetooth headset is connected. The internal BT state will
-        // change accordingly.
-        // TODO(henrika): perhaps wrap required state into BT manager.
-        if (bluetoothManager.state === AppRTCBluetoothManager.State.HEADSET_AVAILABLE || bluetoothManager.state === AppRTCBluetoothManager.State.HEADSET_UNAVAILABLE || bluetoothManager.state === AppRTCBluetoothManager.State.SCO_DISCONNECTING) {
-            bluetoothManager.updateDevice()
-        }
-
-        // Update the set of available audio devices.
-        val newAudioDevices: MutableSet<AudioDevice> = HashSet()
-        if (bluetoothManager.state === AppRTCBluetoothManager.State.SCO_CONNECTED || bluetoothManager.state === AppRTCBluetoothManager.State.SCO_CONNECTING || bluetoothManager.state === AppRTCBluetoothManager.State.HEADSET_AVAILABLE) {
-            newAudioDevices.add(AudioDevice.BLUETOOTH)
-        }
-        if (hasWiredHeadset) {
-            // If a wired headset is connected, then it is the only possible option.
-            newAudioDevices.add(AudioDevice.WIRED_HEADSET)
-        } else {
-            // No wired headset, hence the audio-device list can contain speaker
-            // phone (on a tablet), or speaker phone and earpiece (on mobile phone).
-            newAudioDevices.add(AudioDevice.SPEAKER_PHONE)
-            if (hasEarpiece()) {
-                newAudioDevices.add(AudioDevice.EARPIECE)
-            }
-        }
-        // Store state which is set to true if the device list has changed.
-        var audioDeviceSetUpdated = audioDevices != newAudioDevices
-        // Update the existing audio device set.
-        audioDevices = newAudioDevices
-        // Correct user selected audio devices if needed.
-        if (bluetoothManager.state === AppRTCBluetoothManager.State.HEADSET_UNAVAILABLE
-            && userSelectedAudioDevice == AudioDevice.BLUETOOTH
-        ) {
-            // If BT is not available, it can't be the user selection.
-            userSelectedAudioDevice = AudioDevice.NONE
-        }
-        if (hasWiredHeadset && userSelectedAudioDevice == AudioDevice.SPEAKER_PHONE) {
-            // If user selected speaker phone, but then plugged wired headset then make
-            // wired headset as user selected device.
-            userSelectedAudioDevice = AudioDevice.WIRED_HEADSET
-        }
-        if (!hasWiredHeadset && userSelectedAudioDevice == AudioDevice.WIRED_HEADSET) {
-            // If user selected wired headset, but then unplugged wired headset then make
-            // speaker phone as user selected device.
-            userSelectedAudioDevice = AudioDevice.SPEAKER_PHONE
-        }
-
-        // Need to start Bluetooth if it is available and user either selected it explicitly or
-        // user did not select any output device.
-        val needBluetoothAudioStart = (bluetoothManager.state === AppRTCBluetoothManager.State.HEADSET_AVAILABLE
-                && (userSelectedAudioDevice == AudioDevice.NONE
-                || userSelectedAudioDevice == AudioDevice.BLUETOOTH))
-
-        // Need to stop Bluetooth audio if user selected different device and
-        // Bluetooth SCO connection is established or in the process.
-        val needBluetoothAudioStop = ((bluetoothManager.state === AppRTCBluetoothManager.State.SCO_CONNECTED
-                || bluetoothManager.state === AppRTCBluetoothManager.State.SCO_CONNECTING)
-                && (userSelectedAudioDevice != AudioDevice.NONE
-                && userSelectedAudioDevice != AudioDevice.BLUETOOTH))
-        if (bluetoothManager.state === AppRTCBluetoothManager.State.HEADSET_AVAILABLE || bluetoothManager.state === AppRTCBluetoothManager.State.SCO_CONNECTING || bluetoothManager.state === AppRTCBluetoothManager.State.SCO_CONNECTED) {
-            Timber.d(
-                "Need BT audio: start=" + needBluetoothAudioStart + ", "
-                        + "stop=" + needBluetoothAudioStop + ", "
-                        + "BT state=" + bluetoothManager.state
-            )
-        }
-
-        // Start or stop Bluetooth SCO connection given states set earlier.
-        if (needBluetoothAudioStop) {
-            bluetoothManager.stopScoAudio()
-            bluetoothManager.updateDevice()
-        }
-        if (needBluetoothAudioStart && !needBluetoothAudioStop) {
-            // Attempt to start Bluetooth SCO audio (takes a few second to start).
-            if (!bluetoothManager.startScoAudio()) {
-                // Remove BLUETOOTH from list of available devices since SCO failed.
-                audioDevices.remove(AudioDevice.BLUETOOTH)
-                audioDeviceSetUpdated = true
-            }
-        }
-
-        // Update selected audio device.
-        val newAudioDevice = if (bluetoothManager.state === AppRTCBluetoothManager.State.SCO_CONNECTED) {
-            // If a Bluetooth is connected, then it should be used as output audio
-            // device. Note that it is not sufficient that a headset is available;
-            // an active SCO channel must also be up and running.
-            AudioDevice.BLUETOOTH
-        } else if (hasWiredHeadset) {
-            // If a wired headset is connected, but Bluetooth is not, then wired headset is used as
-            // audio device.
-            AudioDevice.WIRED_HEADSET
-        } else {
-            // No wired headset and no Bluetooth, hence the audio-device list can contain speaker
-            // phone (on a tablet), or speaker phone and earpiece (on mobile phone).
-            // |defaultAudioDevice| contains either AudioDevice.SPEAKER_PHONE or AudioDevice.EARPIECE
-            // depending on the user's selection.
-            defaultAudioDevice
-        }
-        // Switch to new device but only if there has been any changes.
-        if (newAudioDevice != selectedAudioDevice || audioDeviceSetUpdated) {
-            // Do the required device switch.
-            setAudioDeviceInternal(newAudioDevice)
-            Timber.d(
-                "New device status: "
-                        + "available=" + audioDevices + ", "
-                        + "selected=" + newAudioDevice
-            )
-            if (audioManagerEvents != null) {
-                // Notify a listening client that audio device has been changed.
-                audioManagerEvents!!.onAudioDeviceChanged(selectedAudioDevice, audioDevices)
-            }
-        }
-        Timber.d("--- updateAudioDeviceState done")
-    }
-
-    companion object {
-        private const val TAG = "AppRTCAudioManager"
-        private const val SPEAKERPHONE_AUTO = "auto"
-        private const val SPEAKERPHONE_TRUE = "true"
-        private const val SPEAKERPHONE_FALSE = "false"
-
-        private const val STATE_UNPLUGGED = 0
-        private const val STATE_PLUGGED = 1
-        private const val HAS_NO_MIC = 0
-        private const val HAS_MIC = 1
-    }
-
-    init {
-        Timber.d("ctor")
-        ThreadUtils.checkIsOnMainThread()
-        apprtcContext = context
-        audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-        bluetoothManager = create(context, this)
-        wiredHeadsetReceiver = WiredHeadsetReceiver()
-        amState = AudioManagerState.UNINITIALIZED
-        useSpeakerphone = SPEAKERPHONE_TRUE
-        defaultAudioDevice = AudioDevice.SPEAKER_PHONE
-
-        // Create and initialize the proximity sensor.
-        // Tablet devices (e.g. Nexus 7) does not support proximity sensors.
-        // Note that, the sensor will not be active until start() has been called.
-        proximitySensor = create(context) { onProximitySensorChangedState() }
-        Timber.d("defaultAudioDevice: $defaultAudioDevice")
-        AppRTCUtils.logDeviceInfo(TAG)
-    }
-}

-/*
- *  Copyright 2016 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 io.livekit.android.sample.audio
-
-import android.Manifest
-import android.annotation.SuppressLint
-import android.bluetooth.BluetoothAdapter
-import android.bluetooth.BluetoothDevice
-import android.bluetooth.BluetoothHeadset
-import android.bluetooth.BluetoothProfile
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.content.pm.PackageManager
-import android.media.AudioManager
-import android.os.Build
-import android.os.Handler
-import android.os.Looper
-import android.os.Process
-import org.webrtc.ThreadUtils
-import timber.log.Timber
-
-/**
- * AppRTCProximitySensor manages functions related to Bluetoth devices in the
- * AppRTC demo.
- */
-@Suppress("MemberVisibilityCanBePrivate")
-@SuppressLint("BinaryOperationInTimber")
-open class AppRTCBluetoothManager
-constructor(context: Context, audioManager: AppRTCAudioManager) {
-    // Bluetooth connection state.
-    enum class State {
-        // Bluetooth is not available; no adapter or Bluetooth is off.
-        UNINITIALIZED,  // Bluetooth error happened when trying to start Bluetooth.
-        ERROR,  // Bluetooth proxy object for the Headset profile exists, but no connected headset devices,
-
-        // SCO is not started or disconnected.
-        HEADSET_UNAVAILABLE,  // Bluetooth proxy object for the Headset profile connected, connected Bluetooth headset
-
-        // present, but SCO is not started or disconnected.
-        HEADSET_AVAILABLE,  // Bluetooth audio SCO connection with remote device is closing.
-        SCO_DISCONNECTING,  // Bluetooth audio SCO connection with remote device is initiated.
-        SCO_CONNECTING,  // Bluetooth audio SCO connection with remote device is established.
-        SCO_CONNECTED
-    }
-
-    private val apprtcContext: Context
-    private val apprtcAudioManager: AppRTCAudioManager
-    private val audioManager: AudioManager?
-    private val handler: Handler
-    var scoConnectionAttempts = 0
-    private var bluetoothState: State
-    private val bluetoothServiceListener: BluetoothProfile.ServiceListener
-    private var bluetoothAdapter: BluetoothAdapter? = null
-    private var bluetoothHeadset: BluetoothHeadset? = null
-    private var bluetoothDevice: BluetoothDevice? = null
-    private val bluetoothHeadsetReceiver: BroadcastReceiver
-
-    // Runs when the Bluetooth timeout expires. We use that timeout after calling
-    // startScoAudio() or stopScoAudio() because we're not guaranteed to get a
-    // callback after those calls.
-    private val bluetoothTimeoutRunnable = Runnable { bluetoothTimeout() }
-
-    /**
-     * Implementation of an interface that notifies BluetoothProfile IPC clients when they have been
-     * connected to or disconnected from the service.
-     */
-    private inner class BluetoothServiceListener : BluetoothProfile.ServiceListener {
-        // Called to notify the client when the proxy object has been connected to the service.
-        // Once we have the profile proxy object, we can use it to monitor the state of the
-        // connection and perform other operations that are relevant to the headset profile.
-        override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
-            if (profile != BluetoothProfile.HEADSET || bluetoothState == State.UNINITIALIZED) {
-                return
-            }
-            Timber.d("BluetoothServiceListener.onServiceConnected: BT state=$bluetoothState")
-            // Android only supports one connected Bluetooth Headset at a time.
-            bluetoothHeadset = proxy as BluetoothHeadset
-            updateAudioDeviceState()
-            Timber.d("onServiceConnected done: BT state=$bluetoothState")
-        }
-
-        /** Notifies the client when the proxy object has been disconnected from the service.  */
-        override fun onServiceDisconnected(profile: Int) {
-            if (profile != BluetoothProfile.HEADSET || bluetoothState == State.UNINITIALIZED) {
-                return
-            }
-            Timber.d("BluetoothServiceListener.onServiceDisconnected: BT state=$bluetoothState")
-            stopScoAudio()
-            bluetoothHeadset = null
-            bluetoothDevice = null
-            bluetoothState = State.HEADSET_UNAVAILABLE
-            updateAudioDeviceState()
-            Timber.d("onServiceDisconnected done: BT state=$bluetoothState")
-        }
-    }
-
-    // Intent broadcast receiver which handles changes in Bluetooth device availability.
-    // Detects headset changes and Bluetooth SCO state changes.
-    private inner class BluetoothHeadsetBroadcastReceiver : BroadcastReceiver() {
-        override fun onReceive(context: Context, intent: Intent) {
-            if (bluetoothState == State.UNINITIALIZED) {
-                return
-            }
-            val action = intent.action
-            // Change in connection state of the Headset profile. Note that the
-            // change does not tell us anything about whether we're streaming
-            // audio to BT over SCO. Typically received when user turns on a BT
-            // headset while audio is active using another audio device.
-            if (action == BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED) {
-                val state = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, BluetoothHeadset.STATE_DISCONNECTED)
-                Timber.d(
-                    """BluetoothHeadsetBroadcastReceiver.onReceive: a=ACTION_CONNECTION_STATE_CHANGED, s=${
-                        stateToString(
-                            state
-                        )
-                    }, sb=$isInitialStickyBroadcast, BT state: $bluetoothState"""
-                )
-                if (state == BluetoothHeadset.STATE_CONNECTED) {
-                    scoConnectionAttempts = 0
-                    updateAudioDeviceState()
-                } else if (state == BluetoothHeadset.STATE_CONNECTING) {
-                    // No action needed.
-                } else if (state == BluetoothHeadset.STATE_DISCONNECTING) {
-                    // No action needed.
-                } else if (state == BluetoothHeadset.STATE_DISCONNECTED) {
-                    // Bluetooth is probably powered off during the call.
-                    stopScoAudio()
-                    updateAudioDeviceState()
-                }
-                // Change in the audio (SCO) connection state of the Headset profile.
-                // Typically received after call to startScoAudio() has finalized.
-            } else if (action == BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED) {
-                val state = intent.getIntExtra(
-                    BluetoothHeadset.EXTRA_STATE, BluetoothHeadset.STATE_AUDIO_DISCONNECTED
-                )
-                Timber.d(
-                    "BluetoothHeadsetBroadcastReceiver.onReceive: "
-                            + "a=ACTION_AUDIO_STATE_CHANGED, "
-                            + "s=" + stateToString(state) + ", "
-                            + "sb=" + isInitialStickyBroadcast + ", "
-                            + "BT state: " + bluetoothState
-                )
-                if (state == BluetoothHeadset.STATE_AUDIO_CONNECTED) {
-                    cancelTimer()
-                    if (bluetoothState == State.SCO_CONNECTING) {
-                        Timber.d("+++ Bluetooth audio SCO is now connected")
-                        bluetoothState = State.SCO_CONNECTED
-                        scoConnectionAttempts = 0
-                        updateAudioDeviceState()
-                    } else {
-                        Timber.w("Unexpected state BluetoothHeadset.STATE_AUDIO_CONNECTED")
-                    }
-                } else if (state == BluetoothHeadset.STATE_AUDIO_CONNECTING) {
-                    Timber.d("+++ Bluetooth audio SCO is now connecting...")
-                } else if (state == BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
-                    Timber.d("+++ Bluetooth audio SCO is now disconnected")
-                    if (isInitialStickyBroadcast) {
-                        Timber.d("Ignore STATE_AUDIO_DISCONNECTED initial sticky broadcast.")
-                        return
-                    }
-                    updateAudioDeviceState()
-                }
-            }
-            Timber.d("onReceive done: BT state=$bluetoothState")
-        }
-    }
-
-    /** Returns the internal state.  */
-    val state: State
-        get() {
-            ThreadUtils.checkIsOnMainThread()
-            return bluetoothState
-        }
-
-    /**
-     * Activates components required to detect Bluetooth devices and to enable
-     * BT SCO (audio is routed via BT SCO) for the headset profile. The end
-     * state will be HEADSET_UNAVAILABLE but a state machine has started which
-     * will start a state change sequence where the final outcome depends on
-     * if/when the BT headset is enabled.
-     * Example of state change sequence when start() is called while BT device
-     * is connected and enabled:
-     * UNINITIALIZED --> HEADSET_UNAVAILABLE --> HEADSET_AVAILABLE -->
-     * SCO_CONNECTING --> SCO_CONNECTED <==> audio is now routed via BT SCO.
-     * Note that the AppRTCAudioManager is also involved in driving this state
-     * change.
-     */
-    fun start() {
-        ThreadUtils.checkIsOnMainThread()
-        Timber.d("start")
-        if (!hasPermission(apprtcContext, Manifest.permission.BLUETOOTH) &&
-            !(Build.VERSION.SDK_INT >= Build.VERSION_CODES.S &&
-                    hasPermission(apprtcContext, Manifest.permission.BLUETOOTH_CONNECT))
-        ) {
-            Timber.w("Process (pid=" + Process.myPid() + ") lacks BLUETOOTH permission")
-            return
-        }
-        if (bluetoothState != State.UNINITIALIZED) {
-            Timber.w("Invalid BT state")
-            return
-        }
-        bluetoothHeadset = null
-        bluetoothDevice = null
-        scoConnectionAttempts = 0
-        // Get a handle to the default local Bluetooth adapter.
-        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
-        if (bluetoothAdapter == null) {
-            Timber.w("Device does not support Bluetooth")
-            return
-        }
-        // Ensure that the device supports use of BT SCO audio for off call use cases.
-        if (!audioManager!!.isBluetoothScoAvailableOffCall) {
-            Timber.e("Bluetooth SCO audio is not available off call")
-            return
-        }
-        logBluetoothAdapterInfo(bluetoothAdapter!!)
-        // Establish a connection to the HEADSET profile (includes both Bluetooth Headset and
-        // Hands-Free) proxy object and install a listener.
-        if (!getBluetoothProfileProxy(
-                apprtcContext, bluetoothServiceListener, BluetoothProfile.HEADSET
-            )
-        ) {
-            Timber.e("BluetoothAdapter.getProfileProxy(HEADSET) failed")
-            return
-        }
-        // Register receivers for BluetoothHeadset change notifications.
-        val bluetoothHeadsetFilter = IntentFilter()
-        // Register receiver for change in connection state of the Headset profile.
-        bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)
-        // Register receiver for change in audio connection state of the Headset profile.
-        bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED)
-        registerReceiver(bluetoothHeadsetReceiver, bluetoothHeadsetFilter)
-        Timber.d(
-            "HEADSET profile state: "
-                    + stateToString(bluetoothAdapter!!.getProfileConnectionState(BluetoothProfile.HEADSET))
-        )
-        Timber.d("Bluetooth proxy for headset profile has started")
-        bluetoothState = State.HEADSET_UNAVAILABLE
-        Timber.d("start done: BT state=$bluetoothState")
-    }
-
-    /** Stops and closes all components related to Bluetooth audio.  */
-    fun stop() {
-        ThreadUtils.checkIsOnMainThread()
-        Timber.d("stop: BT state=$bluetoothState")
-        if (bluetoothAdapter == null) {
-            return
-        }
-        // Stop BT SCO connection with remote device if needed.
-        stopScoAudio()
-        // Close down remaining BT resources.
-        if (bluetoothState == State.UNINITIALIZED) {
-            return
-        }
-        unregisterReceiver(bluetoothHeadsetReceiver)
-        cancelTimer()
-        if (bluetoothHeadset != null) {
-            bluetoothAdapter!!.closeProfileProxy(BluetoothProfile.HEADSET, bluetoothHeadset)
-            bluetoothHeadset = null
-        }
-        bluetoothAdapter = null
-        bluetoothDevice = null
-        bluetoothState = State.UNINITIALIZED
-        Timber.d("stop done: BT state=$bluetoothState")
-    }
-
-    /**
-     * Starts Bluetooth SCO connection with remote device.
-     * Note that the phone application always has the priority on the usage of the SCO connection
-     * for telephony. If this method is called while the phone is in call it will be ignored.
-     * Similarly, if a call is received or sent while an application is using the SCO connection,
-     * the connection will be lost for the application and NOT returned automatically when the call
-     * ends. Also note that: up to and including API version JELLY_BEAN_MR1, this method initiates a
-     * virtual voice call to the Bluetooth headset. After API version JELLY_BEAN_MR2 only a raw SCO
-     * audio connection is established.
-     * TODO(henrika): should we add support for virtual voice call to BT headset also for JBMR2 and
-     * higher. It might be required to initiates a virtual voice call since many devices do not
-     * accept SCO audio without a "call".
-     */
-    fun startScoAudio(): Boolean {
-        ThreadUtils.checkIsOnMainThread()
-        Timber.d(
-            "startSco: BT state=" + bluetoothState + ", "
-                    + "attempts: " + scoConnectionAttempts + ", "
-                    + "SCO is on: " + isScoOn
-        )
-        if (scoConnectionAttempts >= MAX_SCO_CONNECTION_ATTEMPTS) {
-            Timber.e("BT SCO connection fails - no more attempts")
-            return false
-        }
-        if (bluetoothState != State.HEADSET_AVAILABLE) {
-            Timber.e("BT SCO connection fails - no headset available")
-            return false
-        }
-        // Start BT SCO channel and wait for ACTION_AUDIO_STATE_CHANGED.
-        Timber.d("Starting Bluetooth SCO and waits for ACTION_AUDIO_STATE_CHANGED...")
-        // The SCO connection establishment can take several seconds, hence we cannot rely on the
-        // connection to be available when the method returns but instead register to receive the
-        // intent ACTION_SCO_AUDIO_STATE_UPDATED and wait for the state to be SCO_AUDIO_STATE_CONNECTED.
-        bluetoothState = State.SCO_CONNECTING
-        audioManager!!.startBluetoothSco()
-        audioManager.isBluetoothScoOn = true
-        scoConnectionAttempts++
-        startTimer()
-        Timber.d(
-            "startScoAudio done: BT state=" + bluetoothState + ", "
-                    + "SCO is on: " + isScoOn
-        )
-        return true
-    }
-
-    /** Stops Bluetooth SCO connection with remote device.  */
-    fun stopScoAudio() {
-        ThreadUtils.checkIsOnMainThread()
-        Timber.d(
-            "stopScoAudio: BT state=" + bluetoothState + ", "
-                    + "SCO is on: " + isScoOn
-        )
-        if (bluetoothState != State.SCO_CONNECTING && bluetoothState != State.SCO_CONNECTED) {
-            return
-        }
-        cancelTimer()
-        audioManager!!.stopBluetoothSco()
-        audioManager.isBluetoothScoOn = false
-        bluetoothState = State.SCO_DISCONNECTING
-        Timber.d(
-            "stopScoAudio done: BT state=" + bluetoothState + ", "
-                    + "SCO is on: " + isScoOn
-        )
-    }
-
-    /**
-     * Use the BluetoothHeadset proxy object (controls the Bluetooth Headset
-     * Service via IPC) to update the list of connected devices for the HEADSET
-     * profile. The internal state will change to HEADSET_UNAVAILABLE or to
-     * HEADSET_AVAILABLE and |bluetoothDevice| will be mapped to the connected
-     * device if available.
-     */
-    fun updateDevice() {
-        if (bluetoothState == State.UNINITIALIZED || bluetoothHeadset == null) {
-            return
-        }
-        Timber.d("updateDevice")
-        // Get connected devices for the headset profile. Returns the set of
-        // devices which are in state STATE_CONNECTED. The BluetoothDevice class
-        // is just a thin wrapper for a Bluetooth hardware address.
-        val devices = bluetoothHeadset!!.connectedDevices
-        if (devices.isEmpty()) {
-            bluetoothDevice = null
-            bluetoothState = State.HEADSET_UNAVAILABLE
-            Timber.d("No connected bluetooth headset")
-        } else {
-            // Always use first device in list. Android only supports one device.
-            bluetoothDevice = devices[0]
-            bluetoothState = State.HEADSET_AVAILABLE
-            Timber.d(
-                "Connected bluetooth headset: "
-                        + "name=" + bluetoothDevice!!.name + ", "
-                        + "state=" + stateToString(bluetoothHeadset!!.getConnectionState(bluetoothDevice))
-                        + ", SCO audio=" + bluetoothHeadset!!.isAudioConnected(bluetoothDevice)
-            )
-        }
-        Timber.d("updateDevice done: BT state=$bluetoothState")
-    }
-
-    /**
-     * Stubs for test mocks.
-     */
-    protected fun getAudioManager(context: Context): AudioManager? {
-        return context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-    }
-
-    protected fun registerReceiver(receiver: BroadcastReceiver?, filter: IntentFilter?) {
-        apprtcContext.registerReceiver(receiver, filter)
-    }
-
-    protected fun unregisterReceiver(receiver: BroadcastReceiver?) {
-        apprtcContext.unregisterReceiver(receiver)
-    }
-
-    protected fun getBluetoothProfileProxy(
-        context: Context?, listener: BluetoothProfile.ServiceListener?, profile: Int
-    ): Boolean {
-        return bluetoothAdapter!!.getProfileProxy(context, listener, profile)
-    }
-
-    protected fun hasPermission(context: Context?, permission: String?): Boolean {
-        return (apprtcContext.checkPermission(permission!!, Process.myPid(), Process.myUid())
-                == PackageManager.PERMISSION_GRANTED)
-    }
-
-    /** Logs the state of the local Bluetooth adapter.  */
-    @SuppressLint("HardwareIds")
-    protected fun logBluetoothAdapterInfo(localAdapter: BluetoothAdapter) {
-        Timber.d(
-            "BluetoothAdapter: "
-                    + "enabled=" + localAdapter.isEnabled + ", "
-                    + "state=" + stateToString(localAdapter.state) + ", "
-                    + "name=" + localAdapter.name + ", "
-                    + "address=" + localAdapter.address
-        )
-        // Log the set of BluetoothDevice objects that are bonded (paired) to the local adapter.
-        val pairedDevices = localAdapter.bondedDevices
-        if (!pairedDevices.isEmpty()) {
-            Timber.d("paired devices:")
-            for (device in pairedDevices) {
-                Timber.d(" name=" + device.name + ", address=" + device.address)
-            }
-        }
-    }
-
-    /** Ensures that the audio manager updates its list of available audio devices.  */
-    private fun updateAudioDeviceState() {
-        ThreadUtils.checkIsOnMainThread()
-        Timber.d("updateAudioDeviceState")
-        apprtcAudioManager.updateAudioDeviceState()
-    }
-
-    /** Starts timer which times out after BLUETOOTH_SCO_TIMEOUT_MS milliseconds.  */
-    private fun startTimer() {
-        ThreadUtils.checkIsOnMainThread()
-        Timber.d("startTimer")
-        handler.postDelayed(bluetoothTimeoutRunnable, BLUETOOTH_SCO_TIMEOUT_MS.toLong())
-    }
-
-    /** Cancels any outstanding timer tasks.  */
-    private fun cancelTimer() {
-        ThreadUtils.checkIsOnMainThread()
-        Timber.d("cancelTimer")
-        handler.removeCallbacks(bluetoothTimeoutRunnable)
-    }
-
-    /**
-     * Called when start of the BT SCO channel takes too long time. Usually
-     * happens when the BT device has been turned on during an ongoing call.
-     */
-    private fun bluetoothTimeout() {
-        ThreadUtils.checkIsOnMainThread()
-        if (bluetoothState == State.UNINITIALIZED || bluetoothHeadset == null) {
-            return
-        }
-        Timber.d(
-            "bluetoothTimeout: BT state=" + bluetoothState + ", "
-                    + "attempts: " + scoConnectionAttempts + ", "
-                    + "SCO is on: " + isScoOn
-        )
-        if (bluetoothState != State.SCO_CONNECTING) {
-            return
-        }
-        // Bluetooth SCO should be connecting; check the latest result.
-        var scoConnected = false
-        val devices = bluetoothHeadset!!.connectedDevices
-        if (devices.size > 0) {
-            bluetoothDevice = devices[0]
-            if (bluetoothHeadset!!.isAudioConnected(bluetoothDevice)) {
-                Timber.d("SCO connected with " + bluetoothDevice!!.name)
-                scoConnected = true
-            } else {
-                Timber.d("SCO is not connected with " + bluetoothDevice!!.name)
-            }
-        }
-        if (scoConnected) {
-            // We thought BT had timed out, but it's actually on; updating state.
-            bluetoothState = State.SCO_CONNECTED
-            scoConnectionAttempts = 0
-        } else {
-            // Give up and "cancel" our request by calling stopBluetoothSco().
-            Timber.w("BT failed to connect after timeout")
-            stopScoAudio()
-        }
-        updateAudioDeviceState()
-        Timber.d("bluetoothTimeout done: BT state=$bluetoothState")
-    }
-
-    /** Checks whether audio uses Bluetooth SCO.  */
-    private val isScoOn: Boolean
-        private get() = audioManager!!.isBluetoothScoOn
-
-    /** Converts BluetoothAdapter states into local string representations.  */
-    private fun stateToString(state: Int): String {
-        return when (state) {
-            BluetoothAdapter.STATE_DISCONNECTED -> "DISCONNECTED"
-            BluetoothAdapter.STATE_CONNECTED -> "CONNECTED"
-            BluetoothAdapter.STATE_CONNECTING -> "CONNECTING"
-            BluetoothAdapter.STATE_DISCONNECTING -> "DISCONNECTING"
-            BluetoothAdapter.STATE_OFF -> "OFF"
-            BluetoothAdapter.STATE_ON -> "ON"
-            BluetoothAdapter.STATE_TURNING_OFF ->         // Indicates the local Bluetooth adapter is turning off. Local clients should immediately
-                // attempt graceful disconnection of any remote links.
-                "TURNING_OFF"
-            BluetoothAdapter.STATE_TURNING_ON ->         // Indicates the local Bluetooth adapter is turning on. However local clients should wait
-                // for STATE_ON before attempting to use the adapter.
-                "TURNING_ON"
-            else -> "INVALID"
-        }
-    }
-
-    companion object {
-        private const val TAG = "AppRTCBluetoothManager"
-
-        // Timeout interval for starting or stopping audio to a Bluetooth SCO device.
-        private const val BLUETOOTH_SCO_TIMEOUT_MS = 4000
-
-        // Maximum number of SCO connection attempts.
-        private const val MAX_SCO_CONNECTION_ATTEMPTS = 2
-
-        /** Construction.  */
-        @JvmStatic
-        fun create(context: Context, audioManager: AppRTCAudioManager): AppRTCBluetoothManager {
-            Timber.d("create" + AppRTCUtils.threadInfo)
-            return AppRTCBluetoothManager(context, audioManager)
-        }
-    }
-
-    init {
-        Timber.d("ctor")
-        ThreadUtils.checkIsOnMainThread()
-        apprtcContext = context
-        apprtcAudioManager = audioManager
-        this.audioManager = getAudioManager(context)
-        bluetoothState = State.UNINITIALIZED
-        bluetoothServiceListener = BluetoothServiceListener()
-        bluetoothHeadsetReceiver = BluetoothHeadsetBroadcastReceiver()
-        handler = Handler(Looper.getMainLooper())
-    }
-}

-/*
- *  Copyright 2014 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 io.livekit.android.sample.audio
-
-import android.annotation.SuppressLint
-import android.content.Context
-import android.hardware.Sensor
-import android.hardware.SensorEvent
-import android.hardware.SensorEventListener
-import android.hardware.SensorManager
-import android.os.Build
-import org.webrtc.ThreadUtils
-import timber.log.Timber
-
-/**
- * AppRTCProximitySensor manages functions related to the proximity sensor in
- * the AppRTC demo.
- * On most device, the proximity sensor is implemented as a boolean-sensor.
- * It returns just two values "NEAR" or "FAR". Thresholding is done on the LUX
- * value i.e. the LUX value of the light sensor is compared with a threshold.
- * A LUX-value more than the threshold means the proximity sensor returns "FAR".
- * Anything less than the threshold value and the sensor  returns "NEAR".
- */
-class AppRTCProximitySensor
-private constructor(context: Context, sensorStateListener: Runnable) : SensorEventListener {
-    // This class should be created, started and stopped on one thread
-    // (e.g. the main thread). We use |nonThreadSafe| to ensure that this is
-    // the case. Only active when |DEBUG| is set to true.
-    private val threadChecker = ThreadUtils.ThreadChecker()
-    private val onSensorStateListener: Runnable?
-    private val sensorManager: SensorManager
-    private var proximitySensor: Sensor? = null
-    private var lastStateReportIsNear = false
-
-    init {
-        Timber.d("AppRTCProximitySensor ${AppRTCUtils.threadInfo}")
-        onSensorStateListener = sensorStateListener
-        sensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
-    }
-
-    /**
-     * Activate the proximity sensor. Also do initialization if called for the
-     * first time.
-     */
-    fun start(): Boolean {
-        threadChecker.checkIsOnValidThread()
-        Timber.d("start ${AppRTCUtils.threadInfo}")
-        if (!initDefaultSensor()) {
-            // Proximity sensor is not supported on this device.
-            return false
-        }
-        sensorManager.registerListener(this, proximitySensor, SensorManager.SENSOR_DELAY_NORMAL)
-        return true
-    }
-
-    /** Deactivate the proximity sensor.  */
-    fun stop() {
-        threadChecker.checkIsOnValidThread()
-        Timber.d("stop ${AppRTCUtils.threadInfo}")
-        if (proximitySensor == null) {
-            return
-        }
-        sensorManager.unregisterListener(this, proximitySensor)
-    }
-
-    /** Getter for last reported state. Set to true if "near" is reported.  */
-    fun sensorReportsNearState(): Boolean {
-        threadChecker.checkIsOnValidThread()
-        return lastStateReportIsNear
-    }
-
-    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
-        threadChecker.checkIsOnValidThread()
-        AppRTCUtils.assertIsTrue(sensor.type == Sensor.TYPE_PROXIMITY)
-        if (accuracy == SensorManager.SENSOR_STATUS_UNRELIABLE) {
-            Timber.e("The values returned by this sensor cannot be trusted")
-        }
-    }
-
-    override fun onSensorChanged(event: SensorEvent) {
-        threadChecker.checkIsOnValidThread()
-        AppRTCUtils.assertIsTrue(event.sensor.type == Sensor.TYPE_PROXIMITY)
-        // As a best practice; do as little as possible within this method and
-        // avoid blocking.
-        val distanceInCentimeters = event.values[0]
-        lastStateReportIsNear = if (distanceInCentimeters < proximitySensor!!.maximumRange) {
-            Timber.d("Proximity sensor => NEAR state")
-            true
-        } else {
-            Timber.d("Proximity sensor => FAR state")
-            false
-        }
-
-        // Report about new state to listening client. Client can then call
-        // sensorReportsNearState() to query the current state (NEAR or FAR).
-        onSensorStateListener?.run()
-        Timber.d(
-            "onSensorChanged ${AppRTCUtils.threadInfo}: accuracy=${event.accuracy}, timestamp=${event.timestamp}, distance=${event.values[0]}"
-        )
-    }
-
-    /**
-     * Get default proximity sensor if it exists. Tablet devices (e.g. Nexus 7)
-     * does not support this type of sensor and false will be returned in such
-     * cases.
-     */
-    private fun initDefaultSensor(): Boolean {
-        if (proximitySensor != null) {
-            return true
-        }
-        proximitySensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)
-        if (proximitySensor == null) {
-            return false
-        }
-        logProximitySensorInfo()
-        return true
-    }
-
-    /** Helper method for logging information about the proximity sensor.  */
-    @SuppressLint("ObsoleteSdkInt")
-    private fun logProximitySensorInfo() {
-        if (proximitySensor == null) {
-            return
-        }
-        val info = StringBuilder("Proximity sensor: ")
-        info.append("name=").append(proximitySensor!!.name)
-        info.append(", vendor: ").append(proximitySensor!!.vendor)
-        info.append(", power: ").append(proximitySensor!!.power)
-        info.append(", resolution: ").append(proximitySensor!!.resolution)
-        info.append(", max range: ").append(proximitySensor!!.maximumRange)
-        info.append(", min delay: ").append(proximitySensor!!.minDelay)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH) {
-            // Added in API level 20.
-            info.append(", type: ").append(proximitySensor!!.stringType)
-        }
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-            // Added in API level 21.
-            info.append(", max delay: ").append(proximitySensor!!.maxDelay)
-            info.append(", reporting mode: ").append(proximitySensor!!.reportingMode)
-            info.append(", isWakeUpSensor: ").append(proximitySensor!!.isWakeUpSensor)
-        }
-        Timber.d(info.toString())
-    }
-
-    companion object {
-
-        /** Construction  */
-        @JvmStatic
-        fun create(context: Context, sensorStateListener: Runnable): AppRTCProximitySensor {
-            return AppRTCProximitySensor(context, sensorStateListener)
-        }
-    }
-}

-/*
- *  Copyright 2014 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 io.livekit.android.sample.audio
-
-import android.annotation.SuppressLint
-import android.os.Build
-import timber.log.Timber
-
-/**
- * AppRTCUtils provides helper functions for managing thread safety.
- */
-object AppRTCUtils {
-    /** Helper method which throws an exception  when an assertion has failed.  */
-    fun assertIsTrue(condition: Boolean) {
-        if (!condition) {
-            throw AssertionError("Expected condition to be true")
-        }
-    }
-
-    /** Helper method for building a string of thread information.  */
-    val threadInfo: String
-        get() = ("@[name=" + Thread.currentThread().name + ", id=" + Thread.currentThread().id
-                + "]")
-
-    /** Information about the current build, taken from system properties.  */
-    @SuppressLint("BinaryOperationInTimber")
-    fun logDeviceInfo(tag: String?) {
-        Timber.tag(tag).d(
-            "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
-        )
-    }
-}

+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="48dp"
+    android:height="48dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M28,41.45V38.35Q32.85,36.95 35.925,32.975Q39,29 39,23.95Q39,18.9 35.95,14.9Q32.9,10.9 28,9.55V6.45Q34.2,7.85 38.1,12.725Q42,17.6 42,23.95Q42,30.3 38.1,35.175Q34.2,40.05 28,41.45ZM6,30V18H14L24,8V40L14,30ZM27,32.4V15.55Q29.7,16.4 31.35,18.75Q33,21.1 33,24Q33,26.95 31.35,29.25Q29.7,31.55 27,32.4ZM21,15.6 L15.35,21H9V27H15.35L21,32.45ZM16.3,24Z"/>
+</vector>

@@ -24,7 +24,9 @@ import androidx.compose.ui.unit.dp
 import androidx.constraintlayout.compose.ConstraintLayout
 import androidx.constraintlayout.compose.ConstraintLayout
 import androidx.constraintlayout.compose.Dimension
 import androidx.constraintlayout.compose.Dimension
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.lifecycleScope
+import io.livekit.android.audio.AudioSwitchHandler
 import io.livekit.android.composesample.ui.DebugMenuDialog
 import io.livekit.android.composesample.ui.DebugMenuDialog
+import io.livekit.android.composesample.ui.SelectAudioDeviceDialog
 import io.livekit.android.composesample.ui.theme.AppTheme
 import io.livekit.android.composesample.ui.theme.AppTheme
 import io.livekit.android.room.Room
 import io.livekit.android.room.Room
 import io.livekit.android.room.participant.Participant
 import io.livekit.android.room.participant.Participant
@@ -78,6 +80,7 @@ class CallActivity : AppCompatActivity() {
                 videoEnabled,
                 videoEnabled,
                 flipButtonEnabled,
                 flipButtonEnabled,
                 screencastEnabled,
                 screencastEnabled,
+                audioSwitchHandler = viewModel.audioHandler,
                 permissionAllowed = permissionAllowed,
                 permissionAllowed = permissionAllowed,
                 onExitClick = { finish() },
                 onExitClick = { finish() },
                 onSendMessage = { viewModel.sendData(it) },
                 onSendMessage = { viewModel.sendData(it) },
@@ -126,6 +129,7 @@ class CallActivity : AppCompatActivity() {
         flipButtonEnabled: Boolean = true,
         flipButtonEnabled: Boolean = true,
         screencastEnabled: Boolean = false,
         screencastEnabled: Boolean = false,
         permissionAllowed: Boolean = true,
         permissionAllowed: Boolean = true,
+        audioSwitchHandler: AudioSwitchHandler? = null,
         onExitClick: () -> Unit = {},
         onExitClick: () -> Unit = {},
         error: Throwable? = null,
         error: Throwable? = null,
         onSnackbarDismiss: () -> Unit = {},
         onSnackbarDismiss: () -> Unit = {},
@@ -349,6 +353,29 @@ class CallActivity : AppCompatActivity() {
                         horizontalArrangement = Arrangement.SpaceEvenly,
                         horizontalArrangement = Arrangement.SpaceEvenly,
                         verticalAlignment = Alignment.Bottom,
                         verticalAlignment = Alignment.Bottom,
                     ) {
                     ) {
+                        var showAudioDeviceDialog by remember { mutableStateOf(false) }
+                        Surface(
+                            onClick = { showAudioDeviceDialog = true },
+                            indication = rememberRipple(false),
+                            modifier = Modifier
+                                .size(controlSize)
+                                .padding(controlPadding)
+                        ) {
+                            val resource = R.drawable.volume_up_48px
+                            Icon(
+                                painterResource(id = resource),
+                                contentDescription = "Select Audio Device",
+                                tint = Color.White,
+                            )
+                        }
+                        if (showAudioDeviceDialog) {
+                            SelectAudioDeviceDialog(
+                                onDismissRequest = { showAudioDeviceDialog = false },
+                                selectDevice = { audioSwitchHandler?.selectDevice(it) },
+                                currentDevice = audioSwitchHandler?.selectedAudioDevice,
+                                availableDevices = audioSwitchHandler?.availableAudioDevices ?: emptyList()
+                            )
+                        }
                         Surface(
                         Surface(
                             onClick = { viewModel.toggleSubscriptionPermissions() },
                             onClick = { viewModel.toggleSubscriptionPermissions() },
                             indication = rememberRipple(false),
                             indication = rememberRipple(false),

+package io.livekit.android.composesample.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.Button
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import com.twilio.audioswitch.AudioDevice
+
+@Preview
+@Composable
+fun SelectAudioDeviceDialog(
+    onDismissRequest: () -> Unit = {},
+    selectDevice: (AudioDevice) -> Unit = {},
+    currentDevice: AudioDevice? = null,
+    availableDevices: List<AudioDevice> = emptyList()
+) {
+    Dialog(onDismissRequest = onDismissRequest) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            modifier = Modifier
+                .background(Color.DarkGray, shape = RoundedCornerShape(3.dp))
+                .fillMaxWidth()
+                .padding(10.dp)
+        ) {
+            Text("Select Audio Device", color = Color.White)
+            Spacer(modifier = Modifier.height(10.dp))
+
+            LazyColumn {
+                items(availableDevices) { device ->
+                    Button(
+                        onClick = {
+                            selectDevice(device)
+                            onDismissRequest()
+                        },
+                        modifier = Modifier.fillMaxWidth()
+                    ) {
+                        Text(device.name)
+                    }
+                }
+            }
+        }
+    }
+}