fix(firmware): seed bundled releases against the active device database

The process-wide seedChecked flag assumed one successful seed meant
every Room database was populated. But the active database switches
per selected device, so the first seed could populate the default DB
and skip the device-specific DB entirely.

Replace seedChecked with a cached decoded snapshot (bundledSnapshot)
that avoids re-reading the asset file, but re-evaluates the apply/skip
decision against the current active database on every collection. When
the device DB switches and is empty, the bundle re-applies.

Also removes temporary diagnostic logging.

Author: jeremiah-k

core/data/src/commonMain/kotlin/org/meshtastic/core/data/repository/FirmwareReleaseRepositoryImpl.kt

@@ -54,10 +54,19 @@ open class FirmwareReleaseRepositoryImpl(
     /** Single-flight guard so concurrent collectors share one network refresh. */
     private val refreshMutex = Mutex()
 
-    /** Guards [seedChecked] so concurrent collectors decode the bundled snapshot at most once per process. */
+    /**
+     * Guards [bundledSnapshot] decode so concurrent collectors decode the bundled JSON at most once per process. The
+     * apply/skip decision itself is re-evaluated every time against the CURRENT active DB — the active Room database
+     * switches per selected device, so a one-shot seed gate would miss a freshly activated DB whose `firmware_release`
+     * rows are empty.
+     */
     private val seedMutex = Mutex()
 
-    @Volatile private var seedChecked = false
+    /** Decoded bundled snapshot cached for the process lifetime; the asset file never changes between launches. */
+    @Volatile private var bundledSnapshot: NetworkFirmwareReleases? = null
+
+    /** Set when the bundled asset is missing or un-decodable, so we don't retry on every collection. */
+    @Volatile private var bundleDecodeFailed = false
 
     override val stableRelease: Flow<FirmwareRelease?> = getLatestFirmware(FirmwareReleaseType.STABLE)
 
@@ -87,34 +96,42 @@ open class FirmwareReleaseRepositoryImpl(
     /**
      * Applies the bundled snapshot per release type whenever it is newer than what is cached for that type — not just
      * when the cache is empty. The bundle is refreshed weekly in CI, so an app update carries fresh data even for users
-     * whose network path to api.meshtastic.org chronically fails. Checked once per process; a cache that is already
-     * newer (from a successful network refresh) is never regressed, and a type the bundle doesn't ship is left
-     * untouched.
+     * whose network path to api.meshtastic.org chronically fails. The decoded snapshot is cached for the process; the
+     * apply/skip decision is re-evaluated every call against the CURRENT active DB, because that DB switches per
+     * selected device and a one-shot seed gate would skip a freshly activated DB whose `firmware_release` rows are
+     * empty. A cache that is already newer (from a successful network refresh) is never regressed, and a type the
+     * bundle doesn't ship is left untouched.
      */
     private suspend fun ensureSeeded() {
-        if (seedChecked) return
+        if (bundleDecodeFailed) return // don't retry the bundled asset on every collection once it has failed
         seedMutex.withLock {
-            if (seedChecked) return
-            safeCatching {
-                val bundled = assetReader.decode<NetworkFirmwareReleases>("firmware_releases.json", json)?.releases
-                if (bundled == null) {
-                    Logger.w { "FirmwareReleaseRepository: no bundled releases available to seed from" }
-                } else {
-                    val toApply =
-                        listOf(
-                            FirmwareReleaseType.STABLE to bundled.stable,
-                            FirmwareReleaseType.ALPHA to bundled.alpha,
-                        )
-                            .filter { (type, releases) -> isBundleNewerFor(type, releases) }
-                            .toMap()
-                    if (toApply.isNotEmpty()) {
-                        Logger.i { "FirmwareReleaseRepository: applying bundled snapshot for ${toApply.keys}" }
-                        localDataSource.replaceFirmwareReleases(toApply)
+            // Decode the bundled JSON once per process; the asset never changes between launches.
+            if (bundledSnapshot == null && !bundleDecodeFailed) {
+                safeCatching { assetReader.decode<NetworkFirmwareReleases>("firmware_releases.json", json) }
+                    .onSuccess { snapshot -> bundledSnapshot = snapshot }
+                    .onFailure { e ->
+                        Logger.w(e) { "FirmwareReleaseRepository: failed to decode bundled JSON" }
+                        bundleDecodeFailed = true
                     }
+                // Decode returning null (asset missing) also stops further retries.
+                if (bundledSnapshot == null && !bundleDecodeFailed) {
+                    Logger.w { "FirmwareReleaseRepository: no bundled releases available to seed from" }
+                    bundleDecodeFailed = true
                 }
             }
-                .onSuccess { seedChecked = true }
-                .onFailure { e -> Logger.w(e) { "FirmwareReleaseRepository: failed to seed cache from bundled JSON" } }
+
+            val bundled = bundledSnapshot?.releases ?: return
+
+            // Re-evaluate against the current active DB on every call — it may have switched devices since the last
+            // seed.
+            val toApply =
+                listOf(FirmwareReleaseType.STABLE to bundled.stable, FirmwareReleaseType.ALPHA to bundled.alpha)
+                    .filter { (type, releases) -> isBundleNewerFor(type, releases) }
+                    .toMap()
+            if (toApply.isNotEmpty()) {
+                Logger.i { "FirmwareReleaseRepository: applying bundled snapshot for ${toApply.keys}" }
+                localDataSource.replaceFirmwareReleases(toApply)
+            }
         }
     }
 

core/data/src/jvmTest/kotlin/org/meshtastic/core/data/repository/FirmwareReleaseRepositoryImplTest.kt

@@ -161,17 +161,40 @@ class FirmwareReleaseRepositoryImplTest {
     }
 
     @Test
-    fun failedBundledSeedIsRetriedOnNextCollection() = runBlocking {
+    fun failedBundledDecodeIsNotRetried() = runBlocking {
+        // A broken bundled asset is a permanent failure — retrying on every collection just burns I/O.
         seed.failuresBeforeSuccess = 1
         seed.bundled = Releases(stable = listOf(release("v2.7.15.567b8ea")))
         api.response = NetworkFirmwareReleases()
 
         val initialEmissions = repository.stableRelease.toList()
-
+        // Subsequent collection must NOT retry the decode (the second call would succeed if it did).
         val emissions = repository.stableRelease.toList()
 
         assertEquals(null, initialEmissions.first())
-        assertEquals("v2.7.15.567b8ea", emissions.first()?.id)
+        assertEquals(null, emissions.first(), "failed bundled decode is permanent; no retry on subsequent collections")
+    }
+
+    @Test
+    fun reSeedsWhenActiveDatabaseSwitches() = runBlocking {
+        // Reproduces the original bug: the active Room DB switches per selected device. A process-wide
+        // seed gate set during the first collection (against the default DB) skipped seeding the newly
+        // activated device DB, leaving the firmware picker empty.
+        seed.bundled = Releases(stable = listOf(release("v2.7.15.567b8ea")))
+        api.response = NetworkFirmwareReleases()
+
+        val firstEmissions = repository.stableRelease.toList()
+        assertEquals("v2.7.15.567b8ea", firstEmissions.first()?.id, "first collection seeds DB-A")
+
+        // The selected device's DB becomes active — it has no firmware_release rows.
+        dbProvider.switchToNewDatabase()
+
+        val secondEmissions = repository.stableRelease.toList()
+        assertEquals(
+            "v2.7.15.567b8ea",
+            secondEmissions.first()?.id,
+            "DB switch re-evaluates the bundled snapshot against the now-empty active DB and re-seeds it",
+        )
     }
 
     @Test

core/testing/src/commonMain/kotlin/org/meshtastic/core/testing/FakeDatabaseProvider.kt

@@ -24,12 +24,23 @@ import org.meshtastic.core.database.getInMemoryDatabaseBuilder
 
 /** A real [DatabaseProvider] that uses an in-memory database for testing. */
 class FakeDatabaseProvider : DatabaseProvider {
-    private val db: MeshtasticDatabase = getInMemoryDatabaseBuilder().build()
+    private var db: MeshtasticDatabase = getInMemoryDatabaseBuilder().build()
     private val _currentDb = MutableStateFlow(db)
     override val currentDb: StateFlow<MeshtasticDatabase> = _currentDb
 
     override suspend fun <T> withDb(block: suspend (MeshtasticDatabase) -> T): T? = block(db)
 
+    /**
+     * Simulates the active-DB switch that happens when the app selects a different device — the new DB has no rows, so
+     * any cache that lived only in the previous DB is gone. Closes the prior DB to free its resources.
+     */
+    fun switchToNewDatabase() {
+        val previous = db
+        db = getInMemoryDatabaseBuilder().build()
+        _currentDb.value = db
+        previous.close()
+    }
+
     fun close() {
         db.close()
     }