fix: refresh foreground notification every minute, not only on stale flips (#223)

* fix: refresh foreground notification every minute, not only on stale flips

The stale-check loop previously only called updateNotification() when the
stale-state flipped or workout mode was active:

    if (isStale != wasStale || workoutCountdownActive || workoutModeOn) {
        updateNotification()
    }

This left the notification's "Xm" since-text (and the IOB / alert-pause /
workout-elapsed countdowns rendered in composeReadingText) frozen at
whatever value they had at the moment of the last reading. The most visible
symptom: when CamAPS stops posting fresh values (sensor disconnect,
"Attempting" reposts that the parser correctly drops), the notification
keeps showing "0m" against the last good value until either a new reading
arrives or the 10-min stale threshold trips. The user gets a false sense
that data is fresh when it isn't.

Drop the gate — call updateNotification() on every tick (every 60 s). The
work is one DB read + one IOB calc + one notification rebuild; cheap
enough at this cadence and the only path that keeps the displayed
counters honest. The original gate's stated reason (avoid rebuilding
during stable readings) doesn't justify the silent-stale display in a
medical app.

Also drop the now-unused `wasStale` field.

Verified on device: with no new readings for >1 min, the notification
"Xm" advances correctly each minute.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* fix: refresh widget every minute alongside notification, add render-test

The 60s tick in startStaleCheckLoop was rebuilding the foreground
notification but not the home-screen widget. The widget's "Xm" / "now"
freshness label is computed from System.currentTimeMillis() - reading.ts
(StrimmaWidget.kt:120) but updateWidgets() was only called from
onNewReading — between readings the widget froze at whatever counter
value it had at the last reading-arrival, mirroring the notification bug
that #223 fixes. Same medical-safety class (a glanceable surface lying
about freshness).

Adds NotificationHelperRenderTest pinning the rendering contract that
the loop depends on: each call to buildNotification produces a tv_delta
text reflecting the current elapsed minutes from reading.ts (0m / 5m /
9m). If a future refactor breaks the rendering math or someone
re-introduces a gate around the per-tick updateNotification call, this
catches the rendering-side half of the regression.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: psjostrom

app/src/main/java/com/psjostrom/strimma/service/StrimmaService.kt

@@ -104,8 +104,6 @@ class StrimmaService : Service() {
     private var followerJob: Job? = null
     private var lluFollowerJob: Job? = null
     private var calendarPollJob: Job? = null
-    @Volatile
-    private var wasStale = true // Start as stale (no data yet)
     private lateinit var workoutTriggerMinutes: StateFlow<Int>
 
     private lateinit var predMinutes: StateFlow<Int>
@@ -269,17 +267,17 @@ class StrimmaService : Service() {
                 val latest = dao.latestOnce()
                 alertManager.checkStale(latest?.ts)
 
-                val isStale = AlertManager.isStale(latest?.ts)
-                val workoutCountdownActive =
-                    WorkoutAlarmReceiver.notificationTriggerFired.get() && calendarPoller.nextEvent.value != null
-                // Refresh notification once per minute during workout mode so the
-                // "Workout 0:42" elapsed counter actually advances. Without this the
-                // counter is computed once on state-transition and lies for the rest
-                // of the session unless a new CGM reading arrives.
-                val workoutModeOn = workoutModeManager.state.value is WorkoutMode.On
-                if (isStale != wasStale || workoutCountdownActive || workoutModeOn) {
-                    updateNotification()
-                }
+                // Always rebuild the foreground notification AND the home-screen widget
+                // each tick. Both surfaces show time-driven counters that need wall-clock
+                // recomputation every minute: the notification's "Xm" since-text + IOB
+                // countdown + alert-pause countdown + workout-mode "0:42" elapsed, and the
+                // widget's "Xm" / "now" freshness label. The previous gate (refresh only on
+                // stale-state transitions or workout mode) left these counters frozen at
+                // whatever value they had at the moment of the last reading — most visibly,
+                // both surfaces would show "0m" continuously until either the 10-min stale
+                // threshold tripped or the next reading arrived.
+                updateNotification()
+                updateWidgets()
 
                 calendarPoller.nextEvent.value?.let { event ->
                     if (System.currentTimeMillis() > event.startTime + WORKOUT_GRACE_MINUTES * MS_PER_MINUTE) {
@@ -448,7 +446,6 @@ class StrimmaService : Service() {
         val latest = dao.latestOnce()?.takeUnless { reading ->
             AlertManager.isStale(reading.ts)
         }
-        wasStale = (latest == null)
         val graphWindowMs = notifGraphMinutes.value.toLong() * MS_PER_MINUTE
         val now = System.currentTimeMillis()
         val recent = dao.since(now - graphWindowMs)

app/src/test/java/com/psjostrom/strimma/notification/NotificationHelperRenderTest.kt

@@ -0,0 +1,71 @@
+package com.psjostrom.strimma.notification
+
+import android.content.Context
+import android.widget.FrameLayout
+import android.widget.TextView
+import androidx.test.core.app.ApplicationProvider
+import com.psjostrom.strimma.R
+import com.psjostrom.strimma.data.GlucoseReading
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Pins the rendering contract that `StrimmaService.startStaleCheckLoop` depends on:
+ * each call to `updateNotification` must produce a since-text that reflects the current
+ * wall-clock elapsed time from the reading. If a future refactor re-introduces a gate
+ * around the per-tick `updateNotification()` call (see PR #223), the user-visible "Xm"
+ * counter would freeze between readings — these tests guard against that by verifying
+ * the rendering side responds to changing elapsed time.
+ */
+@RunWith(RobolectricTestRunner::class)
+class NotificationHelperRenderTest {
+
+    private fun helper(): NotificationHelper {
+        val context: Context = ApplicationProvider.getApplicationContext()
+        return NotificationHelper(context).also { it.createChannel() }
+    }
+
+    private fun renderedDeltaText(reading: GlucoseReading): String {
+        val context: Context = ApplicationProvider.getApplicationContext()
+        val notif = helper().buildNotification(
+            reading = reading,
+            recentReadings = listOf(reading),
+            bgLow = 70.0,
+            bgHigh = 180.0,
+        )
+        val rv = notif.bigContentView ?: notif.contentView
+            ?: error("notification has no custom content view")
+        val mounted = rv.apply(context, FrameLayout(context))
+        return mounted.findViewById<TextView>(R.id.tv_delta).text.toString()
+    }
+
+    @Test
+    fun `since-text shows 0m for a fresh reading`() {
+        val now = System.currentTimeMillis()
+        val text = renderedDeltaText(reading(ts = now))
+        assertTrue("expected '0m' in '$text'", text.contains("0m"))
+    }
+
+    @Test
+    fun `since-text shows 5m for a five-minute-old reading`() {
+        val now = System.currentTimeMillis()
+        val text = renderedDeltaText(reading(ts = now - 5L * MS_PER_MINUTE))
+        assertTrue("expected '5m' in '$text'", text.contains("5m"))
+    }
+
+    @Test
+    fun `since-text shows 9m for a nine-minute-old reading`() {
+        val now = System.currentTimeMillis()
+        val text = renderedDeltaText(reading(ts = now - 9L * MS_PER_MINUTE))
+        assertTrue("expected '9m' in '$text'", text.contains("9m"))
+    }
+
+    private fun reading(ts: Long): GlucoseReading =
+        GlucoseReading(ts = ts, sgv = 100, direction = "Flat", delta = 0.0)
+
+    private companion object {
+        const val MS_PER_MINUTE = 60_000L
+    }
+}