Watch: action buttons stay visible disabled, accent-aware battery and speed

The Wear Material Button's built-in `enabled=false` faded the whole
button to ~12% alpha, hiding the icon entirely on dark backgrounds.
Removed the enabled flag, kept the onClick guard, and gave the button
its own muted disabledBg/disabledFg palette so the dimmed state is
visible but clearly inactive — same pattern the phone dashboard uses
for its grayed action tiles.

Battery chips:
- Default accent → tier coloring (green/amber/red) so the rider gets
  a glanceable read on remaining range, matching the phone dashboard.
- Any other accent → all chips wear that accent for consistent
  identity with the phone.

Speed glyph follows the same rule: tier color under default accent,
the picked accent otherwise. Details rows and second-page speed
mirror it (white values for default, accent-tinted for the rest).

Phone dashboard: gauge safe-band always green now, matching the
watch fix. Previously a custom accent painted the safe zone in the
accent color, which read as one continuous danger band when the
user picked red/pink. Speed indicator arc still wears the accent.

Schema: added watchStem1Click/Hold and watchStem2Click/Hold for the
stem-button mapping work next, DB v28 -> v29.

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

Author: eried

app/src/main/java/com/eried/eucplanet/data/db/AppDatabase.kt

@@ -8,7 +8,7 @@ import com.eried.eucplanet.data.model.TripRecord
 
 @Database(
     entities = [AppSettings::class, TripRecord::class, AlarmRule::class],
-    version = 28,
+    version = 29,
     exportSchema = false
 )
 abstract class AppDatabase : RoomDatabase() {

app/src/main/java/com/eried/eucplanet/data/model/AppSettings.kt

@@ -185,7 +185,25 @@ data class AppSettings(
     @ColumnInfo(defaultValue = "1")
     val watchShowSpeedUnit: Boolean = true,
     @ColumnInfo(defaultValue = "0")
-    val watchEnableGpsSpeed: Boolean = false
+    val watchEnableGpsSpeed: Boolean = false,
+
+    /**
+     * Hardware-button bindings on the watch (Galaxy Watch Ultra exposes the
+     * orange Action button as STEM_1 and the bottom side button as STEM_2;
+     * Pixel Watch only has one). Stored as the [FlicAction] enum name so the
+     * picker can reuse the same UI/string set as Flic and Volume keys. The
+     * Wear OS side reads these via the Data Layer publish, intercepts
+     * KEYCODE_STEM_* in MainActivity, and either fires a local control
+     * intent or routes to the phone over /euc/control.
+     */
+    @ColumnInfo(defaultValue = "HORN")
+    val watchStem1Click: String = "HORN",
+    @ColumnInfo(defaultValue = "NONE")
+    val watchStem1Hold: String = "NONE",
+    @ColumnInfo(defaultValue = "LIGHT_TOGGLE")
+    val watchStem2Click: String = "LIGHT_TOGGLE",
+    @ColumnInfo(defaultValue = "NONE")
+    val watchStem2Hold: String = "NONE"
 )
 
 enum class FlicAction(val labelRes: Int) {

app/src/main/java/com/eried/eucplanet/ui/dashboard/DashboardScreen.kt

@@ -400,7 +400,10 @@ fun DashboardScreen(
                     showColorBand = showGaugeColorBand,
                     orangeThresholdPct = gaugeOrangePct,
                     redThresholdPct = gaugeRedPct,
-                    safeBandColor = if (useAccent) primary else AccentBlue,
+                    // Safe band is always green so it reads as the safety
+                    // signal and not the user's accent. The speed indicator
+                    // arc (overrideColor above) still wears the accent.
+                    safeBandColor = AccentGreen,
                     modifier = Modifier
                         .fillMaxWidth(0.75f)
                         .aspectRatio(1.25f)

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

@@ -153,14 +153,17 @@ private fun MainScreen(state: WatchState, accent: Color) {
                     )
                     Spacer(Modifier.width(3.dp))
                 }
+                val useAccent = state.accentKey != "default"
                 Text(
                     text = "%.0f".format(WatchUnits.speed(state.speedKmh, state.imperialUnits)),
                     fontSize = speedFontSp,
                     fontWeight = FontWeight.Bold,
-                    // The gauge band already encodes the safety zones via
-                    // green/yellow/red. The speed glyph follows the user's
-                    // accent so the watch identity matches their phone.
-                    color = accent
+                    // Default accent → tier coloring (green/yellow/orange/red)
+                    // so the watch matches the phone dashboard's "rainbow"
+                    // mode. Any other accent → wear that accent so the
+                    // watch identity stays consistent with the phone's pick.
+                    color = if (useAccent) accent
+                            else speedTierColor(state.speedKmh, maxSpeed)
                 )
                 if (state.showSpeedUnit) {
                     Spacer(Modifier.width(3.dp))
@@ -227,6 +230,8 @@ private fun MainScreen(state: WatchState, accent: Color) {
                 phonePercent = state.phoneBatteryPercent.takeIf { state.showPhoneBattery },
                 watchPercent = watchPercent.takeIf { state.showWatchBattery },
                 showWheelChip = state.showWheelBattery,
+                accent = accent,
+                useAccentTint = state.accentKey != "default",
                 fontSize = batteryFontSp,
                 iconSize = batteryIconDp,
                 spacing = batterySpacingDp
@@ -280,6 +285,8 @@ private fun BatteryRow(
     phonePercent: Int?,
     watchPercent: Int?,
     showWheelChip: Boolean,
+    accent: Color,
+    useAccentTint: Boolean,
     fontSize: TextUnit,
     iconSize: Dp,
     spacing: Dp
@@ -292,10 +299,10 @@ private fun BatteryRow(
         // an em-dash so the row layout stays put rather than collapsing the
         // moment a wheel drops out.
         if (showWheelChip) {
-            BatteryChip(Icons.Filled.ElectricScooter, wheelPercent, fontSize, iconSize)
+            BatteryChip(Icons.Filled.ElectricScooter, wheelPercent, accent, useAccentTint, fontSize, iconSize)
         }
-        phonePercent?.let { BatteryChip(Icons.Filled.PhoneAndroid, it, fontSize, iconSize) }
-        watchPercent?.let { BatteryChip(Icons.Filled.Watch, it, fontSize, iconSize) }
+        phonePercent?.let { BatteryChip(Icons.Filled.PhoneAndroid, it, accent, useAccentTint, fontSize, iconSize) }
+        watchPercent?.let { BatteryChip(Icons.Filled.Watch, it, accent, useAccentTint, fontSize, iconSize) }
     }
 }
 
@@ -307,8 +314,22 @@ private fun pwmTierColor(percent: Float): Color = when {
 }
 
 @Composable
-private fun BatteryChip(icon: ImageVector, percent: Int?, fontSize: TextUnit, iconSize: Dp) {
-    val tint = if (percent != null) batteryTint(percent) else Color(0xFF606060)
+private fun BatteryChip(
+    icon: ImageVector,
+    percent: Int?,
+    accent: Color,
+    useAccentTint: Boolean,
+    fontSize: TextUnit,
+    iconSize: Dp
+) {
+    // Default accent → tier coloring (green / amber / red) so the rider
+    // gets a glanceable sense of remaining range. Any other accent →
+    // the chip wears the accent so the watch identity stays consistent.
+    val tint = when {
+        percent == null -> Color(0xFF606060)
+        useAccentTint -> accent
+        else -> batteryTint(percent)
+    }
     Row(verticalAlignment = Alignment.CenterVertically) {
         Icon(
             imageVector = icon,
@@ -336,47 +357,49 @@ 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 live = state.connected
+    // Custom dim palette for the disconnected state — the Wear Button's own
+    // `enabled = false` styling fades the whole button to ~12% alpha which
+    // makes the icon nearly invisible. Keeping the button "enabled" with our
+    // own muted colors and guarding the onClick keeps it visually present
+    // while still being non-interactive.
     val disabledBg = Color(0xFF1A1A1A)
     val disabledFg = Color(0xFF555555)
     Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
         if (state.hasHorn) {
             Button(
                 onClick = {
-                    if (enabled) WatchStateRepository.sendControl(context, WatchControl.HORN)
+                    if (live) WatchStateRepository.sendControl(context, WatchControl.HORN)
                 },
-                enabled = enabled,
                 colors = ButtonDefaults.primaryButtonColors(
-                    backgroundColor = if (enabled) accent else disabledBg,
-                    contentColor = if (enabled) Color.Black else disabledFg
+                    backgroundColor = if (live) accent else disabledBg,
+                    contentColor = if (live) Color.Black else disabledFg
                 ),
                 modifier = Modifier.size(buttonSize)
             ) {
                 Icon(
                     imageVector = Icons.Filled.Campaign,
                     contentDescription = stringResource(R.string.watch_horn),
+                    tint = if (live) Color.Black else disabledFg,
                     modifier = Modifier.size(iconSize)
                 )
             }
         }
         if (state.hasLight) {
             Button(
                 onClick = {
-                    if (!enabled) return@Button
+                    if (!live) return@Button
                     val intent = if (state.lightOn) WatchControl.LIGHT_OFF else WatchControl.LIGHT_ON
                     WatchStateRepository.sendControl(context, intent)
                 },
-                enabled = enabled,
                 colors = ButtonDefaults.secondaryButtonColors(
                     backgroundColor = when {
-                        !enabled -> disabledBg
+                        !live -> disabledBg
                         state.lightOn -> accent.copy(alpha = 0.30f)
                         else -> Color(0xFF2A2A2A)
                     },
                     contentColor = when {
-                        !enabled -> disabledFg
+                        !live -> disabledFg
                         state.lightOn -> accent
                         else -> Color(0xFFB0B0B0)
                     }
@@ -387,7 +410,7 @@ private fun ActionRow(state: WatchState, accent: Color, buttonSize: Dp, iconSize
                     imageVector = Icons.Filled.FlashlightOn,
                     contentDescription = stringResource(R.string.watch_light),
                     tint = when {
-                        !enabled -> disabledFg
+                        !live -> disabledFg
                         state.lightOn -> Color(0xFFFFC107)
                         else -> Color(0xFF606060)
                     },
@@ -448,18 +471,26 @@ private fun DetailsScreen(state: WatchState, accent: Color) {
                     fontWeight = FontWeight.SemiBold
                 )
             }
+            // Same accent rule as the dial: default accent → white speed
+            // so the row aligns with the rest of the value column; any
+            // custom accent → wear that accent.
+            val useAccent = state.accentKey != "default"
             Text(
                 text = "%.0f %s".format(speedDisplay, speedUnit),
                 fontSize = speedSp,
                 fontWeight = FontWeight.Bold,
-                color = accent
+                color = if (useAccent) accent else Color.White
             )
             Spacer(Modifier.height(4.dp))
             val live = state.connected
-            // Accent-tint live values so the page reads as a continuation of
-            // the dashboard's accent identity. Disconnected dashes stay grey
-            // so the rider can tell at a glance that the row isn't live.
-            val valueColor = if (live) accent else Color(0xFF606060)
+            // Live values: white when default accent (matches phone dashboard's
+            // value column) or the accent color when the user picked one.
+            // Disconnected dashes stay muted grey.
+            val valueColor = when {
+                !live -> Color(0xFF606060)
+                useAccent -> accent
+                else -> Color.White
+            }
             DetailRow(R.string.watch_voltage_label, if (live) "%.1f V".format(state.voltage) else DASH, labelSp, valueSp, labelWidth, valueWidth, valueColor)
             DetailRow(R.string.watch_current_label, if (live) "%.1f A".format(state.current) else DASH, labelSp, valueSp, labelWidth, valueWidth, valueColor)
             DetailRow(R.string.watch_power_label, if (live) "%.0f W".format(powerW) else DASH, labelSp, valueSp, labelWidth, valueWidth, valueColor)