Watch: full-bleed dial, three batteries, accent and imperial follow phone

The dial now wraps the whole watch face. Inside it sits a compact battery
row (wheel / phone / watch), the live speed number with units below, and
the horn / light buttons. Same gauge geometry as the phone dashboard so
fixes flow either direction; full-bleed mode skips the outer scale labels
because they collide with the buttons at the bottom.

Wire format additions on `/euc/state`:
- PHONE_BATT — phone-side BatteryManager percent
- IMPERIAL  — AppSettings.imperialUnits
- ACCENT    — AppSettings.accentColor key

WatchState gains phoneBatteryPercent / imperialUnits / accentKey to match.
Watch resolves the accent through a small mirror palette (no shared
module); units flip mph / mi / °F when imperial is on. The Wear bridge
now also depends on SettingsRepository so the publisher sees those fields.

Page 2 (details) gets a wheel-name header in the user's accent, a live
speed line so you don't have to swipe back, and a Power row computed as
V x A. Rows render in a fixed-width table (label right, value left) so
the eye scans cleanly down each column on round and rectangular faces.

Disconnected screen swaps the misleading red dot for a phone glyph and
a two-line message ("Open EUC Planet / on your phone") so it reads as
"do this", not "error".

Layout sizes derive from BoxWithConstraints.maxWidth so the same code
looks right on small round (~390 dp) and Watch Ultra (~454 dp).

Debug builds expose an ADB demo broadcast on the watch app so the
connected dashboard can be exercised without a paired phone:

  adb shell am broadcast -p com.eried.eucplanet \
    -a com.eried.eucplanet.wear.DEMO --ef speed 32 \
    --ei battery 78 --ei phone 64 --es accent teal

Gated by ApplicationInfo.FLAG_DEBUGGABLE so it never reaches release.

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

Author: eried

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

@@ -1,8 +1,13 @@
 package com.eried.eucplanet.wear
 
 import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.BatteryManager
 import android.util.Log
 import com.eried.eucplanet.ble.ConnectionState
+import com.eried.eucplanet.data.model.AppSettings
+import com.eried.eucplanet.data.repository.SettingsRepository
 import com.eried.eucplanet.data.repository.WheelRepository
 import com.google.android.gms.wearable.PutDataMapRequest
 import com.google.android.gms.wearable.Wearable
@@ -36,7 +41,8 @@ import javax.inject.Singleton
 @Singleton
 class WearBridge @Inject constructor(
     @ApplicationContext private val context: Context,
-    private val wheelRepository: WheelRepository
+    private val wheelRepository: WheelRepository,
+    private val settingsRepository: SettingsRepository
 ) {
     companion object {
         private const val TAG = "WearBridge"
@@ -48,6 +54,7 @@ class WearBridge @Inject constructor(
         private const val K_CONNECTED = "c"
         private const val K_SPEED = "s"
         private const val K_BATTERY = "b"
+        private const val K_PHONE_BATT = "b2"
         private const val K_VOLTAGE = "v"
         private const val K_CURRENT = "i"
         private const val K_PWM = "p"
@@ -59,6 +66,8 @@ class WearBridge @Inject constructor(
         private const val K_WHEEL_NAME = "n"
         private const val K_HAS_HORN = "ch"
         private const val K_HAS_LIGHT = "cl"
+        private const val K_IMPERIAL = "im"
+        private const val K_ACCENT = "ac"
         private const val K_TIMESTAMP = "ts"
     }
 
@@ -80,14 +89,15 @@ class WearBridge @Inject constructor(
                 wheelRepository.wheelData,
                 wheelRepository.connectionState,
                 wheelRepository.modelName,
-                wheelRepository.maxSpeedCap
-            ) { data, state, name, maxSpeed ->
-                Quad(data, state, name, maxSpeed)
+                wheelRepository.maxSpeedCap,
+                settingsRepository.settings
+            ) { data, state, name, maxSpeed, settings ->
+                Snapshot(data, state, name, maxSpeed, settings)
             }
                 .sample(PUBLISH_INTERVAL_MS)
                 .distinctUntilChanged()
-                .collect { (data, state, name, maxSpeed) ->
-                    publish(data, state, name, maxSpeed)
+                .collect { snap ->
+                    publish(snap.data, snap.state, snap.name, snap.maxSpeed, snap.settings)
                 }
         }
     }
@@ -96,14 +106,16 @@ class WearBridge @Inject constructor(
         data: com.eried.eucplanet.data.model.WheelData,
         state: ConnectionState,
         name: String?,
-        maxSpeed: Float
+        maxSpeed: Float,
+        settings: AppSettings
     ) {
         try {
             val request = PutDataMapRequest.create(PATH_STATE).apply {
                 dataMap.putBoolean(K_CONNECTED, state == ConnectionState.CONNECTED)
                 dataMap.putString(K_WHEEL_NAME, name ?: "")
                 dataMap.putFloat(K_SPEED, data.speed)
                 dataMap.putInt(K_BATTERY, data.batteryPercent)
+                dataMap.putInt(K_PHONE_BATT, readPhoneBatteryPercent())
                 dataMap.putFloat(K_VOLTAGE, data.voltage)
                 dataMap.putFloat(K_CURRENT, data.current)
                 dataMap.putFloat(K_PWM, data.pwm)
@@ -116,6 +128,8 @@ class WearBridge @Inject constructor(
                 // don't, gate these on WheelAdapter.capabilities. For now true.
                 dataMap.putBoolean(K_HAS_HORN, true)
                 dataMap.putBoolean(K_HAS_LIGHT, true)
+                dataMap.putBoolean(K_IMPERIAL, settings.imperialUnits)
+                dataMap.putString(K_ACCENT, settings.accentColor)
                 // DataItems dedupe by content. Bumping a timestamp guarantees
                 // the watch sees every snapshot when the values stop changing
                 // (e.g. wheel idle, but we want the connection-state heartbeat).
@@ -128,5 +142,24 @@ class WearBridge @Inject constructor(
         }
     }
 
-    private data class Quad<A, B, C, D>(val a: A, val b: B, val c: C, val d: D)
+    private fun readPhoneBatteryPercent(): Int {
+        val bm = context.getSystemService(Context.BATTERY_SERVICE) as? BatteryManager
+        bm?.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)?.let { lvl ->
+            if (lvl in 0..100) return lvl
+        }
+        // Fallback to the sticky ACTION_BATTERY_CHANGED broadcast on devices where
+        // BATTERY_PROPERTY_CAPACITY isn't reliable.
+        val intent: Intent? = context.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
+        val level = intent?.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) ?: -1
+        val scale = intent?.getIntExtra(BatteryManager.EXTRA_SCALE, -1) ?: -1
+        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/MainActivity.kt

@@ -1,13 +1,75 @@
 package com.eried.eucplanet.wear
 
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.ApplicationInfo
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
+import androidx.core.content.ContextCompat
+import com.eried.eucplanet.wear.bridge.WatchState
+import com.eried.eucplanet.wear.bridge.WatchStateRepository
 import com.eried.eucplanet.wear.ui.WatchApp
 
 class MainActivity : ComponentActivity() {
+
+    private val demoReceiver = object : BroadcastReceiver() {
+        /**
+         * Debug-only hook. `adb shell am broadcast -p com.eried.eucplanet \
+         *   -a com.eried.eucplanet.wear.DEMO --ef speed 35 --ei battery 78 \
+         *   --ei phone 64 --es accent teal`
+         * fills the watch UI with synthetic state so the dashboard renders
+         * without the phone/Data Layer pairing being live. Gated by the
+         * debuggable flag so this never ships in a release build.
+         */
+        override fun onReceive(context: Context, intent: Intent) {
+            if (!context.isDebuggable()) return
+            WatchStateRepository.update(
+                WatchState(
+                    connected = true,
+                    wheelName = intent.getStringExtra("name") ?: "Demo wheel",
+                    speedKmh = intent.getFloatExtra("speed", 28f),
+                    batteryPercent = intent.getIntExtra("battery", 78),
+                    phoneBatteryPercent = intent.getIntExtra("phone", 64),
+                    voltage = intent.getFloatExtra("voltage", 95.4f),
+                    current = intent.getFloatExtra("current", 12.3f),
+                    pwmPercent = intent.getFloatExtra("pwm", 35f),
+                    temperatureC = intent.getFloatExtra("temp", 42f),
+                    tripKm = intent.getFloatExtra("trip", 12.34f),
+                    torque = intent.getFloatExtra("torque", 5.6f),
+                    lightOn = intent.getBooleanExtra("light", false),
+                    maxSpeedKmh = intent.getFloatExtra("maxSpeed", 70f),
+                    hasHorn = intent.getBooleanExtra("horn", true),
+                    hasLight = intent.getBooleanExtra("hasLight", true),
+                    imperialUnits = intent.getBooleanExtra("imperial", false),
+                    accentKey = intent.getStringExtra("accent") ?: "default"
+                )
+            )
+        }
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        if (isDebuggable()) {
+            ContextCompat.registerReceiver(
+                this,
+                demoReceiver,
+                IntentFilter("com.eried.eucplanet.wear.DEMO"),
+                ContextCompat.RECEIVER_EXPORTED
+            )
+        }
         setContent { WatchApp() }
     }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        if (isDebuggable()) {
+            runCatching { unregisterReceiver(demoReceiver) }
+        }
+    }
 }
+
+private fun Context.isDebuggable(): Boolean =
+    (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0

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

@@ -27,6 +27,7 @@ class WatchBridgeService : WearableListenerService() {
                         wheelName = map.getString(WatchKeys.WHEEL_NAME, "") ?: "",
                         speedKmh = map.getFloat(WatchKeys.SPEED, 0f),
                         batteryPercent = map.getInt(WatchKeys.BATTERY, 0),
+                        phoneBatteryPercent = map.getInt(WatchKeys.PHONE_BATT, 0),
                         voltage = map.getFloat(WatchKeys.VOLTAGE, 0f),
                         current = map.getFloat(WatchKeys.CURRENT, 0f),
                         pwmPercent = map.getFloat(WatchKeys.PWM, 0f),
@@ -36,7 +37,9 @@ class WatchBridgeService : WearableListenerService() {
                         lightOn = map.getBoolean(WatchKeys.LIGHT_ON, false),
                         maxSpeedKmh = map.getFloat(WatchKeys.MAX_SPEED, 0f),
                         hasHorn = map.getBoolean(WatchKeys.HAS_HORN, false),
-                        hasLight = map.getBoolean(WatchKeys.HAS_LIGHT, false)
+                        hasLight = map.getBoolean(WatchKeys.HAS_LIGHT, false),
+                        imperialUnits = map.getBoolean(WatchKeys.IMPERIAL, false),
+                        accentKey = map.getString(WatchKeys.ACCENT, "default") ?: "default"
                     )
                 )
             }

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

@@ -21,6 +21,7 @@ object WatchKeys {
     const val CONNECTED = "c"
     const val SPEED = "s"
     const val BATTERY = "b"
+    const val PHONE_BATT = "b2"
     const val VOLTAGE = "v"
     const val CURRENT = "i"
     const val PWM = "p"
@@ -32,6 +33,8 @@ object WatchKeys {
     const val WHEEL_NAME = "n"
     const val HAS_HORN = "ch"
     const val HAS_LIGHT = "cl"
+    const val IMPERIAL = "im"
+    const val ACCENT = "ac"
     /** Bumped on every snapshot so the watch always sees a fresh DataItem. */
     const val TIMESTAMP = "ts"
 }
@@ -51,6 +54,7 @@ data class WatchState(
     val wheelName: String = "",
     val speedKmh: Float = 0f,
     val batteryPercent: Int = 0,
+    val phoneBatteryPercent: Int = 0,
     val voltage: Float = 0f,
     val current: Float = 0f,
     val pwmPercent: Float = 0f,
@@ -60,5 +64,7 @@ data class WatchState(
     val lightOn: Boolean = false,
     val maxSpeedKmh: Float = 0f,
     val hasHorn: Boolean = false,
-    val hasLight: Boolean = false
+    val hasLight: Boolean = false,
+    val imperialUnits: Boolean = false,
+    val accentKey: String = "default"
 )