Migrate from KAPT to KSP

app/build.gradle.kts

@@ -6,7 +6,7 @@
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.jetbrains.kotlin.android)
-    alias(libs.plugins.jetbrains.kotlin.kapt)
+    alias(libs.plugins.google.ksp)
     alias(libs.plugins.jetbrains.kotlin.parcelize)
     alias(libs.plugins.sonarqube)
     checkstyle
@@ -40,12 +40,6 @@ android {
         System.getProperty("versionNameSuffix")?.let { versionNameSuffix = it }
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-
-        javaCompileOptions {
-            annotationProcessorOptions {
-                arguments["room.schemaLocation"] = "$projectDir/schemas"
-            }
-        }
     }
 
     buildTypes {
@@ -124,6 +118,11 @@ android {
     }
 }
 
+ksp {
+    arg("room.schemaLocation", "$projectDir/schemas")
+}
+
+
 // Custom dependency configuration for ktlint
 val ktlint by configurations.creating
 
@@ -218,7 +217,7 @@ dependencies {
     implementation(libs.androidx.recyclerview)
     implementation(libs.androidx.room.runtime)
     implementation(libs.androidx.room.rxjava3)
-    kapt(libs.androidx.room.compiler)
+    ksp(libs.androidx.room.compiler)
     implementation(libs.androidx.swiperefreshlayout)
     implementation(libs.androidx.viewpager2)
     implementation(libs.androidx.work.runtime)
@@ -229,7 +228,7 @@ dependencies {
     /** Third-party libraries **/
     implementation(libs.livefront.bridge)
     implementation(libs.evernote.statesaver.core)
-    kapt(libs.evernote.statesaver.compiler)
+    ksp(libs.evernote.statesaver.compiler)
 
     // HTML parser
     implementation(libs.jsoup)
@@ -249,7 +248,7 @@ dependencies {
 
     // Metadata generator for service descriptors
     compileOnly(libs.google.autoservice.annotations)
-    kapt(libs.google.autoservice.compiler)
+    ksp(libs.google.autoservice.compiler)
 
     // Manager for complex RecyclerView layouts
     implementation(libs.lisawray.groupie.core)

app/schemas/org.schabi.newpipe.database.AppDatabase/9.json

@@ -458,7 +458,7 @@
             "notNull": true
           },
           {
-            "fieldPath": "name",
+            "fieldPath": "orderingName",
             "columnName": "name",
             "affinity": "TEXT",
             "notNull": false

app/src/androidTest/java/org/schabi/newpipe/database/DatabaseMigrationTest.kt

@@ -129,7 +129,7 @@ class DatabaseMigrationTest {
         )
 
         val migratedDatabaseV3 = getMigratedDatabase()
-        val listFromDB = migratedDatabaseV3.streamDAO().all.blockingFirst()
+        val listFromDB = migratedDatabaseV3.streamDAO().getAll().blockingFirst()
 
         // Only expect 2, the one with the null url will be ignored
         assertEquals(2, listFromDB.size)
@@ -217,7 +217,7 @@ class DatabaseMigrationTest {
         )
 
         val migratedDatabaseV8 = getMigratedDatabase()
-        val listFromDB = migratedDatabaseV8.searchHistoryDAO().all.blockingFirst()
+        val listFromDB = migratedDatabaseV8.searchHistoryDAO().getAll().blockingFirst()
 
         assertEquals(2, listFromDB.size)
         assertEquals("abc", listFromDB[0].search)
@@ -283,8 +283,8 @@ class DatabaseMigrationTest {
         )
 
         val migratedDatabaseV9 = getMigratedDatabase()
-        var localListFromDB = migratedDatabaseV9.playlistDAO().all.blockingFirst()
-        var remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().all.blockingFirst()
+        var localListFromDB = migratedDatabaseV9.playlistDAO().getAll().blockingFirst()
+        var remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().getAll().blockingFirst()
 
         assertEquals(1, localListFromDB.size)
         assertEquals(localUid2, localListFromDB[0].uid)
@@ -294,17 +294,27 @@ class DatabaseMigrationTest {
         assertEquals(-1, remoteListFromDB[0].displayIndex)
 
         val localUid3 = migratedDatabaseV9.playlistDAO().insert(
-            PlaylistEntity(DEFAULT_NAME + "3", false, -1, -1)
+            PlaylistEntity(
+                name = "${DEFAULT_NAME}3",
+                isThumbnailPermanent = false,
+                thumbnailStreamId = -1,
+                displayIndex = -1
+            )
         )
         val remoteUid3 = migratedDatabaseV9.playlistRemoteDAO().insert(
             PlaylistRemoteEntity(
-                DEFAULT_THIRD_SERVICE_ID, DEFAULT_NAME, DEFAULT_THIRD_URL,
-                DEFAULT_THUMBNAIL, DEFAULT_UPLOADER_NAME, -1, 10
+                serviceId = DEFAULT_THIRD_SERVICE_ID,
+                orderingName = DEFAULT_NAME,
+                url = DEFAULT_THIRD_URL,
+                thumbnailUrl = DEFAULT_THUMBNAIL,
+                uploader = DEFAULT_UPLOADER_NAME,
+                displayIndex = -1,
+                streamCount = 10
             )
         )
 
-        localListFromDB = migratedDatabaseV9.playlistDAO().all.blockingFirst()
-        remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().all.blockingFirst()
+        localListFromDB = migratedDatabaseV9.playlistDAO().getAll().blockingFirst()
+        remoteListFromDB = migratedDatabaseV9.playlistRemoteDAO().getAll().blockingFirst()
         assertEquals(2, localListFromDB.size)
         assertEquals(localUid3, localListFromDB[1].uid)
         assertEquals(-1, localListFromDB[1].displayIndex)

app/src/androidTest/java/org/schabi/newpipe/local/history/HistoryRecordManagerTest.kt

@@ -41,7 +41,7 @@ class HistoryRecordManagerTest {
         // For some reason the Flowable returned by getAll() never completes, so we can't assert
         // that the number of Lists it returns is exactly 1, we can only check if the first List is
         // correct. Why on earth has a Flowable been used instead of a Single for getAll()?!?
-        val entities = database.searchHistoryDAO().all.blockingFirst()
+        val entities = database.searchHistoryDAO().getAll().blockingFirst()
         assertThat(entities).hasSize(1)
         assertThat(entities[0].id).isEqualTo(1)
         assertThat(entities[0].serviceId).isEqualTo(0)
@@ -51,50 +51,50 @@ class HistoryRecordManagerTest {
     @Test
     fun deleteSearchHistory() {
         val entries = listOf(
-            SearchHistoryEntry(time.minusSeconds(1), 0, "A"),
-            SearchHistoryEntry(time.minusSeconds(2), 2, "A"),
-            SearchHistoryEntry(time.minusSeconds(3), 1, "B"),
-            SearchHistoryEntry(time.minusSeconds(4), 0, "B"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 0, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 2, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 1, search = "B"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(4), serviceId = 0, search = "B"),
         )
 
         // make sure all 4 were inserted
         database.searchHistoryDAO().insertAll(entries)
-        assertThat(database.searchHistoryDAO().all.blockingFirst()).hasSameSizeAs(entries)
+        assertThat(database.searchHistoryDAO().getAll().blockingFirst()).hasSameSizeAs(entries)
 
         // try to delete only "A" entries, "B" entries should be untouched
         manager.deleteSearchHistory("A").test().await().assertValue(2)
-        val entities = database.searchHistoryDAO().all.blockingFirst()
+        val entities = database.searchHistoryDAO().getAll().blockingFirst()
         assertThat(entities).hasSize(2)
         assertThat(entities).usingElementComparator { o1, o2 -> if (o1.hasEqualValues(o2)) 0 else 1 }
             .containsExactly(*entries.subList(2, 4).toTypedArray())
 
         // assert that nothing happens if we delete a search query that does exist in the db
         manager.deleteSearchHistory("A").test().await().assertValue(0)
-        val entities2 = database.searchHistoryDAO().all.blockingFirst()
+        val entities2 = database.searchHistoryDAO().getAll().blockingFirst()
         assertThat(entities2).hasSize(2)
         assertThat(entities2).usingElementComparator { o1, o2 -> if (o1.hasEqualValues(o2)) 0 else 1 }
             .containsExactly(*entries.subList(2, 4).toTypedArray())
 
         // delete all remaining entries
         manager.deleteSearchHistory("B").test().await().assertValue(2)
-        assertThat(database.searchHistoryDAO().all.blockingFirst()).isEmpty()
+        assertThat(database.searchHistoryDAO().getAll().blockingFirst()).isEmpty()
     }
 
     @Test
     fun deleteCompleteSearchHistory() {
         val entries = listOf(
-            SearchHistoryEntry(time.minusSeconds(1), 1, "A"),
-            SearchHistoryEntry(time.minusSeconds(2), 2, "B"),
-            SearchHistoryEntry(time.minusSeconds(3), 0, "C"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 1, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 2, search = "B"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 0, search = "C"),
         )
 
         // make sure all 3 were inserted
         database.searchHistoryDAO().insertAll(entries)
-        assertThat(database.searchHistoryDAO().all.blockingFirst()).hasSameSizeAs(entries)
+        assertThat(database.searchHistoryDAO().getAll().blockingFirst()).hasSameSizeAs(entries)
 
         // should remove everything
         manager.deleteCompleteSearchHistory().test().await().assertValue(entries.size)
-        assertThat(database.searchHistoryDAO().all.blockingFirst()).isEmpty()
+        assertThat(database.searchHistoryDAO().getAll().blockingFirst()).isEmpty()
     }
 
     private fun insertShuffledRelatedSearches(relatedSearches: Collection<SearchHistoryEntry>) {
@@ -107,7 +107,7 @@ class HistoryRecordManagerTest {
         // make sure all entries were inserted
         assertEquals(
             relatedSearches.size,
-            database.searchHistoryDAO().all.blockingFirst().size
+            database.searchHistoryDAO().getAll().blockingFirst().size
         )
     }
 
@@ -127,19 +127,18 @@ class HistoryRecordManagerTest {
 
     @Test
     fun getRelatedSearches_emptyQuery_manyDuplicates() {
-        insertShuffledRelatedSearches(
-            listOf(
-                SearchHistoryEntry(time.minusSeconds(9), 3, "A"),
-                SearchHistoryEntry(time.minusSeconds(8), 3, "AB"),
-                SearchHistoryEntry(time.minusSeconds(7), 3, "A"),
-                SearchHistoryEntry(time.minusSeconds(6), 3, "A"),
-                SearchHistoryEntry(time.minusSeconds(5), 3, "BA"),
-                SearchHistoryEntry(time.minusSeconds(4), 3, "A"),
-                SearchHistoryEntry(time.minusSeconds(3), 3, "A"),
-                SearchHistoryEntry(time.minusSeconds(2), 0, "A"),
-                SearchHistoryEntry(time.minusSeconds(1), 2, "AA"),
-            )
+        val relatedSearches = listOf(
+            SearchHistoryEntry(creationDate = time.minusSeconds(9), serviceId = 3, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(8), serviceId = 3, search = "AB"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(7), serviceId = 3, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(6), serviceId = 3, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(5), serviceId = 3, search = "BA"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(4), serviceId = 3, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 3, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 0, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 2, search = "AA"),
         )
+        insertShuffledRelatedSearches(relatedSearches)
 
         val searches = manager.getRelatedSearches("", 9, 3).blockingFirst()
         assertThat(searches).containsExactly("AA", "A", "BA")
@@ -166,13 +165,13 @@ class HistoryRecordManagerTest {
         private val time = OffsetDateTime.of(LocalDateTime.of(2000, 1, 1, 1, 1), ZoneOffset.UTC)
 
         private val RELATED_SEARCHES_ENTRIES = listOf(
-            SearchHistoryEntry(time.minusSeconds(7), 2, "AC"),
-            SearchHistoryEntry(time.minusSeconds(6), 0, "ABC"),
-            SearchHistoryEntry(time.minusSeconds(5), 1, "BA"),
-            SearchHistoryEntry(time.minusSeconds(4), 3, "A"),
-            SearchHistoryEntry(time.minusSeconds(2), 0, "B"),
-            SearchHistoryEntry(time.minusSeconds(3), 2, "AA"),
-            SearchHistoryEntry(time.minusSeconds(1), 1, "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(7), serviceId = 2, search = "AC"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(6), serviceId = 0, search = "ABC"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(5), serviceId = 1, search = "BA"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(4), serviceId = 3, search = "A"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(2), serviceId = 0, search = "B"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(3), serviceId = 2, search = "AA"),
+            SearchHistoryEntry(creationDate = time.minusSeconds(1), serviceId = 1, search = "A"),
         )
     }
 }

app/src/androidTest/java/org/schabi/newpipe/local/playlist/LocalPlaylistManagerTest.kt

@@ -72,6 +72,6 @@ class LocalPlaylistManagerTest {
         val result = manager.createPlaylist("name", listOf(stream, upserted))
 
         result.test().await().assertComplete()
-        database.streamDAO().all.test().awaitCount(1).assertValue(listOf(stream, upserted))
+        database.streamDAO().getAll().test().awaitCount(1).assertValue(listOf(stream, upserted))
     }
 }