Change the name of AudioDeviceSelector class to AudioSwitch (#56)

* Add modify audio settings permission to manifest

* Move all selector classes to the top level package

* Rename AudioDeviceSelector -> AudioSwitch

* Update changelog

* update gradle.properties

* Change version in changelog to 0.3.0

* change http to https for jfrog oss url

Author: John Qualls

CHANGELOG.md

@@ -4,15 +4,17 @@
 
 Enhancements
 
- - Added `AudioDeviceSelector.VERSION` constant so developers can access the version of AudioSwitch at runtime.
- - Added `AudioDeviceSelector.loggingEnabled` property so developers can configure AudioSwitch logging behavior at runtime. By default, AudioSwitch logging is disabled. Reference the following snippet to enable AudioSwitch logging:
+ - Changed the name of the `AudioDeviceSelector` class to `AudioSwitch`.
+ - Added the [MODIFY_AUDIO_SETTINGS](https://developer.android.com/reference/android/Manifest.permission#MODIFY_AUDIO_SETTINGS) to the library manifest so it can be automatically consumed by applications.
+ - Added `AudioSwitch.VERSION` constant so developers can access the version of AudioSwitch at runtime.
+ - Added `AudioSwitch.loggingEnabled` property so developers can configure AudioSwitch logging behavior at runtime. By default, AudioSwitch logging is disabled. Reference the following snippet to enable AudioSwitch logging:
 
  ```kotlin
-val audioDeviceSelector = AudioDeviceSelector(context)
+val audioSwitch = AudioSwitch(context)
 
-audioDeviceSelector.loggingEnabled = true
+audioSwitch.loggingEnabled = true
 
-audioDeviceSelector.start { _, _ -> }
+audioSwitch.start { _, _ -> }
 ```
 
 ### 0.2.1

README.md

@@ -44,57 +44,57 @@ maven {
 implementation 'com.twilio:audioswitch:$version-SNAPSHOT'
 ```
 
-### AudioDeviceSelector Setup
-Instantiate an instance of the [AudioDeviceSelector](audioswitch/src/main/java/com/twilio/audioswitch/selection/AudioDeviceSelector.kt) class, passing a reference to the application context.
+### AudioSwitch Setup
+Instantiate an instance of the [AudioSwitch](audioswitch/src/main/java/com/twilio/audioswitch/AudioSwitch.kt) class, passing a reference to the application context.
 
 ```kotlin
-val audioDeviceSelector = AudioDeviceSelector(applicationContext)
+val audioSwitch = AudioSwitch(applicationContext)
 ```
 
 ### Listen for Devices
-To begin listening for live audio device changes, call the start function and pass a lambda that will receive [AudioDevices](audioswitch/src/main/java/com/twilio/audioswitch/selection/AudioDevice.kt) when they become available.
+To begin listening for live audio device changes, call the start function and pass a lambda that will receive [AudioDevices](audioswitch/src/main/java/com/twilio/audioswitch/AudioDevice.kt) when they become available.
 
 ```kotlin
-audioDeviceSelector.start { audioDevices, selectedDevice ->
+audioSwitch.start { audioDevices, selectedDevice ->
     // TODO update UI with audio devices
 }
 ```
 You can also retrieve the available and selected audio devices manually at any time by calling the following properties:
 ```kotlin
-val devices: List<AudioDevice> = audioDeviceSelector.availableAudioDevices
-val selectedDevice: AudioDevice? = audioDeviceSelector.selectedAudioDevice
+val devices: List<AudioDevice> = audioSwitch.availableAudioDevices
+val selectedDevice: AudioDevice? = audioSwitch.selectedAudioDevice
 ```
 **Note:** Don't forget to stop listening for audio devices when no longer needed in order to prevent a memory leak.
 ```kotlin
-audioDeviceSelector.stop()
+audioSwitch.stop()
 ```
 
 ### Select a Device
 Before activating an AudioDevice, it needs to be selected first.
 ```kotlin
-devices.find { it is AudioDevice.Speakerphone }?.let { audioDeviceSelector.selectDevice(it) }
+devices.find { it is AudioDevice.Speakerphone }?.let { audioSwitch.selectDevice(it) }
 ```
 If no device is selected, then the library will automatically select a device based on the following priority: `BluetoothHeadset -> WiredHeadset -> Earpiece -> Speakerphone`.
 
 ### Activate a Device
 Activating a device acquires audio focus with [voice communication usage](https://developer.android.com/reference/android/media/AudioAttributes#USAGE_VOICE_COMMUNICATION) and begins routing audio input/output to the selected device.
 ```kotlin
-audioDeviceSelector.activate()
+audioSwitch.activate()
 ```
 Make sure to revert back to the prior audio state when it makes sense to do so in your app.
 ```kotlin
-audioDeviceSelector.deactivate()
+audioSwitch.deactivate()
 ```
-**Note:** The `stop()` function will call `deactivate()` before closing AudioDeviceSelector resources.
+**Note:** The `stop()` function will call `deactivate()` before closing AudioSwitch 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.
+  - The library will accurately display the up to date active bluetooth headset within the `AudioSwitch` `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.
+    - The newly activated headset will be propagated to the `AudioSwitch` `availableAudioDevices` and `selectedAudioDevice` functions.
 
 ## Java Compatibility
 
@@ -105,11 +105,11 @@ Audioswitch is compatible with apps written in Java that [target Java 8](https:/
 By default, AudioSwitch logging is disabled. Reference the following snippet to enable AudioSwitch logging:
 
   ```kotlin
- val audioDeviceSelector = AudioDeviceSelector(context)
+ val audioSwitch = AudioSwitch(context)
 
- audioDeviceSelector.loggingEnabled = true
+ audioSwitch.loggingEnabled = true
 
- audioDeviceSelector.start { _, _ -> }
+ audioSwitch.start { _, _ -> }
  ```
 
 

audioswitch/build.gradle

@@ -92,7 +92,7 @@ publishing {
 }
 
 artifactory {
-    contextUrl = 'http://oss.jfrog.org'
+    contextUrl = 'https://oss.jfrog.org'
     publish {
         repository {
             repoKey = 'oss-snapshot-local'

audioswitch/src/androidTest/java/com.twilio.audioswitch/AudioDeviceSelectorTest.kt renamed to audioswitch/src/androidTest/java/com.twilio.audioswitch/AudioSwitchTest.kt

@@ -3,8 +3,6 @@ package com.twilio.audioswitch
 import androidx.test.annotation.UiThreadTest
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
-import com.twilio.audioswitch.selection.AudioDevice
-import com.twilio.audioswitch.selection.AudioDeviceSelector
 import junit.framework.TestCase.assertEquals
 import junit.framework.TestCase.assertFalse
 import junit.framework.TestCase.assertNotNull
@@ -13,55 +11,55 @@ import org.junit.Test
 import org.junit.runner.RunWith
 
 @RunWith(AndroidJUnit4::class)
-class AudioDeviceSelectorTest {
+class AudioSwitchTest {
 
     private val context = InstrumentationRegistry.getInstrumentation().context
 
     @Test
     @UiThreadTest
     fun `it_should_disable_logging_by_default`() {
-        val audioDeviceSelector = AudioDeviceSelector(context)
+        val audioSwitch = AudioSwitch(context)
 
-        assertFalse(audioDeviceSelector.loggingEnabled)
+        assertFalse(audioSwitch.loggingEnabled)
     }
 
     @Test
     @UiThreadTest
     fun `it_should_allow_enabling_logging`() {
-        val audioDeviceSelector = AudioDeviceSelector(context)
+        val audioSwitch = AudioSwitch(context)
 
-        audioDeviceSelector.loggingEnabled = true
+        audioSwitch.loggingEnabled = true
 
-        assertTrue(audioDeviceSelector.loggingEnabled)
+        assertTrue(audioSwitch.loggingEnabled)
     }
 
     @Test
     @UiThreadTest
     fun `it_should_allow_toggling_logging_while_in_use`() {
-        val audioDeviceSelector = AudioDeviceSelector(context)
-        audioDeviceSelector.loggingEnabled = true
-        assertTrue(audioDeviceSelector.loggingEnabled)
-        audioDeviceSelector.start { _, _ -> }
-        val earpiece = audioDeviceSelector.availableAudioDevices
+        val audioSwitch = AudioSwitch(context)
+        audioSwitch.loggingEnabled = true
+        assertTrue(audioSwitch.loggingEnabled)
+        audioSwitch.start { _, _ -> }
+        val earpiece = audioSwitch.availableAudioDevices
             .find { it is AudioDevice.Earpiece }
         assertNotNull(earpiece)
-        audioDeviceSelector.selectDevice(earpiece!!)
-        assertEquals(earpiece, audioDeviceSelector.selectedAudioDevice)
-        audioDeviceSelector.stop()
+        audioSwitch.selectDevice(earpiece!!)
+        assertEquals(earpiece, audioSwitch.selectedAudioDevice)
+        audioSwitch.stop()
 
-        audioDeviceSelector.loggingEnabled = false
-        assertFalse(audioDeviceSelector.loggingEnabled)
+        audioSwitch.loggingEnabled = false
+        assertFalse(audioSwitch.loggingEnabled)
 
-        audioDeviceSelector.start { _, _ -> }
-        audioDeviceSelector.stop()
+        audioSwitch.start { _, _ -> }
+        audioSwitch.stop()
     }
 
     @Test
     @UiThreadTest
     fun `it_should_return_valid_semver_formatted_version`() {
         val semVerRegex = Regex("^([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9A-" +
                 "Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?(?:\\+[0-9A-Za-z-]+)?$")
-        val version: String = AudioDeviceSelector.VERSION
+        val version: String = AudioSwitch.VERSION
         assertNotNull(version)
         assertTrue(version.matches(semVerRegex))
     }

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

@@ -3,8 +3,7 @@ package com.twilio.audioswitch
 import androidx.test.annotation.UiThreadTest
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.LargeTest
-import com.twilio.audioswitch.selection.AudioDevice.Earpiece
-import com.twilio.audioswitch.selection.AudioDeviceSelector
+import com.twilio.audioswitch.AudioDevice.Earpiece
 import org.hamcrest.CoreMatchers.equalTo
 import org.hamcrest.MatcherAssert.assertThat
 import org.junit.Assert.assertEquals
@@ -18,20 +17,20 @@ class AutomaticDeviceSelectionTest {
     @UiThreadTest
     @Test
     fun `it_should_select_the_bluetooth_audio_device_by_default`() {
-        val (audioDeviceSelector, bluetoothHeadsetReceiver) = setupFakeAudioDeviceSelector(getInstrumentationContext())
+        val (audioSwitch, bluetoothHeadsetReceiver) = setupFakeAudioSwitch(getInstrumentationContext())
 
-        audioDeviceSelector.start { _, _ -> }
+        audioSwitch.start { _, _ -> }
         simulateBluetoothSystemIntent(getInstrumentationContext(), bluetoothHeadsetReceiver)
 
-        assertEquals("Fake Headset", audioDeviceSelector.selectedAudioDevice!!.name)
+        assertEquals("Fake Headset", audioSwitch.selectedAudioDevice!!.name)
     }
 
     @UiThreadTest
     @Test
     fun `it_should_select_the_earpiece_audio_device_by_default`() {
-        val audioDeviceSelector = AudioDeviceSelector(getInstrumentationContext())
-        audioDeviceSelector.start { _, _ -> }
+        val audioSwitch = AudioSwitch(getInstrumentationContext())
+        audioSwitch.start { _, _ -> }
 
-        assertThat(audioDeviceSelector.selectedAudioDevice is Earpiece, equalTo(true))
+        assertThat(audioSwitch.selectedAudioDevice is Earpiece, equalTo(true))
     }
 }

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

@@ -19,16 +19,16 @@ class MultipleBluetoothHeadsetsTest {
     @UiThreadTest
     @Test
     fun `it_should_assert_the_second_bluetooth_headset_when_two_are_connected`() {
-        val (audioDeviceSelector, bluetoothHeadsetReceiver) = setupFakeAudioDeviceSelector(getInstrumentationContext())
+        val (audioSwitch, bluetoothHeadsetReceiver) = setupFakeAudioSwitch(getInstrumentationContext())
 
-        audioDeviceSelector.start { _, _ -> }
-        audioDeviceSelector.activate()
+        audioSwitch.start { _, _ -> }
+        audioSwitch.activate()
         simulateBluetoothSystemIntent(getInstrumentationContext(), bluetoothHeadsetReceiver)
         simulateBluetoothSystemIntent(getInstrumentationContext(), bluetoothHeadsetReceiver, HEADSET_2_NAME)
 
-        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 },
+        assertThat(audioSwitch.selectedAudioDevice!!.name, equalTo(HEADSET_2_NAME))
+        assertThat(audioSwitch.availableAudioDevices.first().name, equalTo(HEADSET_2_NAME))
+        assertThat(audioSwitch.availableAudioDevices.find { it.name == HEADSET_NAME },
                 `is`(nullValue()))
         assertThat(isSpeakerPhoneOn(), equalTo(false)) // Best we can do for asserting if a fake BT headset is activated
     }

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

@@ -12,13 +12,10 @@ import com.twilio.audioswitch.android.FakeBluetoothIntentProcessor
 import com.twilio.audioswitch.android.HEADSET_NAME
 import com.twilio.audioswitch.android.Logger
 import com.twilio.audioswitch.bluetooth.BluetoothHeadsetManager
-import com.twilio.audioswitch.selection.AudioDeviceManager
-import com.twilio.audioswitch.selection.AudioDeviceSelector
-import com.twilio.audioswitch.selection.AudioFocusRequestWrapper
 import com.twilio.audioswitch.wired.WiredHeadsetReceiver
 
-internal fun setupFakeAudioDeviceSelector(context: Context):
-        Pair<AudioDeviceSelector, BluetoothHeadsetManager> {
+internal fun setupFakeAudioSwitch(context: Context):
+        Pair<AudioSwitch, BluetoothHeadsetManager> {
 
     val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
     val logger = Logger()
@@ -35,7 +32,7 @@ internal fun setupFakeAudioDeviceSelector(context: Context):
     } ?: run {
         null
     }
-    return Pair(AudioDeviceSelector(logger,
+    return Pair(AudioSwitch(logger,
             audioDeviceManager,
             wiredHeadsetReceiver,
             headsetManager),

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

@@ -4,10 +4,9 @@ import androidx.test.annotation.UiThreadTest
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.LargeTest
 import androidx.test.platform.app.InstrumentationRegistry
-import com.twilio.audioswitch.selection.AudioDevice.BluetoothHeadset
-import com.twilio.audioswitch.selection.AudioDevice.Earpiece
-import com.twilio.audioswitch.selection.AudioDevice.Speakerphone
-import com.twilio.audioswitch.selection.AudioDeviceSelector
+import com.twilio.audioswitch.AudioDevice.BluetoothHeadset
+import com.twilio.audioswitch.AudioDevice.Earpiece
+import com.twilio.audioswitch.AudioDevice.Speakerphone
 import org.hamcrest.CoreMatchers.`is`
 import org.hamcrest.CoreMatchers.equalTo
 import org.hamcrest.CoreMatchers.notNullValue
@@ -24,43 +23,43 @@ class UserDeviceSelectionTest {
     @UiThreadTest
     @Test
     fun `it_should_select_the_earpiece_audio_device_when_the_user_selects_it`() {
-        val audioDeviceSelector = AudioDeviceSelector(context)
-        audioDeviceSelector.start { _, _ -> }
-        val earpiece = audioDeviceSelector.availableAudioDevices
+        val audioSwitch = AudioSwitch(context)
+        audioSwitch.start { _, _ -> }
+        val earpiece = audioSwitch.availableAudioDevices
                 .find { it is Earpiece }
         assertThat(earpiece, `is`(notNullValue()))
 
-        audioDeviceSelector.selectDevice(earpiece!!)
+        audioSwitch.selectDevice(earpiece!!)
 
-        assertThat(audioDeviceSelector.selectedAudioDevice, equalTo(earpiece))
+        assertThat(audioSwitch.selectedAudioDevice, equalTo(earpiece))
     }
 
     @UiThreadTest
     @Test
     fun `it_should_select_the_speakerphone_audio_device_when_the_user_selects_it`() {
-        val audioDeviceSelector = AudioDeviceSelector(context)
-        audioDeviceSelector.start { _, _ -> }
-        val speakerphone = audioDeviceSelector.availableAudioDevices
+        val audioSwitch = AudioSwitch(context)
+        audioSwitch.start { _, _ -> }
+        val speakerphone = audioSwitch.availableAudioDevices
                 .find { it is Speakerphone }
         assertThat(speakerphone, `is`(notNullValue()))
 
-        audioDeviceSelector.selectDevice(speakerphone!!)
+        audioSwitch.selectDevice(speakerphone!!)
 
-        assertThat(audioDeviceSelector.selectedAudioDevice, equalTo(speakerphone))
+        assertThat(audioSwitch.selectedAudioDevice, equalTo(speakerphone))
     }
 
     @UiThreadTest
     @Test
     fun `it_should_select_the_bluetooth_audio_device_when_the_user_selects_it`() {
-        val (audioDeviceSelector, bluetoothHeadsetReceiver) = setupFakeAudioDeviceSelector(context)
-        audioDeviceSelector.start { _, _ -> }
+        val (audioSwitch, bluetoothHeadsetReceiver) = setupFakeAudioSwitch(context)
+        audioSwitch.start { _, _ -> }
         simulateBluetoothSystemIntent(context, bluetoothHeadsetReceiver)
-        val bluetoothDevice = audioDeviceSelector.availableAudioDevices
+        val bluetoothDevice = audioSwitch.availableAudioDevices
                 .find { it is BluetoothHeadset }
         assertThat(bluetoothDevice, `is`(notNullValue()))
 
-        audioDeviceSelector.selectDevice(bluetoothDevice!!)
+        audioSwitch.selectDevice(bluetoothDevice!!)
 
-        assertThat(audioDeviceSelector.selectedAudioDevice, equalTo(bluetoothDevice))
+        assertThat(audioSwitch.selectedAudioDevice, equalTo(bluetoothDevice))
     }
 }

audioswitch/src/main/AndroidManifest.xml

@@ -2,5 +2,6 @@
     package="com.twilio.audioswitch" >
 
     <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
 
 </manifest>

audioswitch/src/main/java/com/twilio/audioswitch/selection/AudioDevice.kt renamed to audioswitch/src/main/java/com/twilio/audioswitch/AudioDevice.kt

@@ -1,7 +1,7 @@
-package com.twilio.audioswitch.selection
+package com.twilio.audioswitch
 
 /**
- * This class represents a single audio device that has been retrieved by the [AudioDeviceSelector].
+ * This class represents a single audio device that has been retrieved by the [AudioSwitch].
  */
 sealed class AudioDevice {
 

audioswitch/src/main/java/com/twilio/audioswitch/selection/AudioDeviceChangeListener.kt renamed to audioswitch/src/main/java/com/twilio/audioswitch/AudioDeviceChangeListener.kt

@@ -1,8 +1,8 @@
-package com.twilio.audioswitch.selection
+package com.twilio.audioswitch
 
 /** A listener that receives the most recently available [AudioDevice]s.
  * Receives a list of the most recently available [AudioDevice]s. Also provides the
- * currently selected [AudioDevice] from [AudioDeviceSelector].
+ * currently selected [AudioDevice] from [AudioSwitch].
  *
  * @param audioDevices the list of [AudioDevice]s or an empty list if none are available.
  * @param selectedAudioDevice the currently selected device or null if no device has been selected.