The Library stays fast with thousands of books

app/src/androidTest/java/com/ninelivesaudio/app/data/local/RecentlyPlayedQueryInstrumentedTest.kt

@@ -0,0 +1,102 @@
+package com.ninelivesaudio.app.data.local
+
+import androidx.room.Room
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.ninelivesaudio.app.data.local.entity.AudioBookEntity
+import com.ninelivesaudio.app.data.local.entity.PlaybackProgressEntity
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * The recently played queries now start from PlaybackProgress and walk its
+ * UpdatedAt index. They must return the same rows as the old library-first
+ * join, which is kept here as the reference.
+ */
+@RunWith(AndroidJUnit4::class)
+class RecentlyPlayedQueryInstrumentedTest {
+
+    private lateinit var database: AppDatabase
+
+    @Before
+    fun setUp() {
+        database = Room.inMemoryDatabaseBuilder(
+            InstrumentationRegistry.getInstrumentation().targetContext,
+            AppDatabase::class.java,
+        ).allowMainThreadQueries().build()
+    }
+
+    @After
+    fun tearDown() {
+        database.close()
+    }
+
+    @Test
+    fun recentQueriesReturnTheSameRowsAsTheLibraryFirstJoin() = runBlocking {
+        seed()
+        val dao = database.audioBookDao()
+
+        assertEquals(reference("lib", isLocal = null, limit = 9), dao.getRecentlyPlayedByLibrary("lib", 9).map { it.audioBook.id })
+        assertEquals(reference("lib", isLocal = null, limit = 9), dao.observeRecentlyPlayedByLibrary("lib", 9).first().map { it.audioBook.id })
+        assertEquals(reference("lib", isLocal = 0, limit = 20), dao.getRecentlyPlayedByLibraryAndSource("lib", 0, 20).map { it.audioBook.id })
+        assertEquals(reference(null, isLocal = null, limit = 9), dao.getRecentlyPlayed(9).map { it.audioBook.id })
+        assertEquals(reference(null, isLocal = null, limit = 9), dao.observeRecentlyPlayed(9).first().map { it.audioBook.id })
+        assertEquals(
+            reference("lib", isLocal = 0, limit = 10_000).size,
+            dao.countRecentlyPlayedByLibrary("lib", 0),
+        )
+        assertEquals(
+            "2026-01-30T00:00:00Z",
+            dao.getRecentlyPlayedByLibrary("lib", 1).single().lastPlayedAt,
+        )
+    }
+
+    @Test
+    fun theUpdatedAtIndexExists() {
+        val cursor = database.openHelper.readableDatabase.query("PRAGMA index_list(`PlaybackProgress`)")
+        val names = mutableListOf<String>()
+        cursor.use { while (it.moveToNext()) names += it.getString(it.getColumnIndexOrThrow("name")) }
+        assertTrue(names.toString(), "idx_playback_progress_updated" in names)
+    }
+
+    private suspend fun seed() {
+        val books = (0 until 30).map { index ->
+            AudioBookEntity(
+                id = "book-$index",
+                libraryId = if (index % 5 == 0) "other" else "lib",
+                isLocal = if (index % 7 == 0) 1 else 0,
+                title = "Title $index",
+                archivedAt = if (index % 11 == 0) 1L else null,
+            )
+        }
+        database.audioBookDao().upsertAll(books)
+        val progress = (0 until 30).filter { it % 3 != 1 }.map { index ->
+            PlaybackProgressEntity(
+                audioBookId = "book-$index",
+                positionSeconds = 1.0,
+                updatedAt = "2026-01-%02dT00:00:00Z".format(index + 1),
+            )
+        } + PlaybackProgressEntity(audioBookId = "deleted-book", updatedAt = "2027-01-01T00:00:00Z")
+        progress.forEach { database.playbackProgressDao().upsert(it) }
+    }
+
+    /** The pre-change query shape, run raw: AudioBooks first, then PlaybackProgress. */
+    private fun reference(libraryId: String?, isLocal: Int?, limit: Int): List<String> {
+        val where = buildList {
+            add("ab.ArchivedAt IS NULL")
+            if (libraryId != null) add("ab.LibraryId = '$libraryId'")
+            if (isLocal != null) add("ab.IsLocal = $isLocal")
+        }.joinToString(" AND ")
+        val sql = "SELECT ab.Id FROM AudioBooks ab INNER JOIN PlaybackProgress pp ON ab.Id = pp.AudioBookId " +
+            "WHERE $where ORDER BY pp.UpdatedAt DESC LIMIT $limit"
+        val ids = mutableListOf<String>()
+        database.openHelper.readableDatabase.query(sql).use { while (it.moveToNext()) ids += it.getString(0) }
+        return ids
+    }
+}

app/src/androidTest/java/com/ninelivesaudio/app/data/local/ShelfProjectionInstrumentedTest.kt

@@ -0,0 +1,133 @@
+package com.ninelivesaudio.app.data.local
+
+import androidx.room.Room
+import androidx.sqlite.db.SimpleSQLiteQuery
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.ninelivesaudio.app.data.local.converter.toDomain
+import com.ninelivesaudio.app.data.local.entity.AudioBookEntity
+import com.ninelivesaudio.app.data.local.entity.PlaybackProgressEntity
+import com.ninelivesaudio.app.data.local.entity.toShelfBook
+import com.ninelivesaudio.app.data.repository.buildLibrarySql
+import com.ninelivesaudio.app.data.repository.buildLibrarySqlArgs
+import com.ninelivesaudio.app.domain.model.AudioBook
+import com.ninelivesaudio.app.domain.util.toEpochMillis
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * The light shelf query returns the same books, with the same shelf fields,
+ * as the former `ab.*` read, on a real Room database.
+ */
+@RunWith(AndroidJUnit4::class)
+class ShelfProjectionInstrumentedTest {
+
+    private lateinit var database: AppDatabase
+
+    @Before
+    fun setUp() {
+        database = Room.inMemoryDatabaseBuilder(
+            InstrumentationRegistry.getInstrumentation().targetContext,
+            AppDatabase::class.java,
+        ).allowMainThreadQueries().build()
+    }
+
+    @After
+    fun tearDown() {
+        database.close()
+    }
+
+    @Test
+    fun shelfRowsMatchTheFullRowsMinusTheHeavyFields() = runBlocking {
+        val dao = database.audioBookDao()
+        dao.upsertAll(
+            listOf(
+                book("b", "Beta", chaptersJson = """[{"Id":1,"Start":0.0,"End":60.0,"Title":"One"}]"""),
+                book("a", "alpha", genresJson = """["Horror"]"""),
+                book("c", "Gamma", archivedAt = 1L),
+                book("d", "Delta", libraryId = "other"),
+            )
+        )
+        database.playbackProgressDao().upsert(
+            PlaybackProgressEntity(audioBookId = "b", positionSeconds = 30.0, updatedAt = "2026-09-20T08:30:00Z")
+        )
+
+        val former: Map<String, AudioBook> = dao.getByLibraryWithLastPlayed(LIBRARY)
+            .filter { it.audioBook.archivedAt == null }
+            .associate { result ->
+                result.audioBook.id to result.audioBook.toDomain().copy(
+                    lastPlayedAt = result.lastPlayedAt?.toEpochMillis(),
+                    description = null,
+                    audioFiles = emptyList(),
+                    tags = emptyList(),
+                )
+            }
+        val shelf = dao.getFilteredBooks(
+            SimpleSQLiteQuery(
+                buildLibrarySql(tab = 0, hideFinished = false, downloadedOnly = false, hasSearch = false),
+                arrayOf(LIBRARY),
+            )
+        ).map { it.toShelfBook() }
+
+        assertEquals(former, shelf.associateBy { it.id })
+        assertEquals(setOf("a", "b"), shelf.map { it.id }.toSet())
+        assertEquals(1, shelf.single { it.id == "b" }.chapters.size)
+    }
+
+    @Test
+    fun percentAndUnderscoreMatchOnlyThemselves() = runBlocking {
+        val dao = database.audioBookDao()
+        dao.upsertAll(
+            listOf(
+                book("pct", "100% Pure"),
+                book("num", "100 Days"),
+                book("under", "a_b"),
+                book("any", "axb"),
+            )
+        )
+
+        suspend fun shelfSearch(query: String) = dao.getFilteredBooks(
+            SimpleSQLiteQuery(
+                buildLibrarySql(tab = 0, hideFinished = false, downloadedOnly = false, hasSearch = true),
+                buildLibrarySqlArgs(LIBRARY, query),
+            )
+        ).map { it.id }.toSet()
+
+        assertEquals(setOf("pct"), shelfSearch("%"))
+        assertEquals(setOf("under"), shelfSearch("_"))
+        assertEquals(setOf("pct", "num"), shelfSearch("100"))
+    }
+
+    private fun book(
+        id: String,
+        title: String,
+        libraryId: String = LIBRARY,
+        archivedAt: Long? = null,
+        genresJson: String = "[]",
+        chaptersJson: String = "[]",
+    ) = AudioBookEntity(
+        id = id,
+        libraryId = libraryId,
+        title = title,
+        author = "Author $id",
+        description = "Long description for $id",
+        durationSeconds = 120.0,
+        addedAt = "2026-09-01T12:00:00Z",
+        audioFilesJson = """[{"Id":"f-$id","Ino":"1","Index":1,"Duration":120.0,"Filename":"$id.mp3"}]""",
+        progress = 0.25,
+        archivedAt = archivedAt,
+        seriesName = "Series",
+        seriesSequence = "1",
+        genresJson = genresJson,
+        tagsJson = """["tag"]""",
+        chaptersJson = chaptersJson,
+    )
+
+    private companion object {
+        const val LIBRARY = "lib"
+    }
+}

app/src/androidTest/java/com/ninelivesaudio/app/service/AutoBrowseQueryInstrumentedTest.kt

@@ -0,0 +1,147 @@
+package com.ninelivesaudio.app.service
+
+import androidx.room.Room
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.ninelivesaudio.app.data.local.AppDatabase
+import com.ninelivesaudio.app.data.local.converter.toDomain
+import com.ninelivesaudio.app.data.local.entity.AudioBookEntity
+import com.ninelivesaudio.app.domain.model.AppMode
+import com.ninelivesaudio.app.domain.model.AppSettings
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Android Auto's SQL pages return what the old load, sort and drop/take did. */
+@RunWith(AndroidJUnit4::class)
+class AutoBrowseQueryInstrumentedTest {
+
+    private lateinit var database: AppDatabase
+
+    private val settings = AppSettings(appMode = AppMode.AUDIOBOOKSHELF, selectedLibraryId = LIBRARY)
+
+    @Before
+    fun setUp() {
+        database = Room.inMemoryDatabaseBuilder(
+            InstrumentationRegistry.getInstrumentation().targetContext,
+            AppDatabase::class.java,
+        ).allowMainThreadQueries().build()
+    }
+
+    @After
+    fun tearDown() {
+        database.close()
+    }
+
+    @Test
+    fun libraryPagesMatchTheFormerInMemoryPaging() = runBlocking {
+        seed()
+        val dao = database.audioBookDao()
+        val former = browseBooksForAuto(dao.getAll().map { it.toDomain() }, settings)
+            .sortedBy { it.title.lowercase() }
+
+        for (page in 0..3) {
+            val expected = former.drop(page * PAGE).take(PAGE).map { it.id }
+            val actual = dao.getAutoBrowsePage(LIBRARY, isLocal = 0, limit = PAGE, offset = page * PAGE).map { it.id }
+            assertEquals("page $page", expected, actual)
+        }
+    }
+
+    @Test
+    fun downloadedPagesMatchTheFormerInMemoryPaging() = runBlocking {
+        seed()
+        val dao = database.audioBookDao()
+        val former = browseBooksForAuto(dao.getAll().map { it.toDomain() }, settings)
+            .filter { it.isDownloaded }
+            .sortedBy { it.title.lowercase() }
+
+        for (page in 0..3) {
+            val expected = former.drop(page * PAGE).take(PAGE).map { it.id }
+            val actual = dao.getAutoDownloadedPage(LIBRARY, isLocal = 0, limit = PAGE, offset = page * PAGE).map { it.id }
+            assertEquals("page $page", expected, actual)
+        }
+    }
+
+    @Test
+    fun equalTitlesNeverRepeatOrSkipAcrossPages() = runBlocking {
+        val dao = database.audioBookDao()
+        dao.upsertAll((0 until 9).map { book(id = "same-$it", title = "Same Title") })
+
+        val paged = (0..2).flatMap { page ->
+            dao.getAutoBrowsePage(LIBRARY, isLocal = 0, limit = 3, offset = page * 3).map { it.id }
+        }
+
+        assertEquals((0 until 9).map { "same-$it" }, paged)
+    }
+
+    @Test
+    fun searchStaysInScopeMatchesWildcardsLiterallyAndCounts() = runBlocking {
+        val dao = database.audioBookDao()
+        dao.upsertAll(
+            listOf(
+                book(id = "pct", title = "100% Wolf"),
+                book(id = "plain", title = "100 Wolves"),
+                book(id = "under", title = "a_b"),
+                book(id = "underless", title = "axb"),
+                book(id = "by-author", title = "Other").copy(author = "Wolfgang"),
+                book(id = "archived", title = "Wolf Archived", archivedAt = 1L),
+                book(id = "other-library", title = "Wolf Elsewhere", libraryId = "other"),
+                book(id = "local", title = "Wolf Local", isLocal = 1),
+            ),
+        )
+
+        fun ids(rows: List<com.ninelivesaudio.app.data.local.entity.AutoBrowseRow>) = rows.map { it.id }
+
+        assertEquals(listOf("pct"), ids(dao.searchAutoPage(LIBRARY, 0, autoSearchPattern("100%")!!, 100, 0)))
+        assertEquals(listOf("under"), ids(dao.searchAutoPage(LIBRARY, 0, autoSearchPattern("a_b")!!, 100, 0)))
+        assertEquals(
+            listOf("pct", "by-author"),
+            ids(dao.searchAutoPage(LIBRARY, 0, autoSearchPattern("wolf")!!, 100, 0)),
+        )
+        assertEquals(2, dao.countAutoSearch(LIBRARY, 0, autoSearchPattern("wolf")!!, 100))
+        assertEquals(1, dao.countAutoSearch(LIBRARY, 0, autoSearchPattern("wolf")!!, 1))
+    }
+
+    private suspend fun seed() {
+        // Mixed case and distinct titles, so NOCASE and lowercase() agree on order.
+        val titles = (0 until 40).map { index ->
+            val word = "Title %02d".format((index * 17) % 40)
+            if (index % 2 == 0) word.uppercase() else word.lowercase()
+        }
+        val books = titles.mapIndexed { index, title ->
+            book(id = "book-$index", title = title, isDownloaded = if (index % 3 == 0) 1 else 0)
+        } + listOf(
+            book(id = "archived", title = "A Archived", archivedAt = 1L, isDownloaded = 1),
+            book(id = "other-library", title = "A Other", libraryId = "other", isDownloaded = 1),
+            book(id = "local", title = "A Local", isLocal = 1, isDownloaded = 1),
+        )
+        database.audioBookDao().upsertAll(books)
+    }
+
+    private fun book(
+        id: String,
+        title: String,
+        libraryId: String = LIBRARY,
+        isLocal: Int = 0,
+        isDownloaded: Int = 0,
+        archivedAt: Long? = null,
+    ) = AudioBookEntity(
+        id = id,
+        libraryId = libraryId,
+        isLocal = isLocal,
+        title = title,
+        author = "Author",
+        description = "A long description that the light rows never read.",
+        isDownloaded = isDownloaded,
+        archivedAt = archivedAt,
+        genresJson = "[\"Mystery\"]",
+    )
+
+    private companion object {
+        const val LIBRARY = "lib"
+        const val PAGE = 7
+    }
+}