fix: CursorWindow crash on large libraries (SQLiteBlobTooBigException) (#961)

getAllOwnedApps loaded all rows in one cursor, which can overflow the
CursorWindow when rows contain large blobs. Try loading all at once;
on SQLiteBlobTooBigException, retry with progressively smaller pages
(50 → 25 → ... → 1). Rethrows if a single row exceeds the window.

Flow reactivity preserved via COUNT(*) observer that triggers a
reload on every table change.

Author: jeremybernstein

app/src/main/java/app/gamenative/db/dao/SteamAppDao.kt

@@ -4,10 +4,27 @@ import androidx.room.Dao
 import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
+import androidx.room.Transaction
 import androidx.room.Update
 import app.gamenative.data.SteamApp
 import app.gamenative.service.SteamService.Companion.INVALID_PKG_ID
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
+
+private const val OWNED_APPS_WHERE =
+    "WHERE app.id != 480 " + // Actively filter out Spacewar
+    "AND app.package_id != :invalidPkgId " +
+    "AND app.type != 0 " +
+    "AND EXISTS (" +
+    "  SELECT 1 FROM steam_license AS license " +
+    "  WHERE license.packageId = app.package_id " +
+    "  AND (license.license_flags & 8 = 0) " + // exclude expired licenses (e.g. free weekends)
+    ") "
+
+private const val PAGE_SIZE = 50
 
 @Dao
 interface SteamAppDao {
@@ -21,21 +38,58 @@ interface SteamAppDao {
     @Update
     suspend fun update(app: SteamApp)
 
+    // observe change count — triggers re-load without pulling all blobs into one CursorWindow
+    @Query(
+        "SELECT COUNT(*) FROM steam_app AS app " + OWNED_APPS_WHERE,
+    )
+    fun _observeOwnedAppCount(
+        invalidPkgId: Int = INVALID_PKG_ID,
+    ): Flow<Int>
+
+    // paged data load — each page fits comfortably in a CursorWindow
     @Query(
-        "SELECT * FROM steam_app AS app " +
-            "WHERE app.id != 480 " + // Actively filter out Spacewar
-            "AND app.package_id != :invalidPkgId " +
-            "AND app.type != 0 " +
-            "AND EXISTS (" +
-            "  SELECT 1 FROM steam_license AS license " +
-            "  WHERE license.packageId = app.package_id " +
-            "  AND (license.license_flags & 8 = 0) " + // exclude expired licenses (e.g. free weekends)
-            ") " +
-            "ORDER BY LOWER(app.name)",
+        "SELECT * FROM steam_app AS app " + OWNED_APPS_WHERE +
+            "ORDER BY LOWER(app.name), app.id LIMIT :limit OFFSET :offset",
     )
+    suspend fun _getOwnedAppsPage(
+        limit: Int,
+        offset: Int,
+        invalidPkgId: Int = INVALID_PKG_ID,
+    ): List<SteamApp>
+
+    @Transaction
+    suspend fun _getAllOwnedAppsPaged(invalidPkgId: Int = INVALID_PKG_ID): List<SteamApp> {
+        val result = mutableListOf<SteamApp>()
+        var offset = 0
+        while (true) {
+            // reset per-offset: try full fetch on first page, PAGE_SIZE thereafter
+            var pageSize = if (offset == 0) Int.MAX_VALUE else PAGE_SIZE
+            while (true) {
+                try {
+                    val page = _getOwnedAppsPage(pageSize, offset, invalidPkgId)
+                    if (page.isEmpty()) return result
+                    result += page
+                    if (pageSize == Int.MAX_VALUE) return result // got everything in one shot
+                    offset += page.size
+                    break
+                } catch (e: android.database.sqlite.SQLiteBlobTooBigException) {
+                    if (pageSize <= 1) throw e // single row exceeds window, can't recover
+                    pageSize = if (pageSize == Int.MAX_VALUE) PAGE_SIZE else (pageSize / 2).coerceAtLeast(1)
+                }
+            }
+        }
+    }
+
+    // emits full list on count changes, loaded in pages to avoid CursorWindow overflow.
+    // property-only updates (name, icon) won't re-emit until the next count change.
+    @OptIn(ExperimentalCoroutinesApi::class)
     fun getAllOwnedApps(
         invalidPkgId: Int = INVALID_PKG_ID,
-    ): Flow<List<SteamApp>>
+    ): Flow<List<SteamApp>> = _observeOwnedAppCount(invalidPkgId)
+        .distinctUntilChanged() // skip reload when count unchanged
+        .flatMapLatest { // cancel stale reloads during rapid PICS inserts
+            flow { emit(_getAllOwnedAppsPaged(invalidPkgId)) }
+        }
 
     @Query("SELECT * FROM steam_app WHERE received_pics = 0 AND package_id != :invalidPkgId AND owner_account_id = :ownerId")
     fun getAllOwnedAppsWithoutPICS(