Data sources sheet: phone IMU + wheel + RaceBox + Compare

Tap the GPS indicator at the top-right of the dashboard to open a bottom
sheet with live readouts from every source the app currently knows about.
Each source has its own tab and a Compare tab lets the rider pick two
sources and see deltas between their shared metrics.

Sources today
- Phone: GPS speed + lat/lon (TripRepository.currentLocation) plus a
  brand-new TYPE_LINEAR_ACCELERATION listener exposing accel X/Y/Z as g.
- Wheel: BLE telemetry speed only (no GPS or IMU on the wheel).
- RaceBox: existing speed/pos plus new accel parsing for the device's
  0xFF/0x01 extended-frame (accel int16 mg at offsets 68/70/72).
  Standard 0x01/0x07 NAV-PVT still works for basic GPS-only streams.

UI
- Source pills at the top show live / stale state per source.
- Per-source tab renders only the metrics that source provides;
  unavailable rows show "—" so the user understands what's missing.
- G-force crosshair (± 1.5 g) with a fading 75-sample trail. Same
  visual treatment for Phone and RaceBox sources so the rider can
  compare patterns directly.
- Compare tab: two source pickers, speed delta, position-pair
  distance (haversine, m) and a 2-dot mini-map when both sources
  have GPS, plus |G| delta when both have IMU.
- Multi-source ring: when 2+ sources are live a tiny segmented ring
  paints around the GPS icon in the dashboard, one segment per
  source coloured by its palette colour. Doesn't appear for single-
  source case so the icon stays clean by default.

Consistent palette across the screens — Phone blue, Wheel green,
RaceBox purple — to match the existing dial overlay dot.

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

Author: eried

app/src/main/java/com/eried/eucplanet/ble/gps/RaceBoxAdapter.kt

@@ -54,14 +54,19 @@ class RaceBoxAdapter @Inject constructor() : ExternalGpsAdapter {
         // Pull the candidate frame out of the buffer.
         val frame = ByteArray(totalFrameSize) { buffer.removeFirst() }
 
-        // Only NAV-PVT carries position+speed; ignore other frames.
-        if (cls != 0x01 || id != 0x07 || len != 92) return null
-
-        // Fletcher-8 checksum over class, id, length, payload (everything after the
-        // header bytes, before the trailing checksum bytes).
+        // Accept either:
+        //  - Standard UBX NAV-PVT (cls=0x01, id=0x07, len=92): position+speed only.
+        //  - RaceBox extended (cls=0xFF, id=0x01, len=80): position+speed PLUS
+        //    accelerometer X/Y/Z and gyro at the tail. Devices stream this when
+        //    the user enables data recording on the RaceBox companion.
+        val isStandardPvt = cls == 0x01 && id == 0x07 && len == 92
+        val isExtendedPvt = cls == 0xFF && id == 0x01 && len == 80
+        if (!isStandardPvt && !isExtendedPvt) return null
+
+        // Fletcher-8 checksum over class, id, length, payload.
         if (!checksumValid(frame)) return null
 
-        return parsePvt(frame)
+        return if (isExtendedPvt) parseExtendedPvt(frame) else parsePvt(frame)
     }
 
     private fun checksumValid(frame: ByteArray): Boolean {
@@ -113,12 +118,63 @@ class RaceBoxAdapter @Inject constructor() : ExternalGpsAdapter {
         )
     }
 
+    /**
+     * RaceBox extended PVT (cls=0xFF id=0x01, 80-byte payload). The first 60
+     * bytes mirror UBX-NAV-PVT closely so we re-use the same offsets for
+     * fix/position/speed, then read the trailing accelerometer triple.
+     *
+     * Per the RaceBox public protocol notes the tail of the payload carries
+     * accel as int16 milligees (LE) at offsets 68/70/72 — i.e. the last
+     * 6 bytes before checksum start. Gyro words follow but we don't
+     * surface them yet.
+     */
+    private fun parseExtendedPvt(frame: ByteArray): ExternalGpsSample? {
+        val payloadStart = 6
+        if (frame.size < payloadStart + 80) return null
+
+        val fixType = frame[payloadStart + 20].toInt() and 0xFF
+        if (fixType != 2 && fixType != 3 && fixType != 4) return null
+
+        val lonRaw = readInt32LE(frame, payloadStart + 24)
+        val latRaw = readInt32LE(frame, payloadStart + 28)
+        val hMslRaw = readInt32LE(frame, payloadStart + 36)
+        val hAccRaw = readUInt32LE(frame, payloadStart + 40)
+        // Note: in the extended frame the speed field sits at offset 60 too,
+        // same as standard PVT — RaceBox kept the layout compatible for the
+        // shared fields.
+        val gSpeedRaw = readInt32LE(frame, payloadStart + 60)
+
+        // Accel: int16 LE milligees on each axis (positive Y = forward).
+        // Divide by 1000 to get g.
+        val ax = readInt16LE(frame, payloadStart + 68) / 1000f
+        val ay = readInt16LE(frame, payloadStart + 70) / 1000f
+        val az = readInt16LE(frame, payloadStart + 72) / 1000f
+
+        val speedMmS = gSpeedRaw.coerceAtLeast(0)
+        return ExternalGpsSample(
+            source = ExternalGpsSource.RACEBOX,
+            speedKmh = speedMmS * 0.0036f,
+            latitude = latRaw * 1e-7,
+            longitude = lonRaw * 1e-7,
+            altitudeMeters = hMslRaw / 1000f,
+            accuracyMeters = hAccRaw / 1000f,
+            accelXG = ax,
+            accelYG = ay,
+            accelZG = az
+        )
+    }
+
     private fun readInt32LE(b: ByteArray, off: Int): Int =
         (b[off].toInt() and 0xFF) or
             ((b[off + 1].toInt() and 0xFF) shl 8) or
             ((b[off + 2].toInt() and 0xFF) shl 16) or
             ((b[off + 3].toInt() and 0xFF) shl 24)
 
+    private fun readInt16LE(b: ByteArray, off: Int): Int {
+        val v = (b[off].toInt() and 0xFF) or ((b[off + 1].toInt() and 0xFF) shl 8)
+        return if (v and 0x8000 != 0) v or 0x7FFF.inv() else v
+    }
+
     private fun readUInt32LE(b: ByteArray, off: Int): Long =
         readInt32LE(b, off).toLong() and 0xFFFFFFFFL
 }

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

@@ -14,6 +14,13 @@ data class ExternalGpsSample(
     val altitudeMeters: Float,
     /** Horizontal accuracy in metres, or 0 if the device doesn't report it. */
     val accuracyMeters: Float = 0f,
+    /** Linear acceleration in g, or null if the device doesn't report it.
+     *  RaceBox Mini/S/Pro stream accel + gyro alongside the PVT message
+     *  on their custom 0xFF/0x01 frame; basic GPS receivers (Garmin etc.)
+     *  won't fill these in. */
+    val accelXG: Float? = null,
+    val accelYG: Float? = null,
+    val accelZG: Float? = null,
     val timestamp: Long = System.currentTimeMillis()
 )
 

app/src/main/java/com/eried/eucplanet/data/repository/PhoneSensorRepository.kt

@@ -0,0 +1,93 @@
+package com.eried.eucplanet.data.repository
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * One sample from the phone's IMU. Linear acceleration is gravity-subtracted
+ * via Android's TYPE_LINEAR_ACCELERATION sensor, then converted from m/s² to
+ * g so the values line up with what RaceBox reports.
+ *
+ *  x = lateral  (right positive)
+ *  y = vertical (up positive — usually ~0 in linear-accel mode)
+ *  z = forward  (forward positive when the phone is screen-up on the wheel)
+ *
+ * On a phone held by the rider in a pocket the axes don't perfectly line up
+ * with the wheel's motion, so the values are useful as a relative reading
+ * (spikes, magnitudes) but shouldn't be treated as absolute lateral / longitudinal
+ * G the way a RaceBox mounted to the stem would.
+ */
+data class PhoneImuSample(
+    val xG: Float,
+    val yG: Float,
+    val zG: Float,
+    val timestamp: Long = System.currentTimeMillis()
+)
+
+/**
+ * Singleton listener over [SensorManager] that re-emits linear acceleration as
+ * a [PhoneImuSample] StateFlow. Registers lazily on first observer (start) and
+ * unregisters when no longer needed (stop). The repo retains the last sample
+ * so consumers can read a snapshot via [latest].
+ */
+@Singleton
+class PhoneSensorRepository @Inject constructor(
+    @ApplicationContext private val context: Context
+) {
+    private val sensorManager: SensorManager? =
+        context.getSystemService(Context.SENSOR_SERVICE) as? SensorManager
+    private val linearAccel: Sensor? =
+        sensorManager?.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION)
+
+    private val _imu = MutableStateFlow<PhoneImuSample?>(null)
+    val imu: StateFlow<PhoneImuSample?> = _imu.asStateFlow()
+
+    val latest: PhoneImuSample? get() = _imu.value
+    val isAvailable: Boolean get() = linearAccel != null
+
+    private var listening = false
+    private val listener = object : SensorEventListener {
+        override fun onSensorChanged(event: SensorEvent) {
+            if (event.sensor.type != Sensor.TYPE_LINEAR_ACCELERATION) return
+            // m/s² → g (9.80665). x/y/z follow the SensorManager axis convention:
+            // x = device right, y = device up, z = out of screen toward user.
+            _imu.value = PhoneImuSample(
+                xG = event.values[0] / 9.80665f,
+                yG = event.values[1] / 9.80665f,
+                zG = event.values[2] / 9.80665f
+            )
+        }
+
+        override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) { /* unused */ }
+    }
+
+    /** Idempotent — second call while listening is a no-op. Safe to invoke
+     *  every time the dialog opens. */
+    fun start() {
+        if (listening) return
+        val sm = sensorManager ?: return
+        val s = linearAccel ?: return
+        // SENSOR_DELAY_GAME (~20 ms) gives a smooth trail in the crosshair
+        // without pegging the CPU. SENSOR_DELAY_UI (~60 ms) felt choppy on
+        // a Pixel 6 during a tilt test.
+        sm.registerListener(listener, s, SensorManager.SENSOR_DELAY_GAME)
+        listening = true
+    }
+
+    /** Stop callback registration. Sample stays in [latest] until the next
+     *  start, so the UI can still show the last reading after dismissing. */
+    fun stop() {
+        if (!listening) return
+        sensorManager?.unregisterListener(listener)
+        listening = false
+    }
+}

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

@@ -193,6 +193,7 @@ fun DashboardScreen(
     var showQuitDialog by remember { mutableStateOf(false) }
     var showDisconnectDialog by remember { mutableStateOf(false) }
     var showNoTripsDialog by remember { mutableStateOf(false) }
+    var showSourcesSheet by remember { mutableStateOf(false) }
     var showSettingsMenu by remember { mutableStateOf(false) }
     var showRestoreConfirmDialog by remember { mutableStateOf(false) }
     val hasSyncFolder by viewModel.hasSyncFolder.collectAsState()
@@ -486,20 +487,65 @@ fun DashboardScreen(
                 //   no permission  -> GpsOff (dim)
                 //   no fix yet     -> GpsNotFixed (dim)
                 //   locked         -> GpsFixed (green)
+                // Tapping the icon opens the multi-source live data sheet
+                // (Phone / Wheel / RaceBox / Compare). When more than one
+                // source is live we paint a small colored ring around the
+                // icon as a hint that there's combined data to inspect.
                 val gpsIcon = when {
                     !locationGranted -> Icons.Default.GpsOff
                     gpsFix -> Icons.Default.GpsFixed
                     else -> Icons.Default.GpsNotFixed
                 }
-                DashIndicatorIcon(
-                    icon = gpsIcon,
-                    active = gpsFix && locationGranted,
-                    activeColor = if (useAccent) primary else AccentGreen,
+                val liveSources = buildList {
+                    if (gpsFix && locationGranted)
+                        add(com.eried.eucplanet.ui.dashboard.sources.DataSource.PHONE)
+                    if (connectionState == ConnectionState.CONNECTED)
+                        add(com.eried.eucplanet.ui.dashboard.sources.DataSource.WHEEL)
+                    if (externalGpsSpeed != null)
+                        add(com.eried.eucplanet.ui.dashboard.sources.DataSource.RACEBOX)
+                }
+                Box(
                     modifier = Modifier
                         .align(Alignment.TopEnd)
                         .offset(x = 4.dp)
                         .padding(top = 8.dp)
-                )
+                        .clickable { showSourcesSheet = true }
+                ) {
+                    DashIndicatorIcon(
+                        icon = gpsIcon,
+                        active = gpsFix && locationGranted,
+                        activeColor = if (useAccent) primary else AccentGreen,
+                        modifier = Modifier
+                    )
+                    // Multi-source ring overlay — one short arc per live
+                    // source, equally divided around the icon. Single-source
+                    // case skips the ring entirely so the icon doesn't grow
+                    // a useless decoration when only Phone is providing data.
+                    if (liveSources.size >= 2) {
+                        Canvas(
+                            modifier = Modifier
+                                .matchParentSize()
+                                .padding(2.dp)
+                        ) {
+                            val r = size.minDimension / 2f - 1f
+                            val center = androidx.compose.ui.geometry.Offset(size.width / 2f, size.height / 2f)
+                            val sweep = 360f / liveSources.size
+                            val gap = 8f  // degrees between segments
+                            liveSources.forEachIndexed { idx, src ->
+                                val start = idx * sweep + gap / 2f
+                                drawArc(
+                                    color = src.color,
+                                    startAngle = start - 90f,
+                                    sweepAngle = sweep - gap,
+                                    useCenter = false,
+                                    topLeft = androidx.compose.ui.geometry.Offset(center.x - r, center.y - r),
+                                    size = androidx.compose.ui.geometry.Size(r * 2, r * 2),
+                                    style = androidx.compose.ui.graphics.drawscope.Stroke(width = 2.5f)
+                                )
+                            }
+                        }
+                    }
+                }
             }
 
             Spacer(Modifier.height(16.dp))
@@ -819,6 +865,13 @@ fun DashboardScreen(
                 )
             }
 
+            if (showSourcesSheet) {
+                com.eried.eucplanet.ui.dashboard.sources.DataSourcesSheet(
+                    imperial = imperial,
+                    onDismiss = { showSourcesSheet = false }
+                )
+            }
+
             if (showAboutDialog) {
                 val crashes = remember { com.eried.eucplanet.util.CrashHandler.listCrashes(context) }
                 val licenseText = remember {

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

@@ -0,0 +1,54 @@
+package com.eried.eucplanet.ui.dashboard.sources
+
+import androidx.compose.ui.graphics.Color
+import com.eried.eucplanet.ui.theme.AccentBlue
+import com.eried.eucplanet.ui.theme.AccentGreen
+import com.eried.eucplanet.ui.theme.AccentPurple
+
+/**
+ * One of the three live data sources the dashboard knows about. The enum is
+ * stable across the UI: same icon, same colour, same string label everywhere
+ * the dialog shows it, so users build a mental map of "blue = phone, green =
+ * wheel, purple = RaceBox" that carries through to the overlay dot on the
+ * speed dial and the lines on the trip-detail chart.
+ */
+enum class DataSource(val displayName: String, val color: Color) {
+    PHONE("Phone", AccentBlue),
+    WHEEL("Wheel", AccentGreen),
+    RACEBOX("RaceBox", AccentPurple);
+
+    /**
+     * Capability flags so each tab can render the right rows without
+     * branching deep inside the view code. Update these alongside the
+     * underlying repository when a new metric becomes available.
+     */
+    val hasSpeed: Boolean get() = true                  // all three expose speed
+    val hasPosition: Boolean get() = this != WHEEL      // wheel has no GPS
+    val hasImu: Boolean get() = this == PHONE || this == RACEBOX
+}
+
+/**
+ * Snapshot fed to the source dialog. Each field is nullable so the UI can
+ * dash out rows the source doesn't currently provide (e.g. RaceBox accel
+ * stays null until the device sends an extended-frame, even though the
+ * source claims hasImu = true at the enum level).
+ */
+data class SourceSnapshot(
+    val speedKmh: Float? = null,
+    val latitude: Double? = null,
+    val longitude: Double? = null,
+    /** True when speed/position values are flowing live; UI dims when false. */
+    val isLive: Boolean = false,
+    /** Accel in g, axes aligned to the source's reference frame. */
+    val accelXG: Float? = null,
+    val accelYG: Float? = null,
+    val accelZG: Float? = null
+) {
+    /** Magnitude of horizontal G-force, useful as a single safety number. */
+    val horizGMagnitude: Float?
+        get() {
+            val x = accelXG ?: return null
+            val z = accelZG ?: return null
+            return kotlin.math.sqrt(x * x + z * z)
+        }
+}