Change bluetooth to state (as opposed to boolean)

rajramsaroop · rajramsaroop · commit bb009a7d96a4 · 2025-01-21T14:28:33.000-05:00
diff --git a/DittoHealth/src/main/java/live/ditto/health/HealthScreenActionHandler.kt b/DittoHealth/src/main/java/live/ditto/health/HealthScreenActionHandler.kt
@@ -7,7 +7,10 @@ import android.provider.Settings
 
 class HealthScreenActionHandler {
     fun handle(actionType: HealthUiActionType, context: Context) = when (actionType) {
-        HealthUiActionType.NoAction -> {}
+        HealthUiActionType.NoAction,
+        HealthUiActionType.BluetoothUnsupported -> {
+        }
+
         HealthUiActionType.EnableWifi -> {
             context.startActivity(Intent(Settings.ACTION_WIFI_SETTINGS))
         }
@@ -23,5 +26,6 @@ class HealthScreenActionHandler {
         HealthUiActionType.EnableBluetooth -> {
             context.startActivity(Intent(Settings.ACTION_BLUETOOTH_SETTINGS))
         }
+
     }
 }
diff --git a/DittoHealth/src/main/java/live/ditto/health/HealthUiActionType.kt b/DittoHealth/src/main/java/live/ditto/health/HealthUiActionType.kt
@@ -5,4 +5,5 @@ sealed class HealthUiActionType {
     object RequestPermissions : HealthUiActionType()
     object EnableWifi : HealthUiActionType()
     object EnableBluetooth : HealthUiActionType()
+    object BluetoothUnsupported : HealthUiActionType()
 }
diff --git a/DittoHealth/src/main/java/live/ditto/health/HealthUiStateCause.kt b/DittoHealth/src/main/java/live/ditto/health/HealthUiStateCause.kt
@@ -15,6 +15,7 @@ data class HealthUiStateCause(
             HealthUiActionType.EnableWifi -> false
             HealthUiActionType.RequestPermissions -> false
             HealthUiActionType.EnableBluetooth -> false
+            HealthUiActionType.BluetoothUnsupported -> false
         }
     }
 
@@ -23,5 +24,6 @@ data class HealthUiStateCause(
         HealthUiActionType.EnableWifi -> context.getString(R.string.enable_wifi)
         HealthUiActionType.RequestPermissions -> context.getString(R.string.request_permissions)
         HealthUiActionType.EnableBluetooth -> context.getString(R.string.enable_bluetooth)
+        HealthUiActionType.BluetoothUnsupported -> ""
     }
 }
diff --git a/DittoHealth/src/main/java/live/ditto/health/data/HealthUiState.kt b/DittoHealth/src/main/java/live/ditto/health/data/HealthUiState.kt
@@ -7,13 +7,14 @@ import kotlinx.coroutines.withContext
 import live.ditto.health.HealthUiActionType
 import live.ditto.health.HealthUiStateCause
 import live.ditto.health.R
+import live.ditto.health.usecase.BluetoothState
 import live.ditto.health.usecase.WifiAwareState
 
 data class HealthUiState(
     val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
     val missingPermissions: List<String> = emptyList(),
     val wifiEnabled: Boolean = true,
-    val bluetoothEnabled: Boolean = true,
+    val bluetoothState: BluetoothState = BluetoothState.UNSUPPORTED,
     val wifiAwareState: WifiAwareState = WifiAwareState.UNSUPPORTED,
     val deviceDetails: DeviceDetails
 ) {
@@ -81,22 +82,36 @@ data class HealthUiState(
         withActions: MutableList<HealthUiStateCause>,
         context: Context
     ) {
-        if (bluetoothEnabled) {
-            noActions.add(
-                HealthUiStateCause(
-                    reason = context.getString(R.string.bluetooth_status),
-                    details = listOf(context.getString(R.string.bluetooth_enabled)),
-                    actionType = HealthUiActionType.NoAction
+        when (bluetoothState) {
+            BluetoothState.ENABLED -> {
+                noActions.add(
+                    HealthUiStateCause(
+                        reason = context.getString(R.string.bluetooth_status),
+                        details = listOf(context.getString(R.string.bluetooth_enabled)),
+                        actionType = HealthUiActionType.NoAction
+                    )
                 )
-            )
-        } else {
-            withActions.add(
-                HealthUiStateCause(
-                    reason = context.getString(R.string.bluetooth_status),
-                    details = listOf(context.getString(R.string.bluetooth_not_enabled)),
-                    actionType = HealthUiActionType.EnableBluetooth
+            }
+
+            BluetoothState.DISABLED -> {
+                withActions.add(
+                    HealthUiStateCause(
+                        reason = context.getString(R.string.bluetooth_status),
+                        details = listOf(context.getString(R.string.bluetooth_not_enabled)),
+                        actionType = HealthUiActionType.EnableBluetooth
+                    )
                 )
-            )
+            }
+
+            BluetoothState.UNSUPPORTED -> {
+                noActions.add(
+                    HealthUiStateCause(
+                        reason = context.getString(R.string.bluetooth_status),
+                        details = listOf(context.getString(R.string.bluetooth_unsupported)),
+                        actionType = HealthUiActionType.BluetoothUnsupported
+                    )
+                )
+            }
         }
     }
 }
diff --git a/DittoHealth/src/main/java/live/ditto/health/ui/composables/TransportHealthInformation.kt b/DittoHealth/src/main/java/live/ditto/health/ui/composables/TransportHealthInformation.kt
@@ -68,7 +68,7 @@ private fun TransportHealthInformation(
             healthUiStateCauses.forEach { healthUiStateCause ->
                 val actionType = healthUiStateCause.actionType
 
-                if (actionType == HealthUiActionType.NoAction) {
+                if (actionType == HealthUiActionType.NoAction || actionType == HealthUiActionType.BluetoothUnsupported) {
                     HealthCheckWithNoAction(
                         header = healthUiStateCause.reason,
                         isHealthy = healthUiStateCause.isHealthy,
diff --git a/DittoHealth/src/main/java/live/ditto/health/ui/viewmodel/HealthViewModel.kt b/DittoHealth/src/main/java/live/ditto/health/ui/viewmodel/HealthViewModel.kt
@@ -14,6 +14,7 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.update
 import live.ditto.health.data.DeviceDetails
 import live.ditto.health.data.HealthUiState
+import live.ditto.health.usecase.BluetoothState
 import live.ditto.health.usecase.GetBluetoothStatusFlow
 import live.ditto.health.usecase.GetDittoMissingPermissionsFlow
 import live.ditto.health.usecase.GetPermissionsMetricsUseCase
@@ -109,9 +110,9 @@ class HealthViewModel(
         }
     }
 
-    private fun onBluetoothStatus(status: Boolean?) {
+    private fun onBluetoothStatus(bluetoothState: BluetoothState) {
         _state.update {
-            it.copy(bluetoothEnabled = status ?: false)
+            it.copy(bluetoothState = bluetoothState)
         }
     }
 
diff --git a/DittoHealth/src/main/java/live/ditto/health/usecase/GetBluetoothStatusFlow.kt b/DittoHealth/src/main/java/live/ditto/health/usecase/GetBluetoothStatusFlow.kt
@@ -18,18 +18,44 @@ class GetBluetoothStatusFlow(context: Context) {
     private val state = callbackFlow {
         val receiver = object : BroadcastReceiver() {
             override fun onReceive(context: Context, intent: Intent) {
-                launch { send(bluetoothManager.adapter.isEnabled) }
+                launch { send(determineBluetoothState(bluetoothManager = bluetoothManager)) }
             }
         }
 
         context.registerReceiver(receiver, IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED))
 
-        send(bluetoothManager.adapter?.isEnabled)
+        if (bluetoothManager.adapter == null) {
+            send(BluetoothState.UNSUPPORTED)
+        } else {
+            if (bluetoothManager.adapter.isEnabled) {
+                send(BluetoothState.ENABLED)
+            } else {
+                send(BluetoothState.DISABLED)
+            }
+        }
 
         awaitClose {
             context.unregisterReceiver(receiver)
         }
     }
 
     operator fun invoke() = state
+
+    private fun determineBluetoothState(bluetoothManager: BluetoothManager): BluetoothState {
+        return if (bluetoothManager.adapter == null) {
+            BluetoothState.UNSUPPORTED
+        } else {
+            if (bluetoothManager.adapter.isEnabled) {
+                BluetoothState.ENABLED
+            } else {
+                BluetoothState.DISABLED
+            }
+        }
+    }
+}
+
+enum class BluetoothState {
+    ENABLED,
+    DISABLED,
+    UNSUPPORTED
 }
diff --git a/DittoHealth/src/main/java/live/ditto/health/usecase/GetPermissionsMetricsUseCase.kt b/DittoHealth/src/main/java/live/ditto/health/usecase/GetPermissionsMetricsUseCase.kt
@@ -8,15 +8,19 @@ class GetPermissionsMetricsUseCase {
     operator fun invoke(healthUiState: HealthUiState): HealthMetric {
         val missingPermissions = healthUiState.missingPermissions
         val wifiEnabled = healthUiState.wifiEnabled
-        val bluetoothEnabled = healthUiState.bluetoothEnabled
+        val bluetoothState = healthUiState.bluetoothState
         val wifiAwareState = healthUiState.wifiAwareState
 
-        val isHealthy = missingPermissions.isEmpty() && wifiEnabled && bluetoothEnabled
+        val isHealthy by lazy {
+            missingPermissions.isEmpty()
+                    && wifiEnabled
+                    && bluetoothState == BluetoothState.ENABLED
+        }
 
         val details = createDetailsMap(
             missingPermissions = missingPermissions,
             wifiEnabled = wifiEnabled,
-            bluetoothEnabled = bluetoothEnabled,
+            bluetoothState = bluetoothState,
             wifiAwareState = wifiAwareState
         )
 
@@ -29,15 +33,15 @@ class GetPermissionsMetricsUseCase {
     private fun createDetailsMap(
         missingPermissions: List<String>,
         wifiEnabled: Boolean,
-        bluetoothEnabled: Boolean,
+        bluetoothState: BluetoothState,
         wifiAwareState: WifiAwareState
     ): MutableMap<String, String> {
         return mutableMapOf<String, String>().apply {
             if (missingPermissions.isNotEmpty()) {
                 this[KEY_MISSING_PERMISSIONS] = missingPermissions.joinToString()
             }
             this[KEY_WIFI_ENABLED] = wifiEnabled.toString()
-            this[KEY_BLUETOOTH_ENABLED] = bluetoothEnabled.toString()
+            this[KEY_BLUETOOTH_STATE] = getBluetoothStateDescription(bluetoothState)
             this[KEY_WIFI_AWARE_STATE] = getWifiAwareStateDescription(wifiAwareState)
         }
     }
@@ -50,10 +54,18 @@ class GetPermissionsMetricsUseCase {
         }
     }
 
+    private fun getBluetoothStateDescription(bluetoothState: BluetoothState): String {
+        return when (bluetoothState) {
+            BluetoothState.ENABLED -> "Bluetooth is enabled"
+            BluetoothState.DISABLED -> "Bluetooth is disabled"
+            BluetoothState.UNSUPPORTED -> "Bluetooth is not supported by this device"
+        }
+    }
+
     companion object {
         const val KEY_MISSING_PERMISSIONS = "Missing Permissions"
         const val KEY_WIFI_ENABLED = "WiFi Enabled"
-        const val KEY_BLUETOOTH_ENABLED = "Bluetooth Enabled"
+        const val KEY_BLUETOOTH_STATE = "Bluetooth State"
         const val KEY_WIFI_AWARE_STATE = "Wifi Aware State"
     }
 }
diff --git a/DittoHealth/src/main/res/values/strings.xml b/DittoHealth/src/main/res/values/strings.xml
@@ -12,6 +12,7 @@
     <string name="bluetooth_enabled">Bluetooth Enabled</string>
     <string name="bluetooth_not_enabled">Bluetooth Not Enabled</string>
     <string name="enable_bluetooth">Enable Bluetooth</string>
+    <string name="bluetooth_unsupported">Bluetooth unsupported</string>
     <string name="wifi_aware_supported">WiFi Aware is supported by this device</string>
     <string name="wifi_aware_unsupported">Wifi Aware is unavailable for this device</string>
     <string name="wifi_aware_unsupported_android_version">Wifi Aware is not supported by this device as it not running Android 8.0 (API 26) or later</string>

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,10 @@ import android.provider.Settings`
`7`	`7`
`8`	`8`	`class HealthScreenActionHandler {`
`9`	`9`	`fun handle(actionType: HealthUiActionType, context: Context) = when (actionType) {`
`10`		`- HealthUiActionType.NoAction -> {}`
	`10`	`+ HealthUiActionType.NoAction,`
	`11`	`+ HealthUiActionType.BluetoothUnsupported -> {`
	`12`	`+ }`
	`13`	`+`
`11`	`14`	`HealthUiActionType.EnableWifi -> {`
`12`	`15`	`context.startActivity(Intent(Settings.ACTION_WIFI_SETTINGS))`
`13`	`16`	`}`
`@@ -23,5 +26,6 @@ class HealthScreenActionHandler {`
`23`	`26`	`HealthUiActionType.EnableBluetooth -> {`
`24`	`27`	`context.startActivity(Intent(Settings.ACTION_BLUETOOTH_SETTINGS))`
`25`	`28`	`}`
	`29`	`+`
`26`	`30`	`}`
`27`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,4 +5,5 @@ sealed class HealthUiActionType {`
`5`	`5`	`object RequestPermissions : HealthUiActionType()`
`6`	`6`	`object EnableWifi : HealthUiActionType()`
`7`	`7`	`object EnableBluetooth : HealthUiActionType()`
	`8`	`+ object BluetoothUnsupported : HealthUiActionType()`
`8`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ data class HealthUiStateCause(`
`15`	`15`	`HealthUiActionType.EnableWifi -> false`
`16`	`16`	`HealthUiActionType.RequestPermissions -> false`
`17`	`17`	`HealthUiActionType.EnableBluetooth -> false`
	`18`	`+ HealthUiActionType.BluetoothUnsupported -> false`
`18`	`19`	`}`
`19`	`20`	`}`
`20`	`21`
`@@ -23,5 +24,6 @@ data class HealthUiStateCause(`
`23`	`24`	`HealthUiActionType.EnableWifi -> context.getString(R.string.enable_wifi)`
`24`	`25`	`HealthUiActionType.RequestPermissions -> context.getString(R.string.request_permissions)`
`25`	`26`	`HealthUiActionType.EnableBluetooth -> context.getString(R.string.enable_bluetooth)`
	`27`	`+ HealthUiActionType.BluetoothUnsupported -> ""`
`26`	`28`	`}`
`27`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ import kotlinx.coroutines.flow.onEach`
`14`	`14`	`import kotlinx.coroutines.flow.update`
`15`	`15`	`import live.ditto.health.data.DeviceDetails`
`16`	`16`	`import live.ditto.health.data.HealthUiState`
	`17`	`+import live.ditto.health.usecase.BluetoothState`
`17`	`18`	`import live.ditto.health.usecase.GetBluetoothStatusFlow`
`18`	`19`	`import live.ditto.health.usecase.GetDittoMissingPermissionsFlow`
`19`	`20`	`import live.ditto.health.usecase.GetPermissionsMetricsUseCase`
`@@ -109,9 +110,9 @@ class HealthViewModel(`
`109`	`110`	`}`
`110`	`111`	`}`
`111`	`112`
`112`		`- private fun onBluetoothStatus(status: Boolean?) {`
	`113`	`+ private fun onBluetoothStatus(bluetoothState: BluetoothState) {`
`113`	`114`	`_state.update {`
`114`		`- it.copy(bluetoothEnabled = status ?: false)`
	`115`	`+ it.copy(bluetoothState = bluetoothState)`
`115`	`116`	`}`
`116`	`117`	`}`
`117`	`118`