Watch: dashboard always renders, disconnected = zeros + grayed buttons

When the wheel isn't connected the watch used to swap to a placeholder
screen ("Open EUC Planet on your phone"). Tester feedback: the layout
should stay put with every metric at 0 and the action buttons grayed
out, mirroring how the phone dashboard looks when disconnected. The
header on the details page replaces the wheel-name accent with a muted
"Wheel disconnected" so the rider still knows the values aren't live.

A side benefit: phone-side settings tweaks (PWM display, batteries,
speed unit, light icon, etc.) now show up on the watch immediately,
even without a wheel paired — testers can validate the layout end to
end before they ever turn the wheel on.

Bridge fix: the publish pipeline used a Flow combine + sample +
distinctUntilChanged combo that went silent when nothing upstream
changed (e.g. wheel disconnected, no telemetry tick). Replaced with a
plain coroutine loop ticking at PUBLISH_INTERVAL_MS so the watch's
freshness signal stays alive regardless of whether the wheel is
producing data.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: eried

app/src/main/java/com/eried/eucplanet/wear/WearBridge.kt

@@ -17,9 +17,7 @@ import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.sample
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -113,21 +111,27 @@ class WearBridge @Inject constructor(
             }
         }
 
+        // Periodic publisher rather than a Flow combine. Reasoning: when the
+        // wheel is disconnected the upstream flows don't emit, so a sample +
+        // distinctUntilChanged pipeline goes silent — and the watch ends up
+        // in the "phone not here" placeholder even though the phone app is
+        // running and paired. Polling at PUBLISH_INTERVAL_MS keeps the
+        // watch's freshness signal alive without per-emission complexity.
         scope.launch {
-            combine(
-                wheelRepository.wheelData,
-                wheelRepository.connectionState,
-                wheelRepository.modelName,
-                wheelRepository.maxSpeedCap,
-                settingsRepository.settings
-            ) { data, state, name, maxSpeed, settings ->
-                Snapshot(data, state, name, maxSpeed, settings)
-            }
-                .sample(PUBLISH_INTERVAL_MS)
-                .distinctUntilChanged()
-                .collect { snap ->
-                    publish(snap.data, snap.state, snap.name, snap.maxSpeed, snap.settings)
+            while (true) {
+                try {
+                    publish(
+                        data = wheelRepository.wheelData.value,
+                        state = wheelRepository.connectionState.value,
+                        name = wheelRepository.modelName.value,
+                        maxSpeed = wheelRepository.maxSpeedCap.value,
+                        settings = settingsRepository.get()
+                    )
+                } catch (e: Exception) {
+                    Log.w(TAG, "publish loop error", e)
                 }
+                delay(PUBLISH_INTERVAL_MS)
+            }
         }
     }
 
@@ -190,11 +194,4 @@ class WearBridge @Inject constructor(
         return if (level >= 0 && scale > 0) (level * 100 / scale).coerceIn(0, 100) else 0
     }
 
-    private data class Snapshot(
-        val data: com.eried.eucplanet.data.model.WheelData,
-        val state: ConnectionState,
-        val name: String?,
-        val maxSpeed: Float,
-        val settings: AppSettings
-    )
 }

wear/src/main/java/com/eried/eucplanet/wear/bridge/WatchStateRepository.kt

@@ -28,10 +28,19 @@ object WatchStateRepository {
     private val _state = MutableStateFlow(WatchState())
     val state: StateFlow<WatchState> = _state.asStateFlow()
 
+    /**
+     * Wall-clock time of the last [update] call, in millis. Used by the UI to
+     * tell apart the "phone hasn't said hi yet" placeholder from the
+     * "phone is here, just no wheel" one. Zero until the first push lands.
+     */
+    private val _lastPushAtMs = MutableStateFlow(0L)
+    val lastPushAtMs: StateFlow<Long> = _lastPushAtMs.asStateFlow()
+
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
     fun update(snapshot: WatchState) {
         _state.value = snapshot
+        _lastPushAtMs.value = System.currentTimeMillis()
     }
 
     /**

wear/src/main/java/com/eried/eucplanet/wear/ui/WatchApp.kt

@@ -87,10 +87,11 @@ private fun MainScreen(state: WatchState, accent: Color) {
             .background(Color.Black),
         contentAlignment = Alignment.Center
     ) {
-        if (!state.connected) {
-            DisconnectedPlaceholder()
-            return@BoxWithConstraints
-        }
+        // The disconnected state is rendered by zeroing every metric and
+        // graying the action buttons rather than swapping in a placeholder
+        // screen — the rider always sees the same layout, and the second
+        // page (DetailsScreen) is where the explicit "Disconnected" hint
+        // lives. Mirrors the phone dashboard's behaviour.
         val sw = maxWidth.value
         val batteryFontSp = (sw * 0.034f).coerceIn(9f, 12f).sp
         val batteryIconDp = (sw * 0.038f).coerceIn(10f, 14f).dp
@@ -253,39 +254,6 @@ private fun LoadBar(percent: Float, modifier: Modifier = Modifier) {
     }
 }
 
-@Composable
-private fun DisconnectedPlaceholder() {
-    BoxWithConstraints(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(horizontal = 16.dp),
-        contentAlignment = Alignment.Center
-    ) {
-        val sw = maxWidth.value
-        val iconDp = (sw * 0.18f).coerceIn(36f, 56f).dp
-        val textSp = (sw * 0.038f).coerceIn(12f, 15f).sp
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Center
-        ) {
-            Icon(
-                imageVector = Icons.Filled.PhoneAndroid,
-                contentDescription = null,
-                tint = Color(0xFF9AA0A6),
-                modifier = Modifier.size(iconDp)
-            )
-            Spacer(Modifier.height(8.dp))
-            Text(
-                text = stringResource(R.string.watch_waiting_phone),
-                fontSize = textSp,
-                color = Color(0xFFB0B0B0),
-                textAlign = TextAlign.Center,
-                fontWeight = FontWeight.Medium
-            )
-        }
-    }
-}
-
 @Composable
 private fun BatteryRow(
     wheelPercent: Int?,
@@ -342,13 +310,21 @@ private fun batteryTint(percent: Int): Color = when {
 @Composable
 private fun ActionRow(state: WatchState, accent: Color, buttonSize: Dp, iconSize: Dp) {
     val context = LocalContext.current
+    val enabled = state.connected
+    // Use the same dim grey as the phone dashboard's grayed action tiles so
+    // disconnected reads identically across surfaces.
+    val disabledBg = Color(0xFF1A1A1A)
+    val disabledFg = Color(0xFF555555)
     Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
         if (state.hasHorn) {
             Button(
-                onClick = { WatchStateRepository.sendControl(context, WatchControl.HORN) },
+                onClick = {
+                    if (enabled) WatchStateRepository.sendControl(context, WatchControl.HORN)
+                },
+                enabled = enabled,
                 colors = ButtonDefaults.primaryButtonColors(
-                    backgroundColor = accent,
-                    contentColor = Color.Black
+                    backgroundColor = if (enabled) accent else disabledBg,
+                    contentColor = if (enabled) Color.Black else disabledFg
                 ),
                 modifier = Modifier.size(buttonSize)
             ) {
@@ -362,19 +338,33 @@ private fun ActionRow(state: WatchState, accent: Color, buttonSize: Dp, iconSize
         if (state.hasLight) {
             Button(
                 onClick = {
+                    if (!enabled) return@Button
                     val intent = if (state.lightOn) WatchControl.LIGHT_OFF else WatchControl.LIGHT_ON
                     WatchStateRepository.sendControl(context, intent)
                 },
+                enabled = enabled,
                 colors = ButtonDefaults.secondaryButtonColors(
-                    backgroundColor = if (state.lightOn) accent.copy(alpha = 0.30f) else Color(0xFF2A2A2A),
-                    contentColor = if (state.lightOn) accent else Color(0xFFB0B0B0)
+                    backgroundColor = when {
+                        !enabled -> disabledBg
+                        state.lightOn -> accent.copy(alpha = 0.30f)
+                        else -> Color(0xFF2A2A2A)
+                    },
+                    contentColor = when {
+                        !enabled -> disabledFg
+                        state.lightOn -> accent
+                        else -> Color(0xFFB0B0B0)
+                    }
                 ),
                 modifier = Modifier.size(buttonSize)
             ) {
                 Icon(
                     imageVector = Icons.Filled.FlashlightOn,
                     contentDescription = stringResource(R.string.watch_light),
-                    tint = if (state.lightOn) Color(0xFFFFC107) else Color(0xFF606060),
+                    tint = when {
+                        !enabled -> disabledFg
+                        state.lightOn -> Color(0xFFFFC107)
+                        else -> Color(0xFF606060)
+                    },
                     modifier = Modifier.size(iconSize)
                 )
             }
@@ -390,10 +380,6 @@ private fun DetailsScreen(state: WatchState, accent: Color) {
             .background(Color.Black),
         contentAlignment = Alignment.Center
     ) {
-        if (!state.connected) {
-            DisconnectedPlaceholder()
-            return@BoxWithConstraints
-        }
         val sw = maxWidth.value
         val labelSp = (sw * 0.034f).coerceIn(10f, 13f).sp
         val valueSp = (sw * 0.038f).coerceIn(11f, 14f).sp
@@ -418,7 +404,17 @@ private fun DetailsScreen(state: WatchState, accent: Color) {
             horizontalAlignment = Alignment.CenterHorizontally,
             verticalArrangement = Arrangement.spacedBy(2.dp)
         ) {
-            if (state.wheelName.isNotBlank()) {
+            // When disconnected we still render every metric (all zeros) but
+            // swap the wheel-name accent header for a muted "Disconnected"
+            // hint so the rider knows the values aren't live.
+            if (!state.connected) {
+                Text(
+                    text = stringResource(R.string.watch_disconnected),
+                    fontSize = headerSp,
+                    color = Color(0xFF9AA0A6),
+                    fontWeight = FontWeight.SemiBold
+                )
+            } else if (state.wheelName.isNotBlank()) {
                 Text(
                     text = state.wheelName,
                     fontSize = headerSp,

wear/src/main/res/values/strings.xml

@@ -2,6 +2,7 @@
 <resources>
     <string name="app_name">EUC Planet</string>
     <string name="watch_waiting_phone">Open EUC Planet\non your phone</string>
+    <string name="watch_waiting_wheel">Connect a wheel\nin EUC Planet</string>
     <string name="watch_disconnected">Wheel disconnected</string>
     <string name="watch_horn">Horn</string>
     <string name="watch_light">Light</string>