Address minor build warnings

app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupManager.kt

@@ -70,7 +70,6 @@ class BackupManager(
      * @param uri path of Uri
      * @param isAutoBackup backup called from scheduled backup job
      */
-    @Suppress("BlockingMethodInNonBlockingContext")
     suspend fun createBackup(uri: Uri, flags: Int, isAutoBackup: Boolean): String {
         if (!context.hasPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
             throw IllegalStateException(context.getString(R.string.missing_storage_permission))
@@ -222,10 +221,10 @@ class BackupManager(
     }
 
     internal suspend fun restoreExistingManga(manga: Manga, dbManga: Mangas): Manga {
-        var manga = manga.copy(id = dbManga._id)
+        var updatedManga = manga.copy(id = dbManga._id)
-        manga = manga.copyFrom(dbManga)
+        updatedManga = updatedManga.copyFrom(dbManga)
-        updateManga(manga)
+        updateManga(updatedManga)
-        return manga
+        return updatedManga
     }
 
     /**
@@ -298,7 +297,7 @@ class BackupManager(
                 dbCategories.firstOrNull { dbCategory ->
                     dbCategory.name == backupCategory.name
                 }?.let { dbCategory ->
-                    mangaCategoriesToUpdate.add(Pair(manga.id!!, dbCategory.id))
+                    mangaCategoriesToUpdate.add(Pair(manga.id, dbCategory.id))
                 }
             }
         }
@@ -306,7 +305,7 @@ class BackupManager(
         // Update database
         if (mangaCategoriesToUpdate.isNotEmpty()) {
             handler.await(true) {
-                mangas_categoriesQueries.deleteMangaCategoryByMangaId(manga.id!!)
+                mangas_categoriesQueries.deleteMangaCategoryByMangaId(manga.id)
                 mangaCategoriesToUpdate.forEach { (mangaId, categoryId) ->
                     mangas_categoriesQueries.insert(mangaId, categoryId)
                 }
@@ -370,37 +369,38 @@ class BackupManager(
      * @param tracks the track list to restore.
      */
     internal suspend fun restoreTracking(manga: Manga, tracks: List<tachiyomi.domain.track.model.Track>) {
-        // Fix foreign keys with the current manga id
-        val tracks = tracks.map { it.copy(mangaId = manga.id!!) }
-
         // Get tracks from database
-        val dbTracks = handler.awaitList { manga_syncQueries.getTracksByMangaId(manga.id!!) }
+        val dbTracks = handler.awaitList { manga_syncQueries.getTracksByMangaId(manga.id) }
         val toUpdate = mutableListOf<Manga_sync>()
         val toInsert = mutableListOf<tachiyomi.domain.track.model.Track>()
 
-        tracks.forEach { track ->
+        tracks
-            var isInDatabase = false
+            // Fix foreign keys with the current manga id
-            for (dbTrack in dbTracks) {
+            .map { it.copy(mangaId = manga.id) }
-                if (track.syncId == dbTrack.sync_id) {
+            .forEach { track ->
-                    // The sync is already in the db, only update its fields
+                var isInDatabase = false
-                    var temp = dbTrack
+                for (dbTrack in dbTracks) {
-                    if (track.remoteId != dbTrack.remote_id) {
+                    if (track.syncId == dbTrack.sync_id) {
-                        temp = temp.copy(remote_id = track.remoteId)
+                        // The sync is already in the db, only update its fields
+                        var temp = dbTrack
+                        if (track.remoteId != dbTrack.remote_id) {
+                            temp = temp.copy(remote_id = track.remoteId)
+                        }
+                        if (track.libraryId != dbTrack.library_id) {
+                            temp = temp.copy(library_id = track.libraryId)
+                        }
+                        temp = temp.copy(last_chapter_read = max(dbTrack.last_chapter_read, track.lastChapterRead))
+                        isInDatabase = true
+                        toUpdate.add(temp)
+                        break
                     }
-                    if (track.libraryId != dbTrack.library_id) {
+                }
-                        temp = temp.copy(library_id = track.libraryId)
+                if (!isInDatabase) {
-                    }
+                    // Insert new sync. Let the db assign the id
-                    temp = temp.copy(last_chapter_read = max(dbTrack.last_chapter_read, track.lastChapterRead))
+                    toInsert.add(track.copy(id = 0))
-                    isInDatabase = true
-                    toUpdate.add(temp)
-                    break
                 }
             }
-            if (!isInDatabase) {
+
-                // Insert new sync. Let the db assign the id
-                toInsert.add(track.copy(id = 0))
-            }
-        }
         // Update database
         if (toUpdate.isNotEmpty()) {
             handler.await(true) {
@@ -446,25 +446,25 @@ class BackupManager(
     }
 
     internal suspend fun restoreChapters(manga: Manga, chapters: List<tachiyomi.domain.chapter.model.Chapter>) {
-        val dbChapters = handler.awaitList { chaptersQueries.getChaptersByMangaId(manga.id!!) }
+        val dbChapters = handler.awaitList { chaptersQueries.getChaptersByMangaId(manga.id) }
 
         val processed = chapters.map { chapter ->
-            var chapter = chapter
+            var updatedChapter = chapter
-            val dbChapter = dbChapters.find { it.url == chapter.url }
+            val dbChapter = dbChapters.find { it.url == updatedChapter.url }
             if (dbChapter != null) {
-                chapter = chapter.copy(id = dbChapter._id)
+                updatedChapter = updatedChapter.copy(id = dbChapter._id)
-                chapter = chapter.copyFrom(dbChapter)
+                updatedChapter = updatedChapter.copyFrom(dbChapter)
-                if (dbChapter.read && !chapter.read) {
+                if (dbChapter.read && !updatedChapter.read) {
-                    chapter = chapter.copy(read = dbChapter.read, lastPageRead = dbChapter.last_page_read)
+                    updatedChapter = updatedChapter.copy(read = true, lastPageRead = dbChapter.last_page_read)
-                } else if (chapter.lastPageRead == 0L && dbChapter.last_page_read != 0L) {
+                } else if (updatedChapter.lastPageRead == 0L && dbChapter.last_page_read != 0L) {
-                    chapter = chapter.copy(lastPageRead = dbChapter.last_page_read)
+                    updatedChapter = updatedChapter.copy(lastPageRead = dbChapter.last_page_read)
                 }
-                if (!chapter.bookmark && dbChapter.bookmark) {
+                if (!updatedChapter.bookmark && dbChapter.bookmark) {
-                    chapter = chapter.copy(bookmark = dbChapter.bookmark)
+                    updatedChapter = updatedChapter.copy(bookmark = true)
                 }
             }
 
-            chapter.copy(mangaId = manga.id ?: -1)
+            updatedChapter.copy(mangaId = manga.id)
         }
 
         val newChapters = processed.groupBy { it.id > 0 }
@@ -564,30 +564,6 @@ class BackupManager(
         }
     }
 
-    /**
-     * Updates a list of chapters
-     */
-    private suspend fun updateChapters(chapters: List<tachiyomi.domain.chapter.model.Chapter>) {
-        handler.await(true) {
-            chapters.forEach { chapter ->
-                chaptersQueries.update(
-                    chapter.mangaId,
-                    chapter.url,
-                    chapter.name,
-                    chapter.scanlator,
-                    chapter.read.toLong(),
-                    chapter.bookmark.toLong(),
-                    chapter.lastPageRead,
-                    chapter.chapterNumber.toDouble(),
-                    chapter.sourceOrder,
-                    chapter.dateFetch,
-                    chapter.dateUpload,
-                    chapter.id,
-                )
-            }
-        }
-    }
-
     /**
      * Updates a list of chapters with known database ids
      */

app/src/main/java/eu/kanade/tachiyomi/data/backup/models/BackupTracking.kt

@@ -29,6 +29,7 @@ data class BackupTracking(
     @ProtoNumber(100) var mediaId: Long = 0,
 ) {
 
+    @Suppress("DEPRECATION")
     fun getTrackingImpl(): Track {
         return Track(
             id = -1,

app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaCoverScreenModel.kt

@@ -118,7 +118,6 @@ class MangaCoverScreenModel(
     fun editCover(context: Context, data: Uri) {
         val manga = state.value ?: return
         coroutineScope.launchIO {
-            @Suppress("BlockingMethodInNonBlockingContext")
             context.contentResolver.openInputStream(data)?.use {
                 try {
                     manga.editCover(Injekt.get(), it, updateManga, coverCache)

app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaScreenModel.kt

@@ -605,8 +605,8 @@ class MangaInfoScreenModel(
         }
 
         if (!isFavorited && !successState.hasPromptedToAddBefore) {
-            updateSuccessState { successState ->
+            updateSuccessState { state ->
-                successState.copy(hasPromptedToAddBefore = true)
+                state.copy(hasPromptedToAddBefore = true)
             }
             coroutineScope.launch {
                 val result = snackbarHostState.showSnackbar(