Add support for multiple connected bluetooth headsets (#40)

* First attempt at implementing a Bluetooth Headset State

* Only set headset state back to connected if is not the active device

* Only change bluetooth state if is a new value

* Add audio device fallback mechanism in event of sco activation timeout

* Convert HeadsetState from singleton to normal class

* Fix unit test compilation errors

* Add activating state and restart bluetooth sco when the active device is changed

* Pull out cache and display generic bluetooth name for now

* Add new ActivationError state to handle sco error scenario

* Display bluetooth headset name WIP

* Fix unit test compilation errors and move common dependency logic to the BaseTest class

* Rename HeadsetState.kt -> BluetoothHeadsetState.kt

* Move bluetooth headset state management into the BluetoothHeadsetManager

* Change naming of states

* Bluetooth headset refactor (#42)

* Consolidate all headset logic into the BluetoothHeadsetManager

* Add comments explaining various blueotooth headset states

* Add logs for invalid state tranisition attempts

* Fix unit tests after refactor

* Fix E2E tests after refactor

* Add warning logs for activate and deactivate invalid state transition attempts

* Add changelog update for latest changes

* Update minor version

* Add CL entry to README

* Add BT settings clause

Author: John Qualls

CHANGELOG.md

@@ -1,6 +1,14 @@
 # Changelog
 
-### 0.1.6
+### 0.2.0
+
+Enhancements
+- Added support for multiple connected bluetooth headsets.
+  - The library will now accurately display the up to date active bluetooth headset within the `AudiodDeviceSelector` `availableAudioDevices` and `selectedAudioDevice` functions.
+    - Other connected headsets are not stored by the library at this moment.
+  - In the event of a failure to connecting audio to a bluetooth headset, the library will revert the selected audio device (this is usually the Earpiece on a phone).
+  - If a user would like to switch between multiple Bluetooth headsets, then they need to switch the active bluetooth headset from the system Bluetooth settings.
+    - The newly activated headset will be propagated to the `AudiodDeviceSelector` `availableAudioDevices` and `selectedAudioDevice` functions.
 
 Bug Fixes
 

README.md

@@ -87,6 +87,15 @@ audioDeviceSelector.deactivate()
 ```
 **Note:** The `stop()` function will call `deactivate()` before closing AudioDeviceSelector resources.
 
+## Bluetooth Support
+
+Multiple connected bluetooth headsets are supported.
+  - The library will accurately display the up to date active bluetooth headset within the `AudiodDeviceSelector` `availableAudioDevices` and `selectedAudioDevice` functions.
+    - Other connected headsets are not stored by the library at this moment.
+  - In the event of a failure to connecting audio to a bluetooth headset, the library will revert the selected audio device (this is usually the Earpiece on a phone).
+  - If a user would like to switch between multiple Bluetooth headsets, then they need to switch the active bluetooth headset from the system Bluetooth settings.
+    - The newly activated headset will be propagated to the `AudiodDeviceSelector` `availableAudioDevices` and `selectedAudioDevice` functions.
+
 ## Usage Examples
 
 * [Twilio Video Android App](https://github.com/twilio/twilio-video-app-android)

audioswitch/src/androidTest/java/com.twilio.audioswitch/MultipleBluetoothHeadsetsTest.kt

@@ -1,6 +1,5 @@
 package com.twilio.audioswitch
 
-import android.bluetooth.BluetoothDevice
 import androidx.test.annotation.UiThreadTest
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.LargeTest
@@ -33,42 +32,4 @@ class MultipleBluetoothHeadsetsTest {
                 `is`(nullValue()))
         assertThat(isSpeakerPhoneOn(), equalTo(false)) // Best we can do for asserting if a fake BT headset is activated
     }
-
-    @UiThreadTest
-    @Test
-    fun `it_should_assert_the_first_bluetooth_headset_when_two_are_connected_and_the_second_is_disconnected`() {
-        val (audioDeviceSelector, bluetoothHeadsetReceiver) = setupFakeAudioDeviceSelector(getInstrumentationContext())
-        audioDeviceSelector.start { _, _ -> }
-        audioDeviceSelector.activate()
-        simulateBluetoothSystemIntent(getInstrumentationContext(), bluetoothHeadsetReceiver)
-        simulateBluetoothSystemIntent(getInstrumentationContext(), bluetoothHeadsetReceiver, HEADSET_2_NAME)
-
-        simulateBluetoothSystemIntent(getInstrumentationContext(), bluetoothHeadsetReceiver, HEADSET_2_NAME,
-                BluetoothDevice.ACTION_ACL_DISCONNECTED)
-
-        assertThat(audioDeviceSelector.selectedAudioDevice!!.name, equalTo(HEADSET_NAME))
-        assertThat(audioDeviceSelector.availableAudioDevices.first().name, equalTo(HEADSET_NAME))
-        assertThat(audioDeviceSelector.availableAudioDevices.find { it.name == HEADSET_2_NAME },
-                `is`(nullValue()))
-        assertThat(isSpeakerPhoneOn(), equalTo(false))
-    }
-
-    @UiThreadTest
-    @Test
-    fun `it_should_assert_the_second_bluetooth_headset_when_two_are_connected_and_the_first_is_disconnected`() {
-        val (audioDeviceSelector, bluetoothHeadsetReceiver) = setupFakeAudioDeviceSelector(getInstrumentationContext())
-        audioDeviceSelector.start { _, _ -> }
-        audioDeviceSelector.activate()
-        simulateBluetoothSystemIntent(getInstrumentationContext(), bluetoothHeadsetReceiver)
-        simulateBluetoothSystemIntent(getInstrumentationContext(), bluetoothHeadsetReceiver, HEADSET_2_NAME)
-
-        simulateBluetoothSystemIntent(getInstrumentationContext(), bluetoothHeadsetReceiver, HEADSET_NAME,
-                BluetoothDevice.ACTION_ACL_DISCONNECTED)
-
-        assertThat(audioDeviceSelector.selectedAudioDevice!!.name, equalTo(HEADSET_2_NAME))
-        assertThat(audioDeviceSelector.availableAudioDevices.first().name, equalTo(HEADSET_2_NAME))
-        assertThat(audioDeviceSelector.availableAudioDevices.find { it.name == HEADSET_NAME },
-                `is`(nullValue()))
-        assertThat(isSpeakerPhoneOn(), equalTo(false))
-    }
 }

audioswitch/src/androidTest/java/com.twilio.audioswitch/TestUtil.kt

@@ -11,19 +11,14 @@ import com.twilio.audioswitch.android.DEVICE_NAME
 import com.twilio.audioswitch.android.FakeBluetoothIntentProcessor
 import com.twilio.audioswitch.android.HEADSET_NAME
 import com.twilio.audioswitch.android.LogWrapper
-import com.twilio.audioswitch.bluetooth.BluetoothController
-import com.twilio.audioswitch.bluetooth.BluetoothHeadsetCacheManager
 import com.twilio.audioswitch.bluetooth.BluetoothHeadsetManager
-import com.twilio.audioswitch.bluetooth.BluetoothHeadsetReceiver
 import com.twilio.audioswitch.selection.AudioDeviceManager
 import com.twilio.audioswitch.selection.AudioDeviceSelector
 import com.twilio.audioswitch.selection.AudioFocusRequestWrapper
 import com.twilio.audioswitch.wired.WiredHeadsetReceiver
 
-val TAG = "TestUtil"
-
 internal fun setupFakeAudioDeviceSelector(context: Context):
-        Pair<AudioDeviceSelector, BluetoothHeadsetReceiver> {
+        Pair<AudioDeviceSelector, BluetoothHeadsetManager> {
 
     val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
     val logger = LogWrapper()
@@ -34,35 +29,29 @@ internal fun setupFakeAudioDeviceSelector(context: Context):
                     BuildWrapper(),
                     AudioFocusRequestWrapper())
     val wiredHeadsetReceiver = WiredHeadsetReceiver(context, logger)
-    val bluetoothIntentProcessor = FakeBluetoothIntentProcessor()
-    val deviceCache = BluetoothHeadsetCacheManager(logger)
-    val bluetoothHeadsetReceiver = BluetoothHeadsetReceiver(context, logger, bluetoothIntentProcessor, audioDeviceManager, deviceCache)
-    val bluetoothController = BluetoothAdapter.getDefaultAdapter()?.let { bluetoothAdapter ->
-        BluetoothController(context,
-                bluetoothAdapter,
-                BluetoothHeadsetManager(logger, bluetoothAdapter, deviceCache),
-                bluetoothHeadsetReceiver)
+    val headsetManager = BluetoothAdapter.getDefaultAdapter()?.let { bluetoothAdapter ->
+        BluetoothHeadsetManager(context, logger, bluetoothAdapter, audioDeviceManager,
+                bluetoothIntentProcessor = FakeBluetoothIntentProcessor())
     } ?: run {
         null
     }
     return Pair(AudioDeviceSelector(logger,
             audioDeviceManager,
             wiredHeadsetReceiver,
-            bluetoothController,
-            deviceCache),
-            bluetoothHeadsetReceiver)
+            headsetManager),
+            headsetManager!!)
 }
 
 internal fun simulateBluetoothSystemIntent(
     context: Context,
-    bluetoothHeadsetReceiver: BluetoothHeadsetReceiver,
+    headsetManager: BluetoothHeadsetManager,
     deviceName: String = HEADSET_NAME,
     action: String = BluetoothDevice.ACTION_ACL_CONNECTED
 ) {
     val intent = Intent(action).apply {
         putExtra(DEVICE_NAME, deviceName)
     }
-    bluetoothHeadsetReceiver.onReceive(context, intent)
+    headsetManager.onReceive(context, intent)
 }
 
 fun getTargetContext(): Context = getInstrumentation().targetContext

audioswitch/src/main/java/com/twilio/audioswitch/android/LogWrapper.kt

@@ -8,6 +8,10 @@ internal class LogWrapper {
         Log.d(tag, message)
     }
 
+    fun w(tag: String, message: String) {
+        Log.w(tag, message)
+    }
+
     fun e(tag: String, message: String) {
         Log.e(tag, message)
     }

audioswitch/src/main/java/com/twilio/audioswitch/bluetooth/BluetoothController.kt

@@ -1,5 +1,6 @@
 package com.twilio.audioswitch.bluetooth
 
 internal interface BluetoothHeadsetConnectionListener {
-    fun onBluetoothHeadsetStateChanged()
+    fun onBluetoothHeadsetStateChanged(headsetName: String? = null)
+    fun onBluetoothHeadsetActivationError()
 }