Split up BackupCreator into smaller classes

(cherry picked from commit 1a559124eb9e029a6146bf2660cbd508941c20d4) # Conflicts: # app/src/main/java/eu/kanade/tachiyomi/data/backup/create/BackupCreator.kt # app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/BackupRestorer.kt
2023-12-24 16:54:22 -05:00 · 2023-12-24 16:54:22 -05:00 · 2238b123f9
commit 2238b123f9
parent 18e63cafa0
13 changed files with 323 additions and 245 deletions
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/BackupCreator.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/BackupCreator.kt
@ -6,60 +6,35 @@ import com.hippo.unifile.UniFile
 import eu.kanade.tachiyomi.data.backup.BackupFileValidator
 import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags.BACKUP_APP_PREFS
 import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags.BACKUP_CATEGORY
-import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags.BACKUP_CHAPTER
 import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags.BACKUP_CUSTOM_INFO
-import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags.BACKUP_HISTORY
 import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags.BACKUP_READ_MANGA
 import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags.BACKUP_SOURCE_PREFS
-import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags.BACKUP_TRACK
+import eu.kanade.tachiyomi.data.backup.create.creators.CategoriesBackupCreator
+import eu.kanade.tachiyomi.data.backup.create.creators.MangaBackupCreator
+import eu.kanade.tachiyomi.data.backup.create.creators.PreferenceBackupCreator
+import eu.kanade.tachiyomi.data.backup.create.creators.SavedSearchBackupCreator
+import eu.kanade.tachiyomi.data.backup.create.creators.SourcesBackupCreator
 import eu.kanade.tachiyomi.data.backup.models.Backup
 import eu.kanade.tachiyomi.data.backup.models.BackupCategory
-import eu.kanade.tachiyomi.data.backup.models.BackupChapter
-import eu.kanade.tachiyomi.data.backup.models.BackupFlatMetadata
-import eu.kanade.tachiyomi.data.backup.models.BackupHistory
 import eu.kanade.tachiyomi.data.backup.models.BackupManga
 import eu.kanade.tachiyomi.data.backup.models.BackupPreference
 import eu.kanade.tachiyomi.data.backup.models.BackupSavedSearch
 import eu.kanade.tachiyomi.data.backup.models.BackupSerializer
 import eu.kanade.tachiyomi.data.backup.models.BackupSource
 import eu.kanade.tachiyomi.data.backup.models.BackupSourcePreferences
-import eu.kanade.tachiyomi.data.backup.models.BooleanPreferenceValue
-import eu.kanade.tachiyomi.data.backup.models.FloatPreferenceValue
-import eu.kanade.tachiyomi.data.backup.models.IntPreferenceValue
-import eu.kanade.tachiyomi.data.backup.models.LongPreferenceValue
-import eu.kanade.tachiyomi.data.backup.models.StringPreferenceValue
-import eu.kanade.tachiyomi.data.backup.models.StringSetPreferenceValue
-import eu.kanade.tachiyomi.data.backup.models.backupCategoryMapper
-import eu.kanade.tachiyomi.data.backup.models.backupChapterMapper
-import eu.kanade.tachiyomi.data.backup.models.backupMergedMangaReferenceMapper
-import eu.kanade.tachiyomi.data.backup.models.backupSavedSearchMapper
-import eu.kanade.tachiyomi.data.backup.models.backupTrackMapper
-import eu.kanade.tachiyomi.source.ConfigurableSource
-import eu.kanade.tachiyomi.source.online.MetadataSource
-import eu.kanade.tachiyomi.source.preferenceKey
-import eu.kanade.tachiyomi.source.sourcePreferences
-import exh.source.MERGED_SOURCE_ID
-import exh.source.getMainSource
 import kotlinx.serialization.protobuf.ProtoBuf
 import logcat.LogPriority
 import okio.buffer
 import okio.gzip
 import okio.sink
 import tachiyomi.core.i18n.stringResource
-import tachiyomi.core.preference.Preference
-import tachiyomi.core.preference.PreferenceStore
 import tachiyomi.core.util.system.logcat
 import tachiyomi.data.DatabaseHandler
 import tachiyomi.data.manga.MangaMapper
-import tachiyomi.domain.category.interactor.GetCategories
-import tachiyomi.domain.category.model.Category
-import tachiyomi.domain.history.interactor.GetHistory
-import tachiyomi.domain.manga.interactor.GetCustomMangaInfo
 import tachiyomi.domain.manga.interactor.GetFavorites
 import tachiyomi.domain.manga.interactor.GetFlatMetadataById
 import tachiyomi.domain.manga.interactor.GetMergedManga
 import tachiyomi.domain.manga.model.Manga
-import tachiyomi.domain.source.service.SourceManager
 import tachiyomi.i18n.MR
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
@ -67,20 +42,19 @@ import java.io.FileOutputStream

 class BackupCreator(
    private val context: Context,
-) {
-
-    private val handler: DatabaseHandler = Injekt.get()
-    private val sourceManager: SourceManager = Injekt.get()
-    private val getCategories: GetCategories = Injekt.get()
-    private val getFavorites: GetFavorites = Injekt.get()
-    private val getHistory: GetHistory = Injekt.get()
-    private val preferenceStore: PreferenceStore = Injekt.get()
-
+    private val categoriesBackupCreator: CategoriesBackupCreator = CategoriesBackupCreator(),
+    private val mangaBackupCreator: MangaBackupCreator = MangaBackupCreator(),
+    private val preferenceBackupCreator: PreferenceBackupCreator = PreferenceBackupCreator(),
+    private val sourcesBackupCreator: SourcesBackupCreator = SourcesBackupCreator(),
    // SY -->
-    private val getMergedManga: GetMergedManga = Injekt.get()
-    private val getCustomMangaInfo: GetCustomMangaInfo = Injekt.get()
-    private val getFlatMetadataById: GetFlatMetadataById = Injekt.get()
+    private val savedSearchBackupCreator: SavedSearchBackupCreator = SavedSearchBackupCreator(),
    // SY <--
+    private val getFavorites: GetFavorites = Injekt.get(),
+    // SY -->
+    private val getMergedManga: GetMergedManga = Injekt.get(),
+    private val handler: DatabaseHandler = Injekt.get()
+    // SY <--
+) {

    internal val parser = ProtoBuf

@ -91,24 +65,6 @@ class BackupCreator(
     * @param isAutoBackup backup called from scheduled backup job
     */
    suspend fun createBackup(uri: Uri, flags: Int, isAutoBackup: Boolean): String {
-        val databaseManga = getFavorites.await() /* SY --> */ +
-            if (flags and BACKUP_READ_MANGA == BACKUP_READ_MANGA) {
-                handler.awaitList { mangasQueries.getReadMangaNotInLibrary(MangaMapper::mapManga) }
-            } else {
-                emptyList()
-            } + getMergedManga.await() // SY <--
-        val backup = Backup(
-            backupMangas(databaseManga, flags),
-            backupCategories(flags),
-            emptyList(),
-            prepExtensionInfoForSync(databaseManga),
-            backupAppPreferences(flags),
-            backupSourcePreferences(flags),
-            // SY -->
-            backupSavedSearches(),
-            // SY <--
-        )
-
        var file: UniFile? = null
        try {
            file = (
@ -135,6 +91,23 @@ class BackupCreator(
                throw IllegalStateException("Failed to get handle on a backup file")
            }

+            val databaseManga = getFavorites.await() /* SY --> */ +
+            if (flags and BACKUP_READ_MANGA == BACKUP_READ_MANGA) {
+                handler.awaitList { mangasQueries.getReadMangaNotInLibrary(MangaMapper::mapManga) }
+            } else {
+                emptyList()
+            } + getMergedManga.await() // SY <--
+            val backup = Backup(
+                backupManga = backupMangas(databaseManga, flags),
+                backupCategories = backupCategories(flags),
+                backupSources = backupSources(databaseManga),
+                backupPreferences = backupAppPreferences(flags),
+                backupSourcePreferences = backupSourcePreferences(flags),
+                // SY -->
+                backupSavedSearches = backupSavedSearches(),
+                // SY <--
+            )
+
            val byteArray = parser.encodeToByteArray(BackupSerializer, backup)
            if (byteArray.isEmpty()) {
                throw IllegalStateException(context.stringResource(MR.strings.empty_backup_error))
@ -157,169 +130,37 @@ class BackupCreator(
        }
    }

-    private fun prepExtensionInfoForSync(mangas: List<Manga>): List<BackupSource> {
-        return mangas
-            .asSequence()
-            .map(Manga::source)
-            .distinct()
-            .map(sourceManager::getOrStub)
-            .map(BackupSource::copyFrom)
-            .toList()
-    }
-
-    /**
-     * Backup the categories of library
-     *
-     * @return list of [BackupCategory] to be backed up
-     */
    private suspend fun backupCategories(options: Int): List<BackupCategory> {
-        // Check if user wants category information in backup
-        return if (options and BACKUP_CATEGORY == BACKUP_CATEGORY) {
-            getCategories.await()
-                .filterNot(Category::isSystemCategory)
-                .map(backupCategoryMapper)
-        } else {
-            emptyList()
-        }
+        if (options and BACKUP_CATEGORY != BACKUP_CATEGORY) return emptyList()
+
+        return categoriesBackupCreator.backupCategories()
    }

    private suspend fun backupMangas(mangas: List<Manga>, flags: Int): List<BackupManga> {
-        return mangas.map {
-            backupManga(it, flags)
-        }
+        return mangaBackupCreator.backupMangas(mangas, flags)
    }

-    // SY -->
-    /**
-     * Backup the saved searches from sources
-     *
-     * @return list of [BackupSavedSearch] to be backed up
-     */
-    private suspend fun backupSavedSearches(): List<BackupSavedSearch> {
-        return handler.awaitList { saved_searchQueries.selectAll(backupSavedSearchMapper) }
-    }
-    // SY <--
-
-    /**
-     * Convert a manga to Json
-     *
-     * @param manga manga that gets converted
-     * @param options options for the backup
-     * @return [BackupManga] containing manga in a serializable form
-     */
-    private suspend fun backupManga(manga: Manga, options: Int): BackupManga {
-        // Entry for this manga
-        val mangaObject = BackupManga.copyFrom(
-            manga,
-            // SY -->
-            if (options and BACKUP_CUSTOM_INFO == BACKUP_CUSTOM_INFO) {
-                getCustomMangaInfo.get(manga.id)
-            } else {
-                null
-            }, /* SY <-- */
-        )
-
-        // SY -->
-        if (manga.source == MERGED_SOURCE_ID) {
-            mangaObject.mergedMangaReferences = handler.awaitList {
-                mergedQueries.selectByMergeId(manga.id, backupMergedMangaReferenceMapper)
-            }
-        }
-
-        val source = sourceManager.get(manga.source)?.getMainSource<MetadataSource<*, *>>()
-        if (source != null) {
-            getFlatMetadataById.await(manga.id)?.let { flatMetadata ->
-                mangaObject.flatMetadata = BackupFlatMetadata.copyFrom(flatMetadata)
-            }
-        }
-        // SY <--
-
-        // Check if user wants chapter information in backup
-        if (options and BACKUP_CHAPTER == BACKUP_CHAPTER) {
-            // Backup all the chapters
-            handler.awaitList {
-                chaptersQueries.getChaptersByMangaId(
-                    mangaId = manga.id,
-                    applyScanlatorFilter = 0, // false
-                    mapper = backupChapterMapper,
-                )
-            }
-                .takeUnless(List<BackupChapter>::isEmpty)
-                ?.let { mangaObject.chapters = it }
-        }
-
-        // Check if user wants category information in backup
-        if (options and BACKUP_CATEGORY == BACKUP_CATEGORY) {
-            // Backup categories for this manga
-            val categoriesForManga = getCategories.await(manga.id)
-            if (categoriesForManga.isNotEmpty()) {
-                mangaObject.categories = categoriesForManga.map { it.order }
-            }
-        }
-
-        // Check if user wants track information in backup
-        if (options and BACKUP_TRACK == BACKUP_TRACK) {
-            val tracks = handler.awaitList { manga_syncQueries.getTracksByMangaId(manga.id, backupTrackMapper) }
-            if (tracks.isNotEmpty()) {
-                mangaObject.tracking = tracks
-            }
-        }
-
-        // Check if user wants history information in backup
-        if (options and BACKUP_HISTORY == BACKUP_HISTORY) {
-            val historyByMangaId = getHistory.await(manga.id)
-            if (historyByMangaId.isNotEmpty()) {
-                val history = historyByMangaId.map { history ->
-                    val chapter = handler.awaitOne { chaptersQueries.getChapterById(history.chapterId) }
-                    BackupHistory(chapter.url, history.readAt?.time ?: 0L, history.readDuration)
-                }
-                if (history.isNotEmpty()) {
-                    mangaObject.history = history
-                }
-            }
-        }
-
-        return mangaObject
+    private fun backupSources(mangas: List<Manga>): List<BackupSource> {
+        return sourcesBackupCreator.backupSources(mangas)
    }

    private fun backupAppPreferences(flags: Int): List<BackupPreference> {
        if (flags and BACKUP_APP_PREFS != BACKUP_APP_PREFS) return emptyList()

-        return preferenceStore.getAll().toBackupPreferences()
+        return preferenceBackupCreator.backupAppPreferences()
    }

    private fun backupSourcePreferences(flags: Int): List<BackupSourcePreferences> {
        if (flags and BACKUP_SOURCE_PREFS != BACKUP_SOURCE_PREFS) return emptyList()

-        return sourceManager.getCatalogueSources()
-            .filterIsInstance<ConfigurableSource>()
-            .map {
-                BackupSourcePreferences(
-                    it.preferenceKey(),
-                    it.sourcePreferences().all.toBackupPreferences(),
-                )
-            }
+        return preferenceBackupCreator.backupSourcePreferences()
    }

-    @Suppress("UNCHECKED_CAST")
-    private fun Map<String, *>.toBackupPreferences(): List<BackupPreference> {
-        return this.filterKeys {
-            !Preference.isPrivate(it) && !Preference.isAppState(it)
-        }
-            .mapNotNull { (key, value) ->
-                when (value) {
-                    is Int -> BackupPreference(key, IntPreferenceValue(value))
-                    is Long -> BackupPreference(key, LongPreferenceValue(value))
-                    is Float -> BackupPreference(key, FloatPreferenceValue(value))
-                    is String -> BackupPreference(key, StringPreferenceValue(value))
-                    is Boolean -> BackupPreference(key, BooleanPreferenceValue(value))
-                    is Set<*> -> (value as? Set<String>)?.let {
-                        BackupPreference(key, StringSetPreferenceValue(it))
-                    }
-                    else -> null
-                }
-            }
+    // SY -->
+    private suspend fun backupSavedSearches(): List<BackupSavedSearch> {
+        return savedSearchBackupCreator.backupSavedSearches()
    }
+    // SY <--
 }

 private val MAX_AUTO_BACKUPS: Int = 4
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/CategoriesBackupCreator.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/CategoriesBackupCreator.kt
@ -0,0 +1,19 @@
+package eu.kanade.tachiyomi.data.backup.create.creators
+
+import eu.kanade.tachiyomi.data.backup.models.BackupCategory
+import eu.kanade.tachiyomi.data.backup.models.backupCategoryMapper
+import tachiyomi.domain.category.interactor.GetCategories
+import tachiyomi.domain.category.model.Category
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class CategoriesBackupCreator(
+    private val getCategories: GetCategories = Injekt.get(),
+) {
+
+    suspend fun backupCategories(): List<BackupCategory> {
+        return getCategories.await()
+            .filterNot(Category::isSystemCategory)
+            .map(backupCategoryMapper)
+    }
+}
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/MangaBackupCreator.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/MangaBackupCreator.kt
@ -0,0 +1,116 @@
+package eu.kanade.tachiyomi.data.backup.create.creators
+
+import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags
+import eu.kanade.tachiyomi.data.backup.create.BackupCreateFlags.BACKUP_CUSTOM_INFO
+import eu.kanade.tachiyomi.data.backup.models.BackupChapter
+import eu.kanade.tachiyomi.data.backup.models.BackupFlatMetadata
+import eu.kanade.tachiyomi.data.backup.models.BackupHistory
+import eu.kanade.tachiyomi.data.backup.models.BackupManga
+import eu.kanade.tachiyomi.data.backup.models.backupChapterMapper
+import eu.kanade.tachiyomi.data.backup.models.backupMergedMangaReferenceMapper
+import eu.kanade.tachiyomi.data.backup.models.backupTrackMapper
+import eu.kanade.tachiyomi.source.online.MetadataSource
+import exh.source.MERGED_SOURCE_ID
+import exh.source.getMainSource
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.category.interactor.GetCategories
+import tachiyomi.domain.history.interactor.GetHistory
+import tachiyomi.domain.manga.interactor.GetCustomMangaInfo
+import tachiyomi.domain.manga.interactor.GetFlatMetadataById
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.source.service.SourceManager
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class MangaBackupCreator(
+    private val handler: DatabaseHandler = Injekt.get(),
+    private val getCategories: GetCategories = Injekt.get(),
+    private val getHistory: GetHistory = Injekt.get(),
+    // SY -->
+    private val sourceManager: SourceManager = Injekt.get(),
+    private val getCustomMangaInfo: GetCustomMangaInfo = Injekt.get(),
+    private val getFlatMetadataById: GetFlatMetadataById = Injekt.get(),
+    // SY <--
+) {
+
+    suspend fun backupMangas(mangas: List<Manga>, flags: Int): List<BackupManga> {
+        return mangas.map {
+            backupManga(it, flags)
+        }
+    }
+
+    private suspend fun backupManga(manga: Manga, options: Int): BackupManga {
+        // Entry for this manga
+        val mangaObject = BackupManga.copyFrom(
+            manga,
+            // SY -->
+            if (options and BACKUP_CUSTOM_INFO == BACKUP_CUSTOM_INFO) {
+                getCustomMangaInfo.get(manga.id)
+            } else {
+                null
+            }, /* SY <-- */
+        )
+
+        // SY -->
+        if (manga.source == MERGED_SOURCE_ID) {
+            mangaObject.mergedMangaReferences = handler.awaitList {
+                mergedQueries.selectByMergeId(manga.id, backupMergedMangaReferenceMapper)
+            }
+        }
+
+        val source = sourceManager.get(manga.source)?.getMainSource<MetadataSource<*, *>>()
+        if (source != null) {
+            getFlatMetadataById.await(manga.id)?.let { flatMetadata ->
+                mangaObject.flatMetadata = BackupFlatMetadata.copyFrom(flatMetadata)
+            }
+        }
+        // SY <--
+
+        // Check if user wants chapter information in backup
+        if (options and BackupCreateFlags.BACKUP_CHAPTER == BackupCreateFlags.BACKUP_CHAPTER) {
+            // Backup all the chapters
+            handler.awaitList {
+                chaptersQueries.getChaptersByMangaId(
+                    mangaId = manga.id,
+                    applyScanlatorFilter = 0, // false
+                    mapper = backupChapterMapper,
+                )
+            }
+                .takeUnless(List<BackupChapter>::isEmpty)
+                ?.let { mangaObject.chapters = it }
+        }
+
+        // Check if user wants category information in backup
+        if (options and BackupCreateFlags.BACKUP_CATEGORY == BackupCreateFlags.BACKUP_CATEGORY) {
+            // Backup categories for this manga
+            val categoriesForManga = getCategories.await(manga.id)
+            if (categoriesForManga.isNotEmpty()) {
+                mangaObject.categories = categoriesForManga.map { it.order }
+            }
+        }
+
+        // Check if user wants track information in backup
+        if (options and BackupCreateFlags.BACKUP_TRACK == BackupCreateFlags.BACKUP_TRACK) {
+            val tracks = handler.awaitList { manga_syncQueries.getTracksByMangaId(manga.id, backupTrackMapper) }
+            if (tracks.isNotEmpty()) {
+                mangaObject.tracking = tracks
+            }
+        }
+
+        // Check if user wants history information in backup
+        if (options and BackupCreateFlags.BACKUP_HISTORY == BackupCreateFlags.BACKUP_HISTORY) {
+            val historyByMangaId = getHistory.await(manga.id)
+            if (historyByMangaId.isNotEmpty()) {
+                val history = historyByMangaId.map { history ->
+                    val chapter = handler.awaitOne { chaptersQueries.getChapterById(history.chapterId) }
+                    BackupHistory(chapter.url, history.readAt?.time ?: 0L, history.readDuration)
+                }
+                if (history.isNotEmpty()) {
+                    mangaObject.history = history
+                }
+            }
+        }
+
+        return mangaObject
+    }
+}
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/PreferenceBackupCreator.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/PreferenceBackupCreator.kt
@ -0,0 +1,59 @@
+package eu.kanade.tachiyomi.data.backup.create.creators
+
+import eu.kanade.tachiyomi.data.backup.models.BackupPreference
+import eu.kanade.tachiyomi.data.backup.models.BackupSourcePreferences
+import eu.kanade.tachiyomi.data.backup.models.BooleanPreferenceValue
+import eu.kanade.tachiyomi.data.backup.models.FloatPreferenceValue
+import eu.kanade.tachiyomi.data.backup.models.IntPreferenceValue
+import eu.kanade.tachiyomi.data.backup.models.LongPreferenceValue
+import eu.kanade.tachiyomi.data.backup.models.StringPreferenceValue
+import eu.kanade.tachiyomi.data.backup.models.StringSetPreferenceValue
+import eu.kanade.tachiyomi.source.ConfigurableSource
+import eu.kanade.tachiyomi.source.preferenceKey
+import eu.kanade.tachiyomi.source.sourcePreferences
+import tachiyomi.core.preference.Preference
+import tachiyomi.core.preference.PreferenceStore
+import tachiyomi.domain.source.service.SourceManager
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class PreferenceBackupCreator(
+    private val sourceManager: SourceManager = Injekt.get(),
+    private val preferenceStore: PreferenceStore = Injekt.get(),
+) {
+
+    fun backupAppPreferences(): List<BackupPreference> {
+        return preferenceStore.getAll().toBackupPreferences()
+    }
+
+    fun backupSourcePreferences(): List<BackupSourcePreferences> {
+        return sourceManager.getCatalogueSources()
+            .filterIsInstance<ConfigurableSource>()
+            .map {
+                BackupSourcePreferences(
+                    it.preferenceKey(),
+                    it.sourcePreferences().all.toBackupPreferences(),
+                )
+            }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun Map<String, *>.toBackupPreferences(): List<BackupPreference> {
+        return this.filterKeys {
+            !Preference.isPrivate(it) && !Preference.isAppState(it)
+        }
+            .mapNotNull { (key, value) ->
+                when (value) {
+                    is Int -> BackupPreference(key, IntPreferenceValue(value))
+                    is Long -> BackupPreference(key, LongPreferenceValue(value))
+                    is Float -> BackupPreference(key, FloatPreferenceValue(value))
+                    is String -> BackupPreference(key, StringPreferenceValue(value))
+                    is Boolean -> BackupPreference(key, BooleanPreferenceValue(value))
+                    is Set<*> -> (value as? Set<String>)?.let {
+                        BackupPreference(key, StringSetPreferenceValue(it))
+                    }
+                    else -> null
+                }
+            }
+    }
+}
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/SavedSearchBackupCreator.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/SavedSearchBackupCreator.kt
@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.data.backup.create.creators
+
+import eu.kanade.tachiyomi.data.backup.models.BackupSavedSearch
+import eu.kanade.tachiyomi.data.backup.models.backupSavedSearchMapper
+import tachiyomi.data.DatabaseHandler
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class SavedSearchBackupCreator(
+    private val handler: DatabaseHandler = Injekt.get()
+) {
+
+    suspend fun backupSavedSearches(): List<BackupSavedSearch> {
+        return handler.awaitList { saved_searchQueries.selectAll(backupSavedSearchMapper) }
+    }
+}
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/SourcesBackupCreator.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators/SourcesBackupCreator.kt
@ -0,0 +1,22 @@
+package eu.kanade.tachiyomi.data.backup.create.creators
+
+import eu.kanade.tachiyomi.data.backup.models.BackupSource
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.source.service.SourceManager
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class SourcesBackupCreator(
+    private val sourceManager: SourceManager = Injekt.get(),
+) {
+
+    fun backupSources(mangas: List<Manga>): List<BackupSource> {
+        return mangas
+            .asSequence()
+            .map(Manga::source)
+            .distinct()
+            .map(sourceManager::getOrStub)
+            .map(BackupSource::copyFrom)
+            .toList()
+    }
+}
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/models/BackupSource.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/models/BackupSource.kt
@ -4,14 +4,6 @@ import eu.kanade.tachiyomi.source.Source
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.protobuf.ProtoNumber

-@Serializable
-data class BrokenBackupSource(
-    @ProtoNumber(0) var name: String = "",
-    @ProtoNumber(1) var sourceId: Long,
-) {
-    fun toBackupSource() = BackupSource(name, sourceId)
-}
-
@Serializable
 data class BackupSource(
    @ProtoNumber(1) var name: String = "",
@ -26,3 +18,11 @@ data class BackupSource(
        }
    }
 }
+
+@Serializable
+data class BrokenBackupSource(
+    @ProtoNumber(0) var name: String = "",
+    @ProtoNumber(1) var sourceId: Long,
+) {
+    fun toBackupSource() = BackupSource(name, sourceId)
+}
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/BackupRestorer.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/BackupRestorer.kt
@ -8,6 +8,10 @@ import eu.kanade.tachiyomi.data.backup.models.BackupManga
 import eu.kanade.tachiyomi.data.backup.models.BackupPreference
 import eu.kanade.tachiyomi.data.backup.models.BackupSavedSearch
 import eu.kanade.tachiyomi.data.backup.models.BackupSourcePreferences
+import eu.kanade.tachiyomi.data.backup.restore.restorers.CategoriesRestorer
+import eu.kanade.tachiyomi.data.backup.restore.restorers.MangaRestorer
+import eu.kanade.tachiyomi.data.backup.restore.restorers.PreferenceRestorer
+import eu.kanade.tachiyomi.data.backup.restore.restorers.SavedSearchRestorer
 import eu.kanade.tachiyomi.util.BackupUtil
 import eu.kanade.tachiyomi.util.system.createFileInCacheDir
 import exh.source.MERGED_SOURCE_ID
@ -202,32 +206,3 @@ class BackupRestorer(
        return File("")
    }
 }
-
-data class RestoreOptions(
-    val appSettings: Boolean = true,
-    val sourceSettings: Boolean = true,
-    val library: Boolean = true,
-    // SY -->
-    val savedSearches: Boolean = true,
-    // SY <--
-) {
-    fun toBooleanArray() = booleanArrayOf(
-        appSettings,
-        sourceSettings,
-        library,
-        // SY -->
-        savedSearches,
-        // SY <--
-    )
-
-    companion object {
-        fun fromBooleanArray(booleanArray: BooleanArray) = RestoreOptions(
-            appSettings = booleanArray[0],
-            sourceSettings = booleanArray[1],
-            library = booleanArray[2],
-            // SY -->
-            savedSearches = booleanArray[3],
-            // SY <--
-        )
-    }
-}
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/RestoreOptions.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/RestoreOptions.kt
@ -0,0 +1,30 @@
+package eu.kanade.tachiyomi.data.backup.restore
+
+data class RestoreOptions(
+    val appSettings: Boolean = true,
+    val sourceSettings: Boolean = true,
+    val library: Boolean = true,
+    // SY -->
+    val savedSearches: Boolean = true,
+    // SY <--
+) {
+    fun toBooleanArray() = booleanArrayOf(
+        appSettings,
+        sourceSettings,
+        library,
+        // SY -->
+        savedSearches,
+        // SY <--
+    )
+
+    companion object {
+        fun fromBooleanArray(booleanArray: BooleanArray) = RestoreOptions(
+            appSettings = booleanArray[0],
+            sourceSettings = booleanArray[1],
+            library = booleanArray[2],
+            // SY -->
+            savedSearches = booleanArray[3],
+            // SY <--
+        )
+    }
+}
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers/CategoriesRestorer.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers/CategoriesRestorer.kt
@ -1,4 +1,4 @@
-package eu.kanade.tachiyomi.data.backup.restore
+package eu.kanade.tachiyomi.data.backup.restore.restorers

 import eu.kanade.tachiyomi.data.backup.models.BackupCategory
 import tachiyomi.data.DatabaseHandler
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers/MangaRestorer.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers/MangaRestorer.kt
@ -1,4 +1,4 @@
-package eu.kanade.tachiyomi.data.backup.restore
+package eu.kanade.tachiyomi.data.backup.restore.restorers

 import eu.kanade.domain.manga.interactor.UpdateManga
 import eu.kanade.tachiyomi.data.backup.models.BackupCategory
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers/PreferenceRestorer.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers/PreferenceRestorer.kt
@ -1,4 +1,4 @@
-package eu.kanade.tachiyomi.data.backup.restore
+package eu.kanade.tachiyomi.data.backup.restore.restorers

 import android.content.Context
 import eu.kanade.tachiyomi.data.backup.create.BackupCreateJob
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers/SavedSearchRestorer.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers/SavedSearchRestorer.kt
@ -1,4 +1,4 @@
-package eu.kanade.tachiyomi.data.backup.restore
+package eu.kanade.tachiyomi.data.backup.restore.restorers

 import eu.kanade.tachiyomi.data.backup.models.BackupSavedSearch
 import exh.util.nullIfBlank