Make the event detector a CAM rate input, not a ride-stats readout

The detector's only live consumer is the CAM transmit-rate policy: every emitted event calls CamTransmitLoop.onDetectedEvent, raising the beacon rate from 1 Hz to the elevated rate for five seconds so nearby stations get denser updates through a manoeuvre. Counting one's own braking events is not a goal of this project, so the display is gone and the detector stays: the live per-type counters and their notification text, the event pins and detail sheet on the trip review map, and the event chip on the history card. Events are still persisted and exported to CSV, which is the only route to the tuning measurement section 11.3 says is missing. Fix two defects found while documenting the detector. TripRecordingService overrode nine of DetectionConfig's twelve parameters in its constructor, so the tests validated the Phase A defaults while the phone ran something materially less sensitive. The tuned values are now the defaults and the override is deleted; the numbers moved location, not value, so detector sensitivity is unchanged. EventDetectorTest now sets only windowSize and the sustained-frame counts and inherits every signal threshold, which cannot drift again. That was not a free change and makes the same point from the other side: at the real thresholds the old stimuli triggered nothing. Accel alternating 3.5/0.5 gives a std dev of 1.5 and never clears 1.8, and the moderate-braking case used a 0.8 m/s drop that never clears 1.0. Those stimuli are re-derived against the real values. brakingHighConfidenceRate was documented as a rate but has always been compared against the peak cumulative drop from the onset speed, which grows with episode length, so HIGH was assigned more readily than the name implied. Renamed to brakingHighConfidencePeakDrop rather than changing the comparison: "lost more than 1.5 m/s in one episode" is coherent, whereas a rate off a 1 Hz speed signal sampled at 50 Hz spikes on a near-zero divisor early in an episode. Output is unchanged, so the existing confidence assertions stay evidence instead of being re-baselined. Docs 11.3/11.4 updated in place, including the correction of a claim that detected events do not reach the V2X side; the rate-bump path already existed when that was written. 55 tests, 0 failures.
2026-09-08 16:20:14 +02:00
parent 83ccf335bb
commit 1ad123a6f8
16 changed files with 132 additions and 312 deletions
@@ -248,10 +248,7 @@ class MainActivity : AppCompatActivity() {
                            val trip  = trips.firstOrNull { it.id == tripId }

                            if (trip != null) {
-                                TripReviewScreen(
-                                    trip = trip,
-                                    viewModel = tripViewModel,
-                                )
+                                TripReviewScreen(trip = trip)
                            }
                        }

@@ -4,7 +4,26 @@ package com.hawhamburg.micr0bu.domain.detection
 * All detection thresholds in one place.
 *
 * Pass a custom instance to [EventDetector] to tune behaviour without
- * recompiling.  The defaults match the Phase A specification.
+ * recompiling.
+ *
+ * **These defaults are the values the app actually runs.**  They are *not* the
+ * Phase A specification figures.  Phase A specified a more sensitive detector;
+ * running it on a real bicycle over-triggered, so every signal threshold was
+ * raised and every sustain requirement lengthened.  Those tuned values used to
+ * live as literals in `TripRecordingService`'s constructor, which meant the
+ * unit tests exercised the Phase A defaults and nothing exercised what shipped.
+ * They are the defaults now so that there is exactly one configuration.
+ *
+ * The original Phase A figures, kept for provenance:
+ * `brakingSpeedDropThreshold` 0.5, `brakingAccelStdDevThreshold` 1.2,
+ * `brakingSustainedFrames` 15, `turningGyroMeanThreshold` 0.4,
+ * `turningBearingChangeThreshold` 10.0, `turningSustainedFrames` 20,
+ * `stoppingSpeedThreshold` 0.5, `stoppingFrames` 100,
+ * `stoppingAccelStdDevThreshold` 0.15.
+ *
+ * What motivated each change was never recorded, and the effect on the
+ * false-positive and false-negative rates has never been measured.  That
+ * remains open; sensitivity is deliberately unchanged by this consolidation.
 */
 data class DetectionConfig(

@@ -17,42 +36,51 @@ data class DetectionConfig(
     * Minimum speed drop (m/s) from the reference speed at braking onset for
     * a frame to qualify as a braking frame.
     */
-    val brakingSpeedDropThreshold: Double = 0.5,
+    val brakingSpeedDropThreshold: Double = 1.0,

    /** Minimum accel std-dev (m/s²) required for a frame to count as braking. */
-    val brakingAccelStdDevThreshold: Double = 1.2,
+    val brakingAccelStdDevThreshold: Double = 1.8,

    /** Consecutive braking frames required before an event is emitted. */
-    val brakingSustainedFrames: Int = 15,
+    val brakingSustainedFrames: Int = 25,

    /**
-     * Peak speed-drop rate (m/s per GPS update ≈ m/s²) above which the braking
-     * confidence is upgraded from MEDIUM to HIGH.
+     * Peak *cumulative* speed drop (m/s) from the onset reference speed above
+     * which the braking confidence is upgraded from MEDIUM to HIGH.
+     *
+     * This is a total drop for the episode, not a rate.  It was previously
+     * named `brakingHighConfidenceRate` and documented as "m/s per GPS update
+     * ≈ m/s²", but the quantity it is compared against in
+     * [EventDetector.detectBraking] has always been the cumulative drop, which
+     * grows for as long as the episode lasts.  The name was wrong, not the
+     * comparison: "the rider lost more than this much speed in one braking
+     * episode" is a coherent criterion, so the name was corrected to match the
+     * behaviour rather than the other way round.  Detector output is unchanged.
     */
-    val brakingHighConfidenceRate: Double = 1.5,
+    val brakingHighConfidencePeakDrop: Double = 1.5,

    // ── TURNING ───────────────────────────────────────────────────────────────
    /** Minimum gyro mean (rad/s) required for a frame to qualify as turning. */
-    val turningGyroMeanThreshold: Double = 0.4,
+    val turningGyroMeanThreshold: Double = 0.6,

    /** Bearing-change rate (°/s) that must be exceeded when speed is above the
     *  minimum threshold for a HIGH-confidence turning confirmation. */
-    val turningBearingChangeThreshold: Double = 10.0,
+    val turningBearingChangeThreshold: Double = 15.0,

    /** GPS speed (m/s) above which the bearing-change criterion is enforced. */
    val turningMinSpeedThreshold: Double = 2.0,

    /** Consecutive turning frames required before an event is emitted. */
-    val turningSustainedFrames: Int = 20,
+    val turningSustainedFrames: Int = 30,

    // ── STOPPING ─────────────────────────────────────────────────────────────
    /** GPS speed (m/s) below which a frame is considered a potential stop. */
-    val stoppingSpeedThreshold: Double = 0.5,
+    val stoppingSpeedThreshold: Double = 0.3,

    /** Consecutive stop frames required (> this value) before an event is emitted.
-     *  At 50 Hz, 100 frames ≈ 2 s. */
-    val stoppingFrames: Int = 100,
+     *  At 50 Hz, 150 frames ≈ 3 s. */
+    val stoppingFrames: Int = 150,

    /** Maximum accel std-dev (m/s²) allowed for a frame to count as stationary. */
-    val stoppingAccelStdDevThreshold: Double = 0.15,
+    val stoppingAccelStdDevThreshold: Double = 0.10,
 )
@@ -14,6 +14,16 @@ import kotlin.math.abs
 * to [events] (a hot [SharedFlow]).  Debounce is implemented with
 * consecutive-frame counters, not timers.
 *
+ * **Who consumes this.**  The detector's live consumer is the CAM transmit-rate
+ * policy: [com.hawhamburg.micr0bu.service.TripRecordingService] forwards every
+ * emitted event to
+ * [com.hawhamburg.micr0bu.service.CamTransmitLoop.onDetectedEvent], which
+ * raises the CAM rate from 1 Hz to the elevated rate for a hold window so that
+ * nearby stations get denser updates *through* a manoeuvre rather than only at
+ * the instant it was detected.  These thresholds therefore govern a V2X
+ * behaviour, not a statistic.  Events are also persisted per trip for offline
+ * analysis and CSV export, but nothing in the UI displays them.
+ *
 * GPS updates at 1 Hz whilst sensors fire at ~50 Hz.  [speedMps] and
 * [bearingChangeDegPerSec] should be the values from the last known GPS fix;
 * the detector compares speed against a *reference speed at braking onset*
@@ -37,7 +47,7 @@ class EventDetector(private val config: DetectionConfig = DetectionConfig()) {
    private var brakingFrames      = 0
    private var brakingOnsetSpeed  = 0.0  // reference speed when braking started
    private var brakingStartTime   = 0L
-    private var peakBrakingDrop    = 0.0  // peak speed drop observed during this window
+    private var peakBrakingDrop    = 0.0  // peak CUMULATIVE drop from onset speed, m/s (not a rate)
    private var peakAccelBraking   = 0.0

    // ── Turning state ─────────────────────────────────────────────────────────
@@ -124,7 +134,7 @@ class EventDetector(private val config: DetectionConfig = DetectionConfig()) {

            if (brakingFrames == config.brakingSustainedFrames) {
                val confidence =
-                    if (peakBrakingDrop > config.brakingHighConfidenceRate) Confidence.HIGH
+                    if (peakBrakingDrop > config.brakingHighConfidencePeakDrop) Confidence.HIGH
                    else Confidence.MEDIUM

                _events.tryEmit(
@@ -26,9 +26,7 @@ import com.hawhamburg.micr0bu.R
 import com.hawhamburg.micr0bu.data.TripRepository
 import com.hawhamburg.micr0bu.data.cam.CamUseCaseRepository
 import com.hawhamburg.micr0bu.data.db.AppDatabase
-import com.hawhamburg.micr0bu.domain.detection.DetectionConfig
 import com.hawhamburg.micr0bu.domain.detection.EventDetector
-import com.hawhamburg.micr0bu.domain.detection.EventType
 import dagger.hilt.android.AndroidEntryPoint
 import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
@@ -108,19 +106,10 @@ class TripRecordingService : Service() {
    // V2xMessageEntity's KDoc for why nothing is retained outside of one.
    @Inject lateinit var camUseCaseRepository: CamUseCaseRepository
    private var v2xLoggingJob: Job? = null
-    private val detector = EventDetector(
-        DetectionConfig(
-            brakingSpeedDropThreshold     = 1.0,
-            brakingAccelStdDevThreshold   = 1.8,
-            brakingSustainedFrames        = 25,
-            turningGyroMeanThreshold      = 0.6,
-            turningBearingChangeThreshold = 15.0,
-            turningSustainedFrames        = 30,
-            stoppingSpeedThreshold        = 0.3,
-            stoppingFrames                = 150,
-            stoppingAccelStdDevThreshold  = 0.10,
-        )
-    )
+    // These nine thresholds used to be overridden here; they are now the DetectionConfig
+    // defaults, so there is one configuration and the unit tests exercise it. Behaviour is
+    // unchanged - see DetectionConfig's KDoc.
+    private val detector = EventDetector()

    // ── Sensor fusion state ───────────────────────────────────────────────────

@@ -153,10 +142,10 @@ class TripRecordingService : Service() {
    private val gpsTrackBuilder = StringBuilder("[")
    private var gpsPointCount   = 0

-    // Event counts
-    private var brakingCount  = 0
-    private var turningCount  = 0
-    private var stoppingCount = 0
+    // Number of detected events in this trip. Kept only to populate the trips.eventCount
+    // column; the per-type counts are no longer surfaced anywhere (see EventDetector's KDoc
+    // for why the detector still runs).
+    private var detectedEventCount = 0

    // ── SensorEventListener ───────────────────────────────────────────────────

@@ -253,9 +242,7 @@ class TripRecordingService : Service() {
        ).also { it.acquire() }

        detector.reset()
-        brakingCount  = 0
-        turningCount  = 0
-        stoppingCount = 0
+        detectedEventCount = 0
        distanceMetres = 0f
        prevLat = Double.NaN
        prevLon = Double.NaN
@@ -273,15 +260,14 @@ class TripRecordingService : Service() {
                    isRecording    = true,
                    currentTripId  = currentTripId,
                    elapsedSeconds = 0L,
-                    brakingCount   = 0,
-                    turningCount   = 0,
-                    stoppingCount  = 0,
                    currentSpeedMs = 0f,
                )
            }
        }

-        // Collect detector events and persist them
+        // Collect detector events. The detector's primary consumer is the CAM transmit rate
+        // policy below; persistence is retained so a recorded ride can still be analysed
+        // offline, but nothing in the UI reads it.
        serviceScope.launch {
            detector.events.collect { event ->
                if (currentTripId < 0) return@collect
@@ -289,19 +275,7 @@ class TripRecordingService : Service() {
                // Bump the CAM transmit rate through the maneuver, not just at detection instant.
                // No-op on the CiT One path (see CamTransmitLoop's KDoc).
                camTransmitLoop.onDetectedEvent()
-                when (event.type) {
-                    EventType.BRAKING  -> brakingCount++
-                    EventType.TURNING  -> turningCount++
-                    EventType.STOPPING -> stoppingCount++
-                }
-                TripServiceBus.update {
-                    copy(
-                        brakingCount  = this@TripRecordingService.brakingCount,
-                        turningCount  = this@TripRecordingService.turningCount,
-                        stoppingCount = this@TripRecordingService.stoppingCount,
-                    )
-                }
-                updateNotification()
+                detectedEventCount++
            }
        }

@@ -356,7 +330,7 @@ class TripRecordingService : Service() {
        v2xLoggingJob = null

        val endTime = System.currentTimeMillis()
-        val totalEvents = brakingCount + turningCount + stoppingCount
+        val totalEvents = detectedEventCount

        // Close GPS track JSON
        gpsTrackBuilder.append("]")
@@ -454,10 +428,7 @@ class TripRecordingService : Service() {
    private fun buildNotification(elapsedSeconds: Long) =
        NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Recording trip")
-            .setContentText(
-                "⏱ ${formatElapsed(elapsedSeconds)}  ·  " +
-                "🚨 $brakingCount  🔄 $turningCount  🛑 $stoppingCount"
-            )
+            .setContentText("⏱ ${formatElapsed(elapsedSeconds)}")
            .setSmallIcon(R.mipmap.ic_launcher_foreground)
            .setOngoing(true)
            .setOnlyAlertOnce(true)
@@ -17,9 +17,6 @@ object TripServiceBus {
        val isRecording: Boolean = false,
        val currentTripId: Long = -1L,
        val elapsedSeconds: Long = 0L,
-        val brakingCount: Int = 0,
-        val turningCount: Int = 0,
-        val stoppingCount: Int = 0,
        val currentSpeedMs: Float = 0f,
    )

@@ -141,46 +141,6 @@ fun RecordingScreen(

        Spacer(Modifier.height(8.dp))

-        // ── Event Detection Counters ─────────────────────────────────────────
-        if (state.isRecording || tripServiceState.isRecording) {
-            Text(
-                stringResource(R.string.rec_events_detected),
-                style = MaterialTheme.typography.titleMedium,
-                fontWeight = FontWeight.SemiBold,
-                modifier = Modifier.align(Alignment.Start),
-            )
-
-            Card(
-                modifier = Modifier.fillMaxWidth(),
-                colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.secondaryContainer),
-            ) {
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 16.dp, vertical = 12.dp),
-                    horizontalArrangement = Arrangement.SpaceEvenly,
-                ) {
-                    EventCountBadge(
-                        label = stringResource(R.string.rec_event_braking),
-                        count = tripServiceState.brakingCount,
-                        color = Color(0xFFFF5252),
-                    )
-                    EventCountBadge(
-                        label = stringResource(R.string.rec_event_turning),
-                        count = tripServiceState.turningCount,
-                        color = Color(0xFFFFB300),
-                    )
-                    EventCountBadge(
-                        label = stringResource(R.string.rec_event_stopping),
-                        count = tripServiceState.stoppingCount,
-                        color = Color(0xFF42A5F5),
-                    )
-                }
-            }
-
-            Spacer(Modifier.height(4.dp))
-        }
-
        // ── CSV Session Log shortcut ─────────────────────────────────────────
        if (!state.isRecording) {
            OutlinedButton(
@@ -228,25 +188,6 @@ fun RecordingScreen(
    }
 }

-@Composable
-private fun EventCountBadge(label: String, count: Int, color: Color) {
-    Column(horizontalAlignment = Alignment.CenterHorizontally) {
-        Text(
-            text = count.toString(),
-            style = MaterialTheme.typography.headlineSmall,
-            fontWeight = FontWeight.Bold,
-            fontFamily = FontFamily.Monospace,
-            color = color,
-        )
-        Spacer(Modifier.height(2.dp))
-        Text(
-            text = label,
-            style = MaterialTheme.typography.labelSmall,
-            color = MaterialTheme.colorScheme.onSecondaryContainer,
-        )
-    }
-}
-
@Composable
 private fun StreamRow(label: String, active: Boolean) {
    Row(
@@ -145,7 +145,6 @@ private fun TripCard(
                    val durationSec = ((trip.endTime - trip.startTime) / 1000).coerceAtLeast(0)
                    TripStatChip("⏱ ${formatDuration(durationSec)}")
                    TripStatChip("📍 ${formatDistance(trip.distanceMetres)}")
-                    TripStatChip("🚨 ${trip.eventCount} events")
                }
            }
            IconButton(onClick = onOpen) {
@@ -42,9 +42,7 @@ import androidx.compose.ui.viewinterop.AndroidView
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import androidx.lifecycle.compose.LocalLifecycleOwner
-import com.hawhamburg.micr0bu.data.db.DetectedEventEntity
 import com.hawhamburg.micr0bu.data.db.RecordedTripEntity
-import com.hawhamburg.micr0bu.viewmodel.TripRecordingViewModel
 import kotlinx.coroutines.launch
 import org.osmdroid.config.Configuration
 import org.osmdroid.tileprovider.tilesource.TileSourceFactory
@@ -61,7 +59,6 @@ import java.util.Locale
@Composable
 fun TripReviewScreen(
    trip: RecordedTripEntity,
-    viewModel: TripRecordingViewModel,
    modifier: Modifier = Modifier,
 ) {
    val context = LocalContext.current
@@ -70,15 +67,8 @@ fun TripReviewScreen(
    // provider is ready before MapView is constructed in the factory block.
    initOsmReview(context)

-    LaunchedEffect(trip.id) { viewModel.loadTripEvents(trip.id) }
-    val events by viewModel.selectedTripEvents.collectAsState()
-
    val gpsPoints = remember(trip.gpsTrackJson) { parseGpsTrack(trip.gpsTrackJson) }

-    var selectedEvent by remember { mutableStateOf<DetectedEventEntity?>(null) }
-    val sheetState    = rememberModalBottomSheetState(skipPartiallyExpanded = true)
-    val scope         = rememberCoroutineScope()
-
    val mapViewRef   = remember { mutableStateOf<MapView?>(null) }
    val lifecycleOwner = LocalLifecycleOwner.current

@@ -108,13 +98,6 @@ fun TripReviewScreen(
                fontWeight = FontWeight.Medium,
                color = MaterialTheme.colorScheme.onSurfaceVariant,
            )
-            Text(
-                "🚨 ${events.count { it.type == "BRAKING" }}  " +
-                "🔄 ${events.count { it.type == "TURNING" }}  " +
-                "🛑 ${events.count { it.type == "STOPPING" }}",
-                style = MaterialTheme.typography.labelSmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
        }

        // ── Map ───────────────────────────────────────────────────────────────
@@ -141,33 +124,6 @@ fun TripReviewScreen(
                    mv.overlays.add(polyline)
                }

-                // Event pins
-                events.forEach { event ->
-                    val pinColor = when (event.type) {
-                        "BRAKING"  -> Color(0xFFFF5252)
-                        "TURNING"  -> Color(0xFFFFB300)
-                        "STOPPING" -> Color(0xFF42A5F5)
-                        else       -> Color.Gray
-                    }
-                    val marker = Marker(mv).apply {
-                        position = GeoPoint(event.latitude, event.longitude)
-                        setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_BOTTOM)
-                        title = "${event.type}  (${event.confidence})"
-                        setOnMarkerClickListener { _, _ ->
-                            selectedEvent = event
-                            scope.launch { sheetState.show() }
-                            true
-                        }
-                        // Solid-circle pin in the event color
-                        icon = GradientDrawable().apply {
-                            shape = GradientDrawable.OVAL
-                            setColor(pinColor.toArgb())
-                            setSize(32, 32)
-                        }
-                    }
-                    mv.overlays.add(marker)
-                }
-
                // Auto-fit the camera to the track — deferred via post() so the
                // MapView has been measured before zoomToBoundingBox is called.
                // Calling it with width/height == 0 (before first layout) crashes osmdroid.
@@ -193,82 +149,6 @@ fun TripReviewScreen(
        )
    }

-    // ── Event detail bottom sheet ─────────────────────────────────────────────
-    val ev = selectedEvent
-    if (ev != null) {
-        ModalBottomSheet(
-            onDismissRequest = { selectedEvent = null },
-            sheetState = sheetState,
-            dragHandle = { BottomSheetDefaults.DragHandle() },
-        ) {
-            EventDetailSheet(event = ev, onDismiss = {
-                scope.launch { sheetState.hide() }.invokeOnCompletion { selectedEvent = null }
-            })
-        }
-    }
-}
-
-// ── Event detail sheet content ────────────────────────────────────────────────
-
-@Composable
-private fun EventDetailSheet(event: DetectedEventEntity, onDismiss: () -> Unit) {
-    // Created here (not as a top-level static field) so it always uses the
-    // current locale even if the user changes it while the app is running.
-    val sdf = remember { SimpleDateFormat("HH:mm:ss", Locale.getDefault()) }
-
-    val accentColor = when (event.type) {
-        "BRAKING"  -> Color(0xFFFF5252)
-        "TURNING"  -> Color(0xFFFFB300)
-        "STOPPING" -> Color(0xFF42A5F5)
-        else       -> MaterialTheme.colorScheme.primary
-    }
-
-    Column(modifier = Modifier.padding(horizontal = 20.dp).padding(bottom = 32.dp)) {
-        Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
-            Text(
-                event.type.replaceFirstChar { it.titlecase() },
-                style = MaterialTheme.typography.headlineSmall,
-                fontWeight = FontWeight.Bold,
-                color = accentColor,
-                modifier = Modifier.weight(1f),
-            )
-            IconButton(onClick = onDismiss) {
-                Icon(Icons.Default.Close, contentDescription = "Close")
-            }
-        }
-
-        Text(
-            "Confidence: ${event.confidence}",
-            style = MaterialTheme.typography.bodyMedium,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-        )
-        Text(
-            sdf.format(Date(event.timestamp)),
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-        )
-
-        Spacer(Modifier.height(12.dp))
-        HorizontalDivider()
-        Spacer(Modifier.height(12.dp))
-
-        EventDetailRow("Speed",         "%.1f m/s".format(event.speedMps))
-        EventDetailRow("Peak accel",    "%.2f m/s²".format(event.peakAccelMagnitude))
-        EventDetailRow("Peak gyro",     "%.3f rad/s".format(event.peakGyroMagnitude))
-        EventDetailRow("Duration",      "${event.durationMs} ms")
-        EventDetailRow("Location",      "%.5f°, %.5f°".format(event.latitude, event.longitude))
-    }
-}
-
-@Composable
-private fun EventDetailRow(label: String, value: String) {
-    Row(
-        modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
-        horizontalArrangement = Arrangement.SpaceBetween,
-    ) {
-        Text(label, style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
-        Text(value, style = MaterialTheme.typography.bodyMedium, fontFamily = FontFamily.Monospace, fontWeight = FontWeight.Medium)
-    }
 }

 // ── GPS track parsing ─────────────────────────────────────────────────────────
@@ -9,7 +9,6 @@ import androidx.lifecycle.viewModelScope
 import com.hawhamburg.micr0bu.data.TripRepository
 import com.hawhamburg.micr0bu.data.shareTripCsv
 import com.hawhamburg.micr0bu.data.db.AppDatabase
-import com.hawhamburg.micr0bu.data.db.DetectedEventEntity
 import com.hawhamburg.micr0bu.data.db.RecordedTripEntity
 import com.hawhamburg.micr0bu.service.TripRecordingService
 import com.hawhamburg.micr0bu.service.TripServiceBus
@@ -66,20 +65,6 @@ class TripRecordingViewModel(application: Application) : AndroidViewModel(applic
    /** All recorded trips, newest first. */
    val trips: Flow<List<RecordedTripEntity>> = repository.getAllTrips()

-    // ── Trip review ───────────────────────────────────────────────────────────
-
-    private val _selectedTripEvents = MutableStateFlow<List<DetectedEventEntity>>(emptyList())
-    val selectedTripEvents: StateFlow<List<DetectedEventEntity>> = _selectedTripEvents.asStateFlow()
-
-    /** Load events for [tripId] into [selectedTripEvents]. */
-    fun loadTripEvents(tripId: Long) {
-        viewModelScope.launch {
-            repository.getEventsForTrip(tripId).collect { events ->
-                _selectedTripEvents.value = events
-            }
-        }
-    }
-
    // ── Recording control ─────────────────────────────────────────────────────

    /**