Fix volume settings applied to speaker when Bluetooth is turned off

When Bluetooth is disabled (via settings, airplane mode, or device reboot),
Android doesn't fire ACTION_ACL_DISCONNECTED events for connected devices.
This caused the app to continue applying Bluetooth device volume settings
to the built-in speaker, potentially resulting in unexpected audio levels.

The fix monitors Bluetooth adapter state changes using flatMapLatest on the
isEnabled flow. When Bluetooth is turned OFF, pairedDevices now correctly
emits only the speaker device, ensuring proper volume settings are applied.

Also refactored BluetoothRepo for better readability:
- Extracted bluetoothDeviceEvents() function from inline callbackFlow
- Moved retryWhen outside flatMapLatest for better state re-evaluation
- Simplified speaker device addition to single location
- Made State.devices non-nullable for type safety

Fixes issue reported via email regarding volume management during BT state changes.

Author: d4rken

app/src/main/java/eu/darken/bluemusic/bluetooth/core/BluetoothRepo.kt

@@ -27,12 +27,15 @@ import eu.darken.bluemusic.devices.core.DeviceAddr
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.channels.trySendBlocking
+import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.retry
 import kotlinx.coroutines.flow.retryWhen
@@ -81,7 +84,7 @@ class BluetoothRepo @Inject constructor(
 
     @SuppressLint("MissingPermission")
     @RequiresPermission(anyOf = [Manifest.permission.BLUETOOTH_CONNECT, Manifest.permission.BLUETOOTH])
-    private val pairedDevices: Flow<Set<SourceDevice>?> = callbackFlow {
+    private fun bluetoothDeviceEvents(): Flow<Unit> = callbackFlow {
         if (!isBluetoothSupported) {
             log(TAG, WARN) { "Bluetooth hardware is not available" }
             throw IllegalStateException("Bluetooth hardware is not available")
@@ -124,35 +127,41 @@ class BluetoothRepo @Inject constructor(
             context.unregisterReceiver(receiver)
         }
     }
-        .map {
-            val devices = mutableSetOf<SourceDevice>()
-
-            bluetoothAdapter.bondedDevices
-                .filterNot { device ->
-                    val isHealthDevice = device.hasUUID(0x1400)
-                    if (isHealthDevice) log(TAG) { "Health devices are excluded: ${device.name} - ${device.address}" }
-                    isHealthDevice
-                }
-                .forEach { device ->
-                    val wrapper = SourceDeviceWrapper.from(realDevice = device, isConnected = device.isConnected())
-                    devices.add(wrapper)
-                    log(TAG) { "Paired evice: ${wrapper.name} - ${wrapper.address} - isConnected=${wrapper.isConnected}" }
-
-                }
 
-            devices.add(speakerDeviceProvider.getSpeaker())
+    @SuppressLint("MissingPermission")
+    @RequiresPermission(anyOf = [Manifest.permission.BLUETOOTH_CONNECT, Manifest.permission.BLUETOOTH])
+    private val pairedDevices: Flow<Set<SourceDevice>> = isEnabled
+        .flatMapLatest { enabled ->
+            if (!enabled) {
+                log(TAG, WARN) { "Bluetooth is disabled, emitting empty device set" }
+                return@flatMapLatest flowOf(emptySet())
+            }
 
-            devices.toSet() as Set<SourceDevice>?
+            bluetoothDeviceEvents().map {
+                bluetoothAdapter.bondedDevices
+                    .filterNot { device ->
+                        val isHealthDevice = device.hasUUID(0x1400)
+                        if (isHealthDevice) log(TAG) { "Health devices are excluded: ${device.name} - ${device.address}" }
+                        isHealthDevice
+                    }
+                    .map { device ->
+                        val wrapper = SourceDeviceWrapper.from(realDevice = device, isConnected = device.isConnected())
+                        log(TAG) { "Paired device: ${wrapper.name} - ${wrapper.address} - isConnected=${wrapper.isConnected}" }
+                        wrapper as SourceDevice
+                    }
+                    .toSet()
+            }
         }
         .retryWhen { err, attempt ->
             log(TAG, WARN) { "Can't load paired devices: ${err.asLog()}" }
-            emit(null)
+            emit(emptySet<SourceDevice>())
             delay(3000)
             true
         }
+        .map { btDevices -> btDevices + speakerDeviceProvider.getSpeaker() }
 
     private val hasPermission = flow {
-        while (coroutineContext.isActive) {
+        while (currentCoroutineContext().isActive) {
             emit(permissionHelper.hasBluetoothPermission())
             delay(1000)
         }
@@ -161,10 +170,10 @@ class BluetoothRepo @Inject constructor(
     data class State(
         val isEnabled: Boolean,
         val hasPermission: Boolean,
-        val devices: Set<SourceDevice>?,
+        val devices: Set<SourceDevice>,
         val error: Throwable? = null,
     ) {
-        val isReady = isEnabled && hasPermission && devices != null && error == null
+        val isReady = isEnabled && hasPermission && error == null
     }
 
     val state = combine(
@@ -175,7 +184,7 @@ class BluetoothRepo @Inject constructor(
         State(
             isEnabled = enabled,
             hasPermission = permission,
-            devices = devices ?: emptySet(),
+            devices = devices,
         )
     }
         .retry {

app/src/main/java/eu/darken/bluemusic/bluetooth/ui/discover/DiscoverViewModel.kt

@@ -35,7 +35,7 @@ class DiscoverViewModel @Inject constructor(
         upgradeRepo.upgradeInfo,
     ) { bluetoothState, managed, upgradeInfo ->
         State(
-            devices = bluetoothState.devices!!
+            devices = bluetoothState.devices
                 .filterNot { p -> managed.any { p.address == it.address } }
                 .sortedWith(
                     compareBy(

app/src/main/java/eu/darken/bluemusic/devices/core/DeviceRepo.kt

@@ -29,10 +29,10 @@ class DeviceRepo @Inject constructor(
         bluetoothRepo.state,
         deviceDatabase.devices.getAllDevices()
     ) { btState, managed ->
-        val pairedMap = btState.devices?.associateBy { it.address }
+        val pairedMap = btState.devices.associateBy { it.address }
         val mappings = managed
             .mapNotNull { config ->
-                val paired = pairedMap?.get(config.address) ?: return@mapNotNull null
+                val paired = pairedMap[config.address] ?: return@mapNotNull null
                 config to paired
             }
 

app/src/main/java/eu/darken/bluemusic/devices/core/NewDeviceCreator.kt

@@ -26,7 +26,7 @@ class NewDeviceCreator @Inject constructor(
         val device = bluetoothRepo.state
             .filter { it.isReady }
             .first()
-            .devices!!
+            .devices
             .find { it.address == address } ?: throw IllegalStateException("Device not found: $address")
 
         var config = DeviceConfigEntity(