fix: declare expiryClearJobs before pauseExpiryFlows in AlertManager (#221)

AlertManager constructor crashed with NullPointerException on cold start
whenever an alert pause was already in prefs. Took StrimmaService down with
it on every reboot, install, or memory-pressure rebind — and ActivityManager
backs off restarts up to 1 hour, effectively killing CGM coverage until the
user re-launches the app.

Root cause: `pauseExpiryFlows`'s initializer calls `scheduleExpiryClear` for
any active pause, and `scheduleExpiryClear` touches `expiryClearJobs` — but
`expiryClearJobs` was declared *after* `pauseExpiryFlows`. Kotlin's top-down
property init meant `expiryClearJobs` was null at the moment of first use.

Fix: move `expiryClearJobs` declaration above `pauseExpiryFlows`, and add a
construction-time regression test (`AlertManagerInitOrderTest`) that
pre-populates an active pause before constructing the manager. The existing
`AlertManagerTest` @before clears prefs *after* construction, which is why
the regression slipped past unit tests.

Introduced in #216 (Pause icon fix + configurable notification action,
2026-05-10). Shipped in 1.3.0-rc.1.

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

Author: psjostrom

app/src/main/java/com/psjostrom/strimma/notification/AlertManager.kt

@@ -553,6 +553,14 @@ class AlertManager @Inject constructor(
     private fun alertCategoryAndLevel(alertId: Int): Pair<AlertCategory, Int>? =
         alertIdToCategoryLevel[alertId]
 
+    // Declared before pauseExpiryFlows because the flow initializer below calls
+    // scheduleExpiryClear for any active pause, and scheduleExpiryClear touches
+    // expiryClearJobs. Kotlin property init runs top-down — flipping the order
+    // crashes AlertManager construction (NPE on a null ConcurrentHashMap) on any
+    // cold start where a pause is already in prefs, taking the foreground service
+    // and CGM coverage down with it.
+    private val expiryClearJobs = ConcurrentHashMap<AlertCategory, Job>()
+
     // One MutableStateFlow per category, keyed by the enum so iteration over
     // AlertCategory.entries can never silently bypass a category. The flow's value
     // is the source of truth for "is this category currently paused" — a delayed
@@ -569,8 +577,6 @@ class AlertManager @Inject constructor(
     val pauseLowExpiryMs: StateFlow<Long?> = pauseExpiryFlows.getValue(AlertCategory.LOW)
     val pauseHighExpiryMs: StateFlow<Long?> = pauseExpiryFlows.getValue(AlertCategory.HIGH)
 
-    private val expiryClearJobs = ConcurrentHashMap<AlertCategory, Job>()
-
     fun pauseAlertCategory(category: AlertCategory, durationMs: Long, level: Int = ALERT_LEVEL_URGENT) {
         pauseAlertCategoryAt(category, System.currentTimeMillis() + durationMs, level)
     }

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

@@ -0,0 +1,68 @@
+package com.psjostrom.strimma.notification
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import com.psjostrom.strimma.createTestDataStore
+import com.psjostrom.strimma.data.SettingsRepository
+import com.psjostrom.strimma.data.workout.WorkoutModeManager
+import com.psjostrom.strimma.testutil.workout.FakeCalendarPoller
+import com.psjostrom.strimma.testutil.workout.MutableClock
+import com.psjostrom.strimma.widget.WidgetSettingsRepository
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import org.junit.After
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Regression test for the AlertManager construction crash that took CGM coverage
+ * down on every cold start when a pause was already in prefs.
+ *
+ * Root cause: pauseExpiryFlows' initializer called scheduleExpiryClear for any
+ * active pause, and scheduleExpiryClear touches expiryClearJobs — but
+ * expiryClearJobs was declared *after* pauseExpiryFlows, so Kotlin's top-down
+ * property init left it null at the moment of use → NPE → StrimmaService.onCreate
+ * fails → ActivityManager backs off restarts up to an hour.
+ *
+ * The default AlertManagerTest @Before constructs the instance with an empty
+ * snooze prefs, which is why the regression never tripped a unit test. This test
+ * pre-populates an active pause *before* construction.
+ */
+@RunWith(RobolectricTestRunner::class)
+class AlertManagerInitOrderTest {
+
+    private val managerScope = CoroutineScope(SupervisorJob() + Dispatchers.Unconfined)
+
+    @After
+    fun tearDown() {
+        managerScope.cancel()
+    }
+
+    @Test
+    fun `construction succeeds when an active pause is already in prefs`() {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        // Write an active pause directly to the snooze prefs that the production
+        // AlertManager reads from in alertPauseExpiryMs (-> pauseExpiryMs).
+        // An hour out, well in the future, so scheduleExpiryClear will treat it
+        // as live and try to register an expiry job.
+        context.getSharedPreferences("strimma_snooze", Context.MODE_PRIVATE)
+            .edit()
+            .putLong("pause_low", System.currentTimeMillis() + 60 * 60 * 1000L)
+            .commit()
+
+        val widgetSettings = WidgetSettingsRepository(context)
+        val settings = SettingsRepository(context, widgetSettings, createTestDataStore())
+        val workoutModeManager = WorkoutModeManager(
+            settings,
+            FakeCalendarPoller(),
+            MutableClock(System.currentTimeMillis()),
+            managerScope,
+        )
+
+        // Will throw NullPointerException with the regressed declaration order.
+        AlertManager(context, settings, workoutModeManager, managerScope)
+    }
+}