Possibly fix extension obsolete bug

Revert "Bump compose version"
This reverts commit 5550ddad4e.
2024-05-05 13:17:29 -04:00 · 2024-05-05 12:58:03 -04:00 · 2024-05-05 12:57:45 -04:00 · 2024-05-05 00:07:41 -04:00 · 2024-05-04 23:39:57 -04:00 · 2024-05-04 23:15:17 -04:00
375 changed files with 10948 additions and 4128 deletions
@@ -36,7 +36,7 @@ jobs:
        uses: gradle/actions/setup-gradle@v3

      - name: Build app
-        run: ./gradlew assembleDevDebug
+        run: ./gradlew detekt assembleDevDebug

      - name: Upload APK
        uses: actions/upload-artifact@v3
@@ -40,10 +40,17 @@ jobs:
          path: app/google-services.json
          contents: ${{ secrets.GOOGLE_SERVICES_TEXT }}
          write-mode: overwrite
+
+      - name: Write client_secrets.json
+        uses: DamianReeves/write-file-action@v1.2
+        with:
+          path: app/src/main/assets/client_secrets.json
+          contents: ${{ secrets.CLIENT_SECRETS_TEXT }}
+          write-mode: overwrite
      # SY -->

      - name: Build app and run unit tests
-        run: ./gradlew assembleStandardRelease testStandardReleaseUnitTest --stacktrace
+        run: ./gradlew detekt assembleStandardRelease testStandardReleaseUnitTest --stacktrace

      - name: Sign APK
        uses: r0adkll/sign-android-release@v1
@@ -18,13 +18,10 @@ jobs:
      - name: Validate Gradle Wrapper
        uses: gradle/wrapper-validation-action@v1

-      - name: TAG - Bump version and push tag
-        uses: anothrNick/github-tag-action@1.67.0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          WITH_V: true
-          RELEASE_BRANCHES: master
-          DEFAULT_BUMP: patch
+      - name: Create Tag
+        run: |
+          git tag "preview-${{ github.run_number }}"
+          git push origin "preview-${{ github.run_number }}"

      - name: PING - Dispatch initiating repository event
        run: |
@@ -40,6 +40,12 @@ jobs:
                "ignoreCase": true,
                "labels": ["Cloudflare protected"],
                "message": "Refer to the **Solving Cloudflare issues** section at https://mihon.app/docs/guides/troubleshooting/#cloudflare. If it doesn't work, migrate to other sources or wait until they lower their protection."
+              },
+              {
+                "type": "both",
+                "regex": "^.*(myanimelist|mal).*$",
+                "ignoreCase": true,
+                "message": "For issues with linking MyAnimeList, please follow these steps:\n1. Update Mihon to version 0.16.4 or newer\n2. Change your default User-Agent (`More → Settings → Advanced → Default user agent string`)\n3. Close and restart Mihon\n4. Attempt to link MyAnimeList again\n\nIf you had MyAnimeList linked before, try to unlink it first before trying these steps."
              }
            ]
          auto-close-ignore-label: do-not-autoclose
@@ -22,3 +22,4 @@ TODO.md
 CHANGELOG.md
 /captures
 build.sh
+/app/src/main/assets/client_secrets.json
@@ -52,3 +52,20 @@ When creating a fork, remember to:
 - To avoid having your data polluting the main app's analytics and crash report services:
    - If you want to use Firebase analytics, replace [`google-services.json`](https://github.com/tachiyomiorg/tachiyomi/blob/master/app/src/standard/google-services.json) with your own
    - If you want to use ACRA crash reporting, replace the `ACRA_URI` endpoint in [`build.gradle.kts`](https://github.com/tachiyomiorg/tachiyomi/blob/master/app/build.gradle.kts) with your own
+
+
+### Supporting Cloud Sync - Google Drive Implementation
+1. Go to [Google Cloud Console](https://console.cloud.google.com)
+2. Create a new project
+3. Go to API & Services -> Library -> Google Drive API and click enable
+4. Go to API & Services -> Oauth consent screen
+5. Create it, fill in the app name, user support email, and developer contact information
+6. In the next screen, click add or remove scopes, and add the `.../auth/drive.appdata` and `.../auth/drive.file` scopes
+7. Don't add any test users and go back to the dashboard
+8. Click publish
+9. Go to API & Services -> Credentials
+10. Click Create credentials -> Oauth client ID
+11. Select Android, give it a name, and set `eu.kanade.google.oauth` as the package name
+12. To get the SHA-1 key, run `keytool -printcert -jarfile app-standard-universal-release.apk` on your apk, and copy the listed SHA-1
+13. Expand advanced settings, and enable Custom URL scheme
+14. After that just download the json, name it to `client_secrets.json` and put it in `app/src/main/assets/`
@@ -1,16 +1,16 @@
-| Preview Builds | Release Builds | Tachiyomi Support Server |
+| Preview Builds | Release Builds | Mihon Support Server |
 |-------|----------|----------|
 | [![Preview](https://github.com/jobobby04/TachiyomiSYPreview/workflows/Remote%20Dispatch%20Build%20App/badge.svg)](https://github.com/jobobby04/TachiyomiSYPreview/releases) | [![stable release](https://img.shields.io/github/release/jobobby04/tachiyomisy.svg?maxAge=3600&label=download)](https://github.com/jobobby04/tachiyomisy/releases/latest) | [![Discord](https://img.shields.io/discord/1195734228319617024.svg?label=discord&labelColor=7289da&color=2c2f33&style=flat)](https://discord.gg/mihon) |


 # ![app icon](./.github/readme-images/app-icon.png)TachiyomiSY
-Tachiyomi is a free and open source manga reader for Android 6.0 and above. This version of Tachiyomi, TachiyomiSY was based off TachiyomiAZ. This version is meant to push forward in the ways of usability and features. TachiyomiSY tries to push forward where it can, but staying in a place where it can easily grab updates and features from the main app, it tries to make new features, or take features from other forks like J2K and Neko.
+Mihon is a free and open source manga reader for Android 6.0 and above. This version of Mihon, TachiyomiSY was based off TachiyomiAZ. This version is meant to push forward in the ways of usability and features. TachiyomiSY tries to push forward where it can, but staying in a place where it can easily grab updates and features from the main app, it tries to make new features, or take features from other forks like J2K and Neko.

 ![screenshots of app](./.github/readme-images/screens.png)

 ## Features

-Features of Tachiyomi(original) include:
+Features of Mihon(original) include:
 * Online reading from a variety of sources
 * Local reading of downloaded content
 * A configurable reader with multiple viewers, reading directions and other settings.
@@ -42,7 +42,6 @@ Features of TachiyomiSY include:
 * Page preload customization
 * Customize image cache size
 * Batch import of custom sources and featured extensions
-* Automatic CAPTCHA solving
 * Advanced source settings page, searching, enable/disable all
 * Click tag for local search, long click tag for global search
 * Merge multiple of the same manga from different sources
@@ -116,4 +115,4 @@ See [CODE_OF_CONDUCT.md](./CODE_OF_CONDUCT.md).
 ## FAQ

 [See our website.](https://mihon.app/)
-You can also reach out to us on [Discord](https://discord.gg/mihon).
+You can also reach out to us on [Discord](https://discord.gg/mihon).
@@ -1,9 +1,12 @@
+import mihon.buildlogic.getBuildTime
+import mihon.buildlogic.getCommitCount
+import mihon.buildlogic.getGitSha
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

 plugins {
-    id("com.android.application")
+    id("mihon.android.application")
+    id("mihon.android.application.compose")
    id("com.mikepenz.aboutlibraries.plugin")
-    kotlin("android")
    kotlin("plugin.parcelize")
    kotlin("plugin.serialization")
    // id("com.github.zellius.shortcut-helper")
@@ -26,7 +29,7 @@ android {
    defaultConfig {
        applicationId = "eu.kanade.tachiyomi.sy"

-        versionCode = 65
+        versionCode = 67
        versionName = "1.10.5"

        buildConfigField("String", "COMMIT_COUNT", "\"${getCommitCount()}\"")
@@ -120,7 +123,6 @@ android {

    buildFeatures {
        viewBinding = true
-        compose = true
        buildConfig = true

        // Disable some unused things
@@ -133,10 +135,6 @@ android {
        abortOnError = false
        checkReleaseBuilds = false
    }
-
-    composeOptions {
-        kotlinCompilerExtensionVersion = compose.versions.compiler.get()
-    }
 }

 dependencies {
@@ -154,7 +152,6 @@ dependencies {
    implementation(projects.presentationWidget)

    // Compose
-    implementation(platform(compose.bom))
    implementation(compose.activity)
    implementation(compose.foundation)
    implementation(compose.material3.core)
@@ -165,7 +162,6 @@ dependencies {
    debugImplementation(compose.ui.tooling)
    implementation(compose.ui.tooling.preview)
    implementation(compose.ui.util)
-    implementation(compose.accompanist.webview)
    implementation(compose.accompanist.systemuicontroller)

    implementation(androidx.paging.runtime)
@@ -215,7 +211,7 @@ dependencies {
    // Disk
    implementation(libs.disklrucache)
    implementation(libs.unifile)
-    implementation(libs.junrar)
+    implementation(libs.bundles.archive)
    // SY -->
    implementation(libs.zip4j)
    // SY <--
@@ -247,12 +243,17 @@ dependencies {
    implementation(libs.bundles.voyager)
    implementation(libs.compose.materialmotion)
    implementation(libs.swipe)
+    implementation(libs.compose.webview)
+    implementation(libs.compose.grid)
+
+
+    implementation(libs.google.api.services.drive)
+    implementation(libs.google.api.client.oauth)

    // Logging
    implementation(libs.logcat)

    // Crash reports/analytics
-    // implementation(libs.bundles.acra)
    // "standardImplementation"(libs.firebase.analytics)

    // Shizuku
@@ -265,6 +266,8 @@ dependencies {
    // debugImplementation(libs.leakcanary.android)
    implementation(libs.leakcanary.plumber)

+    testImplementation(kotlinx.coroutines.test)
+
    // SY -->
    // Text distance (EH)
    implementation(sylibs.simularity)
@@ -311,31 +314,11 @@ tasks {
            "-opt-in=androidx.compose.animation.ExperimentalAnimationApi",
            "-opt-in=androidx.compose.animation.graphics.ExperimentalAnimationGraphicsApi",
            "-opt-in=coil3.annotation.ExperimentalCoilApi",
-            "-opt-in=com.google.accompanist.permissions.ExperimentalPermissionsApi",
            "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
            "-opt-in=kotlinx.coroutines.FlowPreview",
            "-opt-in=kotlinx.coroutines.InternalCoroutinesApi",
            "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
        )
-
-        if (project.findProperty("tachiyomi.enableComposeCompilerMetrics") == "true") {
-            kotlinOptions.freeCompilerArgs += listOf(
-                "-P",
-                "plugin:androidx.compose.compiler.plugins.kotlin:reportsDestination=" +
-                    project.layout.buildDirectory.dir("compose_metrics").get().asFile.absolutePath,
-            )
-            kotlinOptions.freeCompilerArgs += listOf(
-                "-P",
-                "plugin:androidx.compose.compiler.plugins.kotlin:metricsDestination=" +
-                    project.layout.buildDirectory.dir("compose_metrics").get().asFile.absolutePath,
-            )
-        }
-
-        // https://developer.android.com/jetpack/androidx/releases/compose-compiler#1.5.9
-        kotlinOptions.freeCompilerArgs += listOf(
-            "-P",
-            "plugin:androidx.compose.compiler.plugins.kotlin:nonSkippingGroupOptimization=true",
-        )
    }
 }

@@ -2,6 +2,7 @@

 -keep,allowoptimization class eu.kanade.**
 -keep,allowoptimization class tachiyomi.**
+-keep,allowoptimization class mihon.**

 # Keep common dependencies used in extensions
 -keep,allowoptimization class androidx.preference.** { public protected *; }
@@ -122,10 +123,19 @@
 # XmlUtil
 -keep public enum nl.adaptivity.xmlutil.EventType { *; }

+# Apache Commons Compress
+-keep class * extends org.apache.commons.compress.archivers.zip.ZipExtraField { <init>(); }
+
 # Firebase
 -keep class com.google.firebase.installations.** { *; }
 -keep interface com.google.firebase.installations.** { *; }

+# Google Drive
+-keep class com.google.api.services.** { *; }
+
+# Google OAuth
+-keep class com.google.api.client.** { *; }
+
 # SY -->
 # SqlCipher
 -keepclassmembers class net.zetetic.database.sqlcipher.SQLiteCustomFunction { *; }
@@ -260,6 +270,9 @@
 -keep,allowoptimization class * extends uy.kohesive.injekt.api.TypeReference
 -keep,allowoptimization public class io.requery.android.database.sqlite.SQLiteConnection { *; }

+ # Keep apache http client
+ -keep class org.apache.http.** { *; }
+
 # Suggested rules
 -dontwarn com.oracle.svm.core.annotate.AutomaticFeature
 -dontwarn com.oracle.svm.core.annotate.Delete
@@ -272,4 +285,16 @@
 -dontwarn org.slf4j.impl.StaticLoggerBinder
 -dontwarn java.lang.Module
 -dontwarn org.graalvm.nativeimage.hosted.RuntimeResourceAccess
-dontwarn org.jspecify.annotations.NullMarked
+-dontwarn org.jspecify.annotations.NullMarked
+-dontwarn javax.naming.InvalidNameException
+-dontwarn javax.naming.NamingException
+-dontwarn javax.naming.directory.Attribute
+-dontwarn javax.naming.directory.Attributes
+-dontwarn javax.naming.ldap.LdapName
+-dontwarn javax.naming.ldap.Rdn
+-dontwarn org.ietf.jgss.GSSContext
+-dontwarn org.ietf.jgss.GSSCredential
+-dontwarn org.ietf.jgss.GSSException
+-dontwarn org.ietf.jgss.GSSManager
+-dontwarn org.ietf.jgss.GSSName
+-dontwarn org.ietf.jgss.Oid
@@ -188,6 +188,20 @@
                <data android:host="shikimori-auth" />
            </intent-filter>
        </activity>
+        <activity
+            android:name=".ui.setting.track.GoogleDriveLoginActivity"
+            android:label="GoogleDrive"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data
+                    android:scheme="eu.kanade.google.oauth" />
+            </intent-filter>
+        </activity>

        <activity
            android:name="exh.ui.login.EhLoginActivity"
@@ -4,10 +4,7 @@ import eu.kanade.domain.chapter.interactor.GetAvailableScanlators
 import eu.kanade.domain.chapter.interactor.SetReadStatus
 import eu.kanade.domain.chapter.interactor.SyncChaptersWithSource
 import eu.kanade.domain.download.interactor.DeleteDownload
-import eu.kanade.domain.extension.interactor.CreateExtensionRepo
-import eu.kanade.domain.extension.interactor.DeleteExtensionRepo
 import eu.kanade.domain.extension.interactor.GetExtensionLanguages
-import eu.kanade.domain.extension.interactor.GetExtensionRepos
 import eu.kanade.domain.extension.interactor.GetExtensionSources
 import eu.kanade.domain.extension.interactor.GetExtensionsByType
 import eu.kanade.domain.extension.interactor.TrustExtension
@@ -26,6 +23,16 @@ import eu.kanade.domain.track.interactor.AddTracks
 import eu.kanade.domain.track.interactor.RefreshTracks
 import eu.kanade.domain.track.interactor.SyncChapterProgressWithTrack
 import eu.kanade.domain.track.interactor.TrackChapter
+import mihon.data.repository.ExtensionRepoRepositoryImpl
+import mihon.domain.extensionrepo.interactor.CreateExtensionRepo
+import mihon.domain.extensionrepo.interactor.DeleteExtensionRepo
+import mihon.domain.extensionrepo.interactor.GetExtensionRepo
+import mihon.domain.extensionrepo.interactor.GetExtensionRepoCount
+import mihon.domain.extensionrepo.interactor.ReplaceExtensionRepo
+import mihon.domain.extensionrepo.interactor.UpdateExtensionRepo
+import mihon.domain.extensionrepo.repository.ExtensionRepoRepository
+import mihon.domain.extensionrepo.service.ExtensionRepoService
+import mihon.domain.upcoming.interactor.GetUpcomingManga
 import tachiyomi.data.category.CategoryRepositoryImpl
 import tachiyomi.data.chapter.ChapterRepositoryImpl
 import tachiyomi.data.history.HistoryRepositoryImpl
@@ -111,6 +118,7 @@ class DomainModule : InjektModule {
        addFactory { GetMangaByUrlAndSourceId(get()) }
        addFactory { GetManga(get()) }
        addFactory { GetNextChapters(get(), get(), get(), get()) }
+        addFactory { GetUpcomingManga(get()) }
        addFactory { ResetViewerFlags(get()) }
        addFactory { SetMangaChapterFlags(get()) }
        addFactory { FetchInterval(get()) }
@@ -171,10 +179,15 @@ class DomainModule : InjektModule {
        addFactory { ToggleLanguage(get()) }
        addFactory { ToggleSource(get()) }
        addFactory { ToggleSourcePin(get()) }
-        addFactory { TrustExtension(get()) }
+        addFactory { TrustExtension(get(), get()) }

-        addFactory { CreateExtensionRepo(get()) }
+        addSingletonFactory<ExtensionRepoRepository> { ExtensionRepoRepositoryImpl(get()) }
+        addFactory { ExtensionRepoService(get(), get()) }
+        addFactory { GetExtensionRepo(get()) }
+        addFactory { GetExtensionRepoCount(get()) }
+        addFactory { CreateExtensionRepo(get(), get()) }
        addFactory { DeleteExtensionRepo(get()) }
-        addFactory { GetExtensionRepos(get()) }
+        addFactory { ReplaceExtensionRepo(get()) }
+        addFactory { UpdateExtensionRepo(get(), get()) }
    }
 }
@@ -2,8 +2,6 @@ package eu.kanade.domain.base

 import android.content.Context
 import dev.icerock.moko.resources.StringResource
-import eu.kanade.tachiyomi.util.system.isPreviewBuildType
-import eu.kanade.tachiyomi.util.system.isReleaseBuildType
 import tachiyomi.core.common.preference.Preference
 import tachiyomi.core.common.preference.PreferenceStore
 import tachiyomi.i18n.MR
@@ -22,8 +20,6 @@ class BasePreferences(

    fun extensionInstaller() = ExtensionInstallerPreference(context, preferenceStore)

-    fun acraEnabled() = preferenceStore.getBoolean("acra.enable", isPreviewBuildType || isReleaseBuildType)
-
    fun shownOnboardingFlow() = preferenceStore.getBoolean(Preference.appStateKey("onboarding_complete"), false)

    enum class ExtensionInstaller(val titleRes: StringResource, val requiresSystemPermission: Boolean) {
@@ -32,4 +28,6 @@ class BasePreferences(
        SHIZUKU(MR.strings.ext_installer_shizuku, false),
        PRIVATE(MR.strings.ext_installer_private, false),
    }
+
+    fun displayProfile() = preferenceStore.getString("pref_display_profile_key", "")
 }
@@ -39,4 +39,5 @@ fun Chapter.toDbChapter(): DbChapter = ChapterImpl().also {
    it.date_upload = dateUpload
    it.chapter_number = chapterNumber.toFloat()
    it.source_order = sourceOrder.toInt()
+    it.last_modified = lastModifiedAt
 }
@@ -1,25 +0,0 @@
-package eu.kanade.domain.extension.interactor
-
-import eu.kanade.domain.source.service.SourcePreferences
-import tachiyomi.core.common.preference.plusAssign
-
-class CreateExtensionRepo(private val preferences: SourcePreferences) {
-
-    fun await(name: String): Result {
-        // Do not allow invalid formats
-        if (!name.matches(repoRegex)) {
-            return Result.InvalidUrl
-        }
-
-        preferences.extensionRepos() += name.removeSuffix("/index.min.json")
-
-        return Result.Success
-    }
-
-    sealed interface Result {
-        data object InvalidUrl : Result
-        data object Success : Result
-    }
-}
-
-private val repoRegex = """^https://.*/index\.min\.json$""".toRegex()
@@ -1,11 +0,0 @@
-package eu.kanade.domain.extension.interactor
-
-import eu.kanade.domain.source.service.SourcePreferences
-import tachiyomi.core.common.preference.minusAssign
-
-class DeleteExtensionRepo(private val preferences: SourcePreferences) {
-
-    fun await(repo: String) {
-        preferences.extensionRepos() -= repo
-    }
-}
@@ -1,11 +0,0 @@
-package eu.kanade.domain.extension.interactor
-
-import eu.kanade.domain.source.service.SourcePreferences
-import kotlinx.coroutines.flow.Flow
-
-class GetExtensionRepos(private val preferences: SourcePreferences) {
-
-    fun subscribe(): Flow<Set<String>> {
-        return preferences.extensionRepos().changes()
-    }
-}
@@ -20,7 +20,7 @@ class GetExtensionsByType(
            extensionManager.installedExtensionsFlow,
            extensionManager.untrustedExtensionsFlow,
            extensionManager.availableExtensionsFlow,
-        ) { _activeLanguages, _installed, _untrusted, _available ->
+        ) { enabledLanguages, _installed, _untrusted, _available ->
            val (updates, installed) = _installed
                .filter { (showNsfwSources || !it.isNsfw) }
                .sortedWith(
@@ -41,9 +41,9 @@ class GetExtensionsByType(
                }
                .flatMap { ext ->
                    if (ext.sources.isEmpty()) {
-                        return@flatMap if (ext.lang in _activeLanguages) listOf(ext) else emptyList()
+                        return@flatMap if (ext.lang in enabledLanguages) listOf(ext) else emptyList()
                    }
-                    ext.sources.filter { it.lang in _activeLanguages }
+                    ext.sources.filter { it.lang in enabledLanguages }
                        .map {
                            ext.copy(
                                name = it.name,
@@ -3,15 +3,18 @@ package eu.kanade.domain.extension.interactor
 import android.content.pm.PackageInfo
 import androidx.core.content.pm.PackageInfoCompat
 import eu.kanade.domain.source.service.SourcePreferences
+import mihon.domain.extensionrepo.repository.ExtensionRepoRepository
 import tachiyomi.core.common.preference.getAndSet

 class TrustExtension(
+    private val extensionRepoRepository: ExtensionRepoRepository,
    private val preferences: SourcePreferences,
 ) {

-    fun isTrusted(pkgInfo: PackageInfo, signatureHash: String): Boolean {
-        val key = "${pkgInfo.packageName}:${PackageInfoCompat.getLongVersionCode(pkgInfo)}:$signatureHash"
-        return key in preferences.trustedExtensions().get()
+    suspend fun isTrusted(pkgInfo: PackageInfo, fingerprints: List<String>): Boolean {
+        val trustedFingerprints = extensionRepoRepository.getAll().map { it.signingKeyFingerprint }.toHashSet()
+        val key = "${pkgInfo.packageName}:${PackageInfoCompat.getLongVersionCode(pkgInfo)}:${fingerprints.last()}"
+        return trustedFingerprints.any { fingerprints.contains(it) } || key in preferences.trustedExtensions().get()
    }

    fun trust(pkgName: String, versionCode: Long, signatureHash: String) {
@@ -19,9 +22,7 @@ class TrustExtension(
            // Remove previously trusted versions
            val removed = exts.filterNot { it.startsWith("$pkgName:") }.toMutableSet()

-            removed.also {
-                it += "$pkgName:$versionCode:$signatureHash"
-            }
+            removed.also { it += "$pkgName:$versionCode:$signatureHash" }
        }
    }

@@ -0,0 +1,101 @@
+package eu.kanade.domain.sync
+
+import eu.kanade.domain.sync.models.SyncSettings
+import eu.kanade.tachiyomi.data.sync.models.SyncTriggerOptions
+import tachiyomi.core.common.preference.Preference
+import tachiyomi.core.common.preference.PreferenceStore
+import java.util.UUID
+
+class SyncPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+    fun clientHost() = preferenceStore.getString("sync_client_host", "https://sync.tachiyomi.org")
+    fun clientAPIKey() = preferenceStore.getString("sync_client_api_key", "")
+    fun lastSyncTimestamp() = preferenceStore.getLong(Preference.appStateKey("last_sync_timestamp"), 0L)
+
+    fun lastSyncEtag() =  preferenceStore.getString("sync_etag", "")
+
+    fun syncInterval() = preferenceStore.getInt("sync_interval", 0)
+    fun syncService() = preferenceStore.getInt("sync_service", 0)
+
+    fun googleDriveAccessToken() = preferenceStore.getString(
+        Preference.appStateKey("google_drive_access_token"),
+        "",
+    )
+
+    fun googleDriveRefreshToken() = preferenceStore.getString(
+        Preference.appStateKey("google_drive_refresh_token"),
+        "",
+    )
+
+    fun uniqueDeviceID(): String {
+        val uniqueIDPreference = preferenceStore.getString("unique_device_id", "")
+
+        // Retrieve the current value of the preference
+        var uniqueID = uniqueIDPreference.get()
+        if (uniqueID.isBlank()) {
+            uniqueID = UUID.randomUUID().toString()
+            uniqueIDPreference.set(uniqueID)
+        }
+
+        return uniqueID
+    }
+
+    fun isSyncEnabled(): Boolean {
+        return syncService().get() != 0
+    }
+
+    fun getSyncSettings(): SyncSettings {
+        return SyncSettings(
+            libraryEntries = preferenceStore.getBoolean("library_entries", true).get(),
+            categories = preferenceStore.getBoolean("categories", true).get(),
+            chapters = preferenceStore.getBoolean("chapters", true).get(),
+            tracking = preferenceStore.getBoolean("tracking", true).get(),
+            history = preferenceStore.getBoolean("history", true).get(),
+            appSettings = preferenceStore.getBoolean("appSettings", true).get(),
+            sourceSettings = preferenceStore.getBoolean("sourceSettings", true).get(),
+            privateSettings = preferenceStore.getBoolean("privateSettings", true).get(),
+
+            // SY -->
+            customInfo = preferenceStore.getBoolean("customInfo", true).get(),
+            readEntries = preferenceStore.getBoolean("readEntries", true).get()
+            // SY <--
+        )
+    }
+
+    fun setSyncSettings(syncSettings: SyncSettings) {
+        preferenceStore.getBoolean("library_entries", true).set(syncSettings.libraryEntries)
+        preferenceStore.getBoolean("categories", true).set(syncSettings.categories)
+        preferenceStore.getBoolean("chapters", true).set(syncSettings.chapters)
+        preferenceStore.getBoolean("tracking", true).set(syncSettings.tracking)
+        preferenceStore.getBoolean("history", true).set(syncSettings.history)
+        preferenceStore.getBoolean("appSettings", true).set(syncSettings.appSettings)
+        preferenceStore.getBoolean("sourceSettings", true).set(syncSettings.sourceSettings)
+        preferenceStore.getBoolean("privateSettings", true).set(syncSettings.privateSettings)
+
+        // SY -->
+        preferenceStore.getBoolean("customInfo", true).set(syncSettings.customInfo)
+        preferenceStore.getBoolean("readEntries", true).set(syncSettings.readEntries)
+        // SY <--
+    }
+
+    fun getSyncTriggerOptions(): SyncTriggerOptions {
+        return SyncTriggerOptions(
+            syncOnChapterRead = preferenceStore.getBoolean("sync_on_chapter_read", false).get(),
+            syncOnChapterOpen = preferenceStore.getBoolean("sync_on_chapter_open", false).get(),
+            syncOnAppStart = preferenceStore.getBoolean("sync_on_app_start", false).get(),
+            syncOnAppResume = preferenceStore.getBoolean("sync_on_app_resume", false).get(),
+        )
+    }
+
+    fun setSyncTriggerOptions(syncTriggerOptions: SyncTriggerOptions) {
+        preferenceStore.getBoolean("sync_on_chapter_read", false)
+            .set(syncTriggerOptions.syncOnChapterRead)
+        preferenceStore.getBoolean("sync_on_chapter_open", false)
+            .set(syncTriggerOptions.syncOnChapterOpen)
+        preferenceStore.getBoolean("sync_on_app_start", false)
+            .set(syncTriggerOptions.syncOnAppStart)
+        preferenceStore.getBoolean("sync_on_app_resume", false)
+            .set(syncTriggerOptions.syncOnAppResume)
+    }
+}
@@ -0,0 +1,17 @@
+package eu.kanade.domain.sync.models
+
+data class SyncSettings(
+    val libraryEntries: Boolean = true,
+    val categories: Boolean = true,
+    val chapters: Boolean = true,
+    val tracking: Boolean = true,
+    val history: Boolean = true,
+    val appSettings: Boolean = true,
+    val sourceSettings: Boolean = true,
+    val privateSettings: Boolean = false,
+
+    // SY -->
+    val customInfo: Boolean = true,
+    val readEntries: Boolean = true
+    // SY <--
+)
@@ -5,7 +5,6 @@ import android.net.Uri
 import android.provider.Settings
 import android.util.DisplayMetrics
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
@@ -362,10 +361,8 @@ private fun InfoText(
    primaryTextStyle: TextStyle = MaterialTheme.typography.bodyLarge,
    onClick: (() -> Unit)? = null,
 ) {
-    val interactionSource = remember { MutableInteractionSource() }
-
    val clickableModifier = if (onClick != null) {
-        Modifier.clickable(interactionSource, indication = null) { onClick() }
+        Modifier.clickable(interactionSource = null, indication = null, onClick = onClick)
    } else {
        Modifier
    }
@@ -70,7 +70,7 @@ fun FeedScreen(
    onClickDelete: (FeedSavedSearch) -> Unit,
    onClickManga: (Manga) -> Unit,
    onRefresh: () -> Unit,
-    getMangaState: @Composable (Manga, CatalogueSource?) -> State<Manga>,
+    getMangaState: @Composable (Manga) -> State<Manga>,
 ) {
    when {
        state.isLoading -> LoadingScreen()
@@ -119,7 +119,7 @@ fun FeedScreen(
                        ) {
                            FeedItem(
                                item = item,
-                                getMangaState = { getMangaState(it, item.source) },
+                                getMangaState = { getMangaState(it) },
                                onClickManga = onClickManga,
                            )
                        }
@@ -37,7 +37,7 @@ fun CrashScreen(
        acceptText = stringResource(MR.strings.pref_dump_crash_logs),
        onAcceptClick = {
            scope.launch {
-                CrashLogUtil(context).dumpLogs()
+                CrashLogUtil(context).dumpLogs(exception)
            }
        },
        rejectText = stringResource(MR.strings.crash_screen_restart_application),
@@ -38,6 +38,7 @@ fun LibraryToolbar(
    onClickRefresh: () -> Unit,
    onClickGlobalUpdate: () -> Unit,
    onClickOpenRandomManga: () -> Unit,
+    onClickSyncNow: () -> Unit,
    // SY -->
    onClickSyncExh: (() -> Unit)?,
    // SY <--
@@ -60,6 +61,7 @@ fun LibraryToolbar(
        onClickRefresh = onClickRefresh,
        onClickGlobalUpdate = onClickGlobalUpdate,
        onClickOpenRandomManga = onClickOpenRandomManga,
+        onClickSyncNow = onClickSyncNow,
        // SY -->
        onClickSyncExh = onClickSyncExh,
        // SY <--
@@ -77,6 +79,7 @@ private fun LibraryRegularToolbar(
    onClickRefresh: () -> Unit,
    onClickGlobalUpdate: () -> Unit,
    onClickOpenRandomManga: () -> Unit,
+    onClickSyncNow: () -> Unit,
    // SY -->
    onClickSyncExh: (() -> Unit)?,
    // SY <--
@@ -125,7 +128,10 @@ private fun LibraryRegularToolbar(
                        title = stringResource(MR.strings.action_open_random_manga),
                        onClick = onClickOpenRandomManga,
                    ),
-
+                    AppBar.OverflowAction(
+                        title = stringResource(SYMR.strings.sync_library),
+                        onClick = onClickSyncNow,
+                    ),
                ).builder().apply {
                    // SY -->
                    if (onClickSyncExh != null) {
@@ -1,16 +1,33 @@
 package eu.kanade.presentation.manga

+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
-import androidx.compose.material3.AlertDialog
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.sizeIn
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Add
+import androidx.compose.material.icons.outlined.Book
+import androidx.compose.material.icons.outlined.SwapVert
+import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import eu.kanade.presentation.components.AdaptiveSheet
+import eu.kanade.presentation.components.TabbedDialogPaddings
+import eu.kanade.presentation.more.settings.LocalPreferenceMinHeight
+import eu.kanade.presentation.more.settings.widget.TextPreferenceWidget
 import tachiyomi.i18n.MR
-import tachiyomi.presentation.core.components.material.padding
 import tachiyomi.presentation.core.i18n.stringResource

@Composable
@@ -18,42 +35,92 @@ fun DuplicateMangaDialog(
    onDismissRequest: () -> Unit,
    onConfirm: () -> Unit,
    onOpenManga: () -> Unit,
+    onMigrate: () -> Unit,
+    modifier: Modifier = Modifier,
 ) {
-    AlertDialog(
+    val minHeight = LocalPreferenceMinHeight.current
+
+    AdaptiveSheet(
+        modifier = modifier,
        onDismissRequest = onDismissRequest,
-        title = {
-            Text(text = stringResource(MR.strings.are_you_sure))
-        },
-        text = {
-            Text(text = stringResource(MR.strings.confirm_add_duplicate_manga))
-        },
-        confirmButton = {
-            FlowRow(
-                horizontalArrangement = Arrangement.spacedBy(MaterialTheme.padding.extraSmall),
+    ) {
+        Column(
+            modifier = Modifier
+                .padding(
+                    vertical = TabbedDialogPaddings.Vertical,
+                    horizontal = TabbedDialogPaddings.Horizontal,
+                )
+                .fillMaxWidth(),
+        ) {
+            Text(
+                modifier = Modifier.padding(TitlePadding),
+                text = stringResource(MR.strings.are_you_sure),
+                style = MaterialTheme.typography.headlineMedium,
+            )
+
+            Text(
+                text = stringResource(MR.strings.confirm_add_duplicate_manga),
+                style = MaterialTheme.typography.bodyMedium,
+            )
+
+            Spacer(Modifier.height(PaddingSize))
+
+            TextPreferenceWidget(
+                title = stringResource(MR.strings.action_show_manga),
+                icon = Icons.Outlined.Book,
+                onPreferenceClick = {
+                    onDismissRequest()
+                    onOpenManga()
+                },
+            )
+
+            HorizontalDivider()
+
+            TextPreferenceWidget(
+                title = stringResource(MR.strings.action_migrate_duplicate),
+                icon = Icons.Outlined.SwapVert,
+                onPreferenceClick = {
+                    onDismissRequest()
+                    onMigrate()
+                },
+            )
+
+            HorizontalDivider()
+
+            TextPreferenceWidget(
+                title = stringResource(MR.strings.action_add_anyway),
+                icon = Icons.Outlined.Add,
+                onPreferenceClick = {
+                    onDismissRequest()
+                    onConfirm()
+                },
+            )
+
+            Row(
+                modifier = Modifier
+                    .sizeIn(minHeight = minHeight)
+                    .clickable { onDismissRequest.invoke() }
+                    .padding(ButtonPadding)
+                    .fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.Center,
            ) {
-                TextButton(
-                    onClick = {
-                        onDismissRequest()
-                        onOpenManga()
-                    },
-                ) {
-                    Text(text = stringResource(MR.strings.action_show_manga))
-                }
-
-                Spacer(modifier = Modifier.weight(1f))
-
-                TextButton(onClick = onDismissRequest) {
-                    Text(text = stringResource(MR.strings.action_cancel))
-                }
-                TextButton(
-                    onClick = {
-                        onDismissRequest()
-                        onConfirm()
-                    },
-                ) {
-                    Text(text = stringResource(MR.strings.action_add))
+                OutlinedButton(onClick = onDismissRequest, modifier = Modifier.fillMaxWidth()) {
+                    Text(
+                        modifier = Modifier
+                            .padding(vertical = 8.dp),
+                        text = stringResource(MR.strings.action_cancel),
+                        color = MaterialTheme.colorScheme.primary,
+                        style = MaterialTheme.typography.titleLarge,
+                        fontSize = 16.sp,
+                    )
                }
            }
-        },
-    )
+        }
+    }
 }
+
+private val PaddingSize = 16.dp
+
+private val ButtonPadding = PaddingValues(top = 16.dp, bottom = 16.dp)
+private val TitlePadding = PaddingValues(bottom = 16.dp, top = 8.dp)
@@ -9,13 +9,13 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.CheckCircle
 import androidx.compose.material.icons.outlined.ArrowDownward
 import androidx.compose.material.icons.outlined.ErrorOutline
-import androidx.compose.material.ripple
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ProgressIndicatorDefaults
 import androidx.compose.material3.Text
+import androidx.compose.material3.ripple
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -24,6 +24,7 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.StrokeCap
 import androidx.compose.ui.hapticfeedback.HapticFeedback
 import androidx.compose.ui.hapticfeedback.HapticFeedbackType
 import androidx.compose.ui.platform.LocalHapticFeedback
@@ -85,13 +86,12 @@ private fun NotDownloadedIndicator(
    modifier: Modifier = Modifier,
    onClick: (ChapterDownloadAction) -> Unit,
 ) {
-    val hapticFeedback = LocalHapticFeedback.current
    Box(
        modifier = modifier
            .size(IconButtonTokens.StateLayerSize)
            .commonClickable(
                enabled = enabled,
-                hapticFeedback = hapticFeedback,
+                hapticFeedback = LocalHapticFeedback.current,
                onLongClick = { onClick(ChapterDownloadAction.START_NOW) },
                onClick = { onClick(ChapterDownloadAction.START) },
            )
@@ -115,14 +115,13 @@ private fun DownloadingIndicator(
    onClick: (ChapterDownloadAction) -> Unit,
    modifier: Modifier = Modifier,
 ) {
-    val hapticFeedback = LocalHapticFeedback.current
    var isMenuExpanded by remember { mutableStateOf(false) }
    Box(
        modifier = modifier
            .size(IconButtonTokens.StateLayerSize)
            .commonClickable(
                enabled = enabled,
-                hapticFeedback = hapticFeedback,
+                hapticFeedback = LocalHapticFeedback.current,
                onLongClick = { onClick(ChapterDownloadAction.CANCEL) },
                onClick = { isMenuExpanded = true },
            ),
@@ -139,6 +138,8 @@ private fun DownloadingIndicator(
                modifier = IndicatorModifier,
                color = strokeColor,
                strokeWidth = IndicatorStrokeWidth,
+                trackColor = Color.Transparent,
+                strokeCap = StrokeCap.Butt,
            )
        } else {
            val animatedProgress by animateFloatAsState(
@@ -155,6 +156,9 @@ private fun DownloadingIndicator(
                modifier = IndicatorModifier,
                color = strokeColor,
                strokeWidth = IndicatorSize / 2,
+                trackColor = Color.Transparent,
+                strokeCap = StrokeCap.Butt,
+                gapSize = 0.dp,
            )
        }
        DropdownMenu(expanded = isMenuExpanded, onDismissRequest = { isMenuExpanded = false }) {
@@ -188,14 +192,13 @@ private fun DownloadedIndicator(
    modifier: Modifier = Modifier,
    onClick: (ChapterDownloadAction) -> Unit,
 ) {
-    val hapticFeedback = LocalHapticFeedback.current
    var isMenuExpanded by remember { mutableStateOf(false) }
    Box(
        modifier = modifier
            .size(IconButtonTokens.StateLayerSize)
            .commonClickable(
                enabled = enabled,
-                hapticFeedback = hapticFeedback,
+                hapticFeedback = LocalHapticFeedback.current,
                onLongClick = { isMenuExpanded = true },
                onClick = { isMenuExpanded = true },
            ),
@@ -225,13 +228,12 @@ private fun ErrorIndicator(
    modifier: Modifier = Modifier,
    onClick: (ChapterDownloadAction) -> Unit,
 ) {
-    val hapticFeedback = LocalHapticFeedback.current
    Box(
        modifier = modifier
            .size(IconButtonTokens.StateLayerSize)
            .commonClickable(
                enabled = enabled,
-                hapticFeedback = hapticFeedback,
+                hapticFeedback = LocalHapticFeedback.current,
                onLongClick = { onClick(ChapterDownloadAction.START) },
                onClick = { onClick(ChapterDownloadAction.START) },
            ),
@@ -8,7 +8,6 @@ import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.animation.shrinkVertically
 import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -33,12 +32,12 @@ import androidx.compose.material.icons.outlined.Label
 import androidx.compose.material.icons.outlined.MoreVert
 import androidx.compose.material.icons.outlined.RemoveDone
 import androidx.compose.material.icons.outlined.SwapCalls
-import androidx.compose.material.ripple
 import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.material3.ripple
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateListOf
@@ -199,7 +198,7 @@ private fun RowScope.Button(
            .size(48.dp)
            .weight(animatedWeight)
            .combinedClickable(
-                interactionSource = remember { MutableInteractionSource() },
+                interactionSource = null,
                indication = ripple(bounded = false),
                onLongClick = onLongClick,
                onClick = onClick,
@@ -239,6 +238,7 @@ fun LibraryBottomActionMenu(
    onClickCleanTitles: (() -> Unit)?,
    onClickMigrate: (() -> Unit)?,
    onClickAddToMangaDex: (() -> Unit)?,
+    onClickResetInfo: (() -> Unit)?,
    // SY <--
    modifier: Modifier = Modifier,
 ) {
@@ -267,7 +267,7 @@ fun LibraryBottomActionMenu(
                }
            }
            // SY -->
-            val showOverflow = onClickCleanTitles != null || onClickAddToMangaDex != null
+            val showOverflow = onClickCleanTitles != null || onClickAddToMangaDex != null || onClickResetInfo != null
            val configuration = LocalConfiguration.current
            val moveMarkPrev = remember { !configuration.isTabletUi() }
            var overFlowOpen by remember { mutableStateOf(false) }
@@ -364,6 +364,12 @@ fun LibraryBottomActionMenu(
                                onClick = onClickAddToMangaDex,
                            )
                        }
+                        if (onClickResetInfo != null) {
+                            DropdownMenuItem(
+                                text = { Text(text = stringResource(SYMR.strings.reset_info)) },
+                                onClick = onClickResetInfo,
+                            )
+                        }
                    }
                } else {
                    Button(
@@ -30,13 +30,13 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
 import eu.kanade.tachiyomi.data.download.model.Download
 import me.saket.swipe.SwipeableActionsBox
 import tachiyomi.domain.library.service.LibraryPreferences
@@ -143,13 +143,8 @@ fun MangaChapterListItem(
                    )
                }

-                Row {
-                    ProvideTextStyle(
-                        value = MaterialTheme.typography.bodyMedium.copy(
-                            fontSize = 12.sp,
-                            color = LocalContentColor.current.copy(alpha = textSubtitleAlpha),
-                        ),
-                    ) {
+                Row(modifier = Modifier.alpha(textSubtitleAlpha)) {
+                    ProvideTextStyle(value = MaterialTheme.typography.bodySmall) {
                        if (date != null) {
                            Text(
                                text = date,
@@ -8,6 +8,8 @@ import android.provider.Settings
 import android.webkit.WebStorage
 import android.webkit.WebView
 import android.widget.Toast
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Text
@@ -60,7 +62,6 @@ import eu.kanade.tachiyomi.util.CrashLogUtil
 import eu.kanade.tachiyomi.util.storage.DiskUtil
 import eu.kanade.tachiyomi.util.system.isDevFlavor
 import eu.kanade.tachiyomi.util.system.isPreviewBuildType
-import eu.kanade.tachiyomi.util.system.isReleaseBuildType
 import eu.kanade.tachiyomi.util.system.isShizukuInstalled
 import eu.kanade.tachiyomi.util.system.powerManager
 import eu.kanade.tachiyomi.util.system.setDefaultSettings
@@ -113,71 +114,54 @@ object SettingsAdvancedScreen : SearchableSettings {
        val basePreferences = remember { Injekt.get<BasePreferences>() }
        val networkPreferences = remember { Injekt.get<NetworkPreferences>() }

-        return buildList {
-            addAll(
-                listOf(
-                    /* SY --> Preference.PreferenceItem.SwitchPreference(
-                        pref = basePreferences.acraEnabled(),
-                        title = stringResource(MR.strings.pref_enable_acra),
-                        subtitle = stringResource(MR.strings.pref_acra_summary),
-                        enabled = isPreviewBuildType || isReleaseBuildType,
-                    ), SY <-- */
-                    Preference.PreferenceItem.TextPreference(
-                        title = stringResource(MR.strings.pref_dump_crash_logs),
-                        subtitle = stringResource(MR.strings.pref_dump_crash_logs_summary),
-                        onClick = {
-                            scope.launch {
-                                CrashLogUtil(context).dumpLogs()
-                            }
-                        },
-                    ),
-                    /* SY --> Preference.PreferenceItem.SwitchPreference(
-                        pref = networkPreferences.verboseLogging(),
-                        title = stringResource(MR.strings.pref_verbose_logging),
-                        subtitle = stringResource(MR.strings.pref_verbose_logging_summary),
-                        onValueChanged = {
-                            context.toast(MR.strings.requires_app_restart)
-                            true
-                        },
-                    ), SY <-- */
-                    Preference.PreferenceItem.TextPreference(
-                        title = stringResource(MR.strings.pref_debug_info),
-                        onClick = { navigator.push(DebugInfoScreen()) },
-                    ),
-                    Preference.PreferenceItem.TextPreference(
-                        title = stringResource(MR.strings.pref_onboarding_guide),
-                        onClick = { navigator.push(OnboardingScreen()) },
-                    ),
-                ),
-            )
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                add(
-                    Preference.PreferenceItem.TextPreference(
-                        title = stringResource(MR.strings.pref_manage_notifications),
-                        onClick = {
-                            val intent = Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS).apply {
-                                putExtra(Settings.EXTRA_APP_PACKAGE, context.packageName)
-                            }
-                            context.startActivity(intent)
-                        },
-                    ),
-                )
-            }
-            addAll(
-                listOf(
-                    getBackgroundActivityGroup(),
-                    getDataGroup(),
-                    getNetworkGroup(networkPreferences = networkPreferences),
-                    getLibraryGroup(),
-                    getExtensionsGroup(basePreferences = basePreferences),
-                    // SY -->
-                    // getDownloaderGroup(),
-                    getDataSaverGroup(),
-                    getDeveloperToolsGroup(),
-                    // SY <--
-                ),
-            )
-        }
+        return listOf(
+            Preference.PreferenceItem.TextPreference(
+                title = stringResource(MR.strings.pref_dump_crash_logs),
+                subtitle = stringResource(MR.strings.pref_dump_crash_logs_summary),
+                onClick = {
+                    scope.launch {
+                        CrashLogUtil(context).dumpLogs()
+                    }
+                },
+            ),
+            /* SY --> Preference.PreferenceItem.SwitchPreference(
+                pref = networkPreferences.verboseLogging(),
+                title = stringResource(MR.strings.pref_verbose_logging),
+                subtitle = stringResource(MR.strings.pref_verbose_logging_summary),
+                onValueChanged = {
+                    context.toast(MR.strings.requires_app_restart)
+                    true
+                },
+            ), SY <-- */
+            Preference.PreferenceItem.TextPreference(
+                title = stringResource(MR.strings.pref_debug_info),
+                onClick = { navigator.push(DebugInfoScreen()) },
+            ),
+            Preference.PreferenceItem.TextPreference(
+                title = stringResource(MR.strings.pref_onboarding_guide),
+                onClick = { navigator.push(OnboardingScreen()) },
+            ),
+            Preference.PreferenceItem.TextPreference(
+                title = stringResource(MR.strings.pref_manage_notifications),
+                onClick = {
+                    val intent = Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS).apply {
+                        putExtra(Settings.EXTRA_APP_PACKAGE, context.packageName)
+                    }
+                    context.startActivity(intent)
+                },
+            ),
+            getBackgroundActivityGroup(),
+            getDataGroup(),
+            getNetworkGroup(networkPreferences = networkPreferences),
+            getLibraryGroup(),
+            getReaderGroup(basePreferences = basePreferences),
+            getExtensionsGroup(basePreferences = basePreferences),
+            // SY -->
+            // getDownloaderGroup(),
+            getDataSaverGroup(),
+            getDeveloperToolsGroup(),
+            // SY <--
+        )
    }

    @Composable
@@ -368,6 +352,34 @@ object SettingsAdvancedScreen : SearchableSettings {
        )
    }

+    @Composable
+    private fun getReaderGroup(
+        basePreferences: BasePreferences,
+    ): Preference.PreferenceGroup {
+        val context = LocalContext.current
+        val chooseColorProfile = rememberLauncherForActivityResult(
+            contract = ActivityResultContracts.OpenDocument(),
+        ) { uri ->
+            uri?.let {
+                val flags = Intent.FLAG_GRANT_READ_URI_PERMISSION
+                context.contentResolver.takePersistableUriPermission(uri, flags)
+                basePreferences.displayProfile().set(uri.toString())
+            }
+        }
+        return Preference.PreferenceGroup(
+            title = stringResource(MR.strings.pref_category_reader),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.TextPreference(
+                    title = stringResource(MR.strings.pref_display_profile),
+                    subtitle = basePreferences.displayProfile().get(),
+                    onClick = {
+                        chooseColorProfile.launch(arrayOf("*/*"))
+                    },
+                ),
+            )
+        )
+    }
+
    @Composable
    private fun getExtensionsGroup(
        basePreferences: BasePreferences,
@@ -2,6 +2,7 @@ package eu.kanade.presentation.more.settings.screen

 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.ReadOnlyComposable
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
@@ -17,6 +18,7 @@ import eu.kanade.presentation.more.settings.screen.browse.ExtensionReposScreen
 import eu.kanade.tachiyomi.ui.category.sources.SourceCategoryScreen
 import eu.kanade.tachiyomi.util.system.AuthenticatorUtil.authenticate
 import kotlinx.collections.immutable.persistentListOf
+import mihon.domain.extensionrepo.interactor.GetExtensionRepoCount
 import tachiyomi.core.common.i18n.stringResource
 import tachiyomi.domain.UnsortedPreferences
 import tachiyomi.i18n.MR
@@ -39,7 +41,9 @@ object SettingsBrowseScreen : SearchableSettings {
        val navigator = LocalNavigator.currentOrThrow

        val sourcePreferences = remember { Injekt.get<SourcePreferences>() }
-        val reposCount by sourcePreferences.extensionRepos().collectAsState()
+        val getExtensionRepoCount = remember { Injekt.get<GetExtensionRepoCount>() }
+
+        val reposCount by getExtensionRepoCount.subscribe().collectAsState(0)

        // SY -->
        val scope = rememberCoroutineScope()
@@ -104,7 +108,7 @@ object SettingsBrowseScreen : SearchableSettings {
                    ),
                    Preference.PreferenceItem.TextPreference(
                        title = stringResource(MR.strings.label_extension_repos),
-                        subtitle = pluralStringResource(MR.plurals.num_repos, reposCount.size, reposCount.size),
+                        subtitle = pluralStringResource(MR.plurals.num_repos, reposCount, reposCount),
                        onClick = {
                            navigator.push(ExtensionReposScreen())
                        },
@@ -15,16 +15,19 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.outlined.HelpOutline
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MultiChoiceSegmentedButtonRow
 import androidx.compose.material3.SegmentedButton
 import androidx.compose.material3.SegmentedButtonDefaults
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.ReadOnlyComposable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
@@ -35,10 +38,13 @@ import androidx.core.net.toUri
 import cafe.adriel.voyager.navigator.LocalNavigator
 import cafe.adriel.voyager.navigator.currentOrThrow
 import com.hippo.unifile.UniFile
+import eu.kanade.domain.sync.SyncPreferences
 import eu.kanade.presentation.more.settings.Preference
 import eu.kanade.presentation.more.settings.screen.data.CreateBackupScreen
 import eu.kanade.presentation.more.settings.screen.data.RestoreBackupScreen
 import eu.kanade.presentation.more.settings.screen.data.StorageInfo
+import eu.kanade.presentation.more.settings.screen.data.SyncSettingsSelector
+import eu.kanade.presentation.more.settings.screen.data.SyncTriggerOptionsScreen
 import eu.kanade.presentation.more.settings.widget.BasePreferenceWidget
 import eu.kanade.presentation.more.settings.widget.PrefsHorizontalPadding
 import eu.kanade.presentation.util.relativeTimeSpanString
@@ -46,10 +52,15 @@ import eu.kanade.tachiyomi.data.backup.create.BackupCreateJob
 import eu.kanade.tachiyomi.data.backup.restore.BackupRestoreJob
 import eu.kanade.tachiyomi.data.cache.ChapterCache
 import eu.kanade.tachiyomi.data.cache.PagePreviewCache
+import eu.kanade.tachiyomi.data.sync.SyncDataJob
+import eu.kanade.tachiyomi.data.sync.SyncManager
+import eu.kanade.tachiyomi.data.sync.service.GoogleDriveService
+import eu.kanade.tachiyomi.data.sync.service.GoogleDriveSyncService
 import eu.kanade.tachiyomi.util.system.DeviceUtil
 import eu.kanade.tachiyomi.util.system.toast
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.persistentMapOf
+import kotlinx.coroutines.launch
 import logcat.LogPriority
 import tachiyomi.core.common.i18n.stringResource
 import tachiyomi.core.common.storage.displayablePath
@@ -91,13 +102,16 @@ object SettingsDataScreen : SearchableSettings {
        val backupPreferences = Injekt.get<BackupPreferences>()
        val storagePreferences = Injekt.get<StoragePreferences>()

+        val syncPreferences = remember { Injekt.get<SyncPreferences>() }
+        val syncService by syncPreferences.syncService().collectAsState()
+
        return persistentListOf(
            getStorageLocationPref(storagePreferences = storagePreferences),
            Preference.PreferenceItem.InfoPreference(stringResource(MR.strings.pref_storage_location_info)),

            getBackupAndRestoreGroup(backupPreferences = backupPreferences),
            getDataGroup(),
-        )
+        ) + getSyncPreferences(syncPreferences = syncPreferences, syncService = syncService)
    }

    @Composable
@@ -330,4 +344,225 @@ object SettingsDataScreen : SearchableSettings {
            ),
        )
    }
+
+    @Composable
+    private fun getSyncPreferences(syncPreferences: SyncPreferences, syncService: Int): List<Preference> {
+        return listOf(
+            Preference.PreferenceGroup(
+                title = stringResource(SYMR.strings.pref_sync_service_category),
+                preferenceItems = persistentListOf(
+                    Preference.PreferenceItem.ListPreference(
+                        pref = syncPreferences.syncService(),
+                        title = stringResource(SYMR.strings.pref_sync_service),
+                        entries = persistentMapOf(
+                            SyncManager.SyncService.NONE.value to stringResource(MR.strings.off),
+                            SyncManager.SyncService.SYNCYOMI.value to stringResource(SYMR.strings.syncyomi),
+                            SyncManager.SyncService.GOOGLE_DRIVE.value to stringResource(SYMR.strings.google_drive),
+                        ),
+                        onValueChanged = { true },
+                    ),
+                ),
+            ),
+        ) + getSyncServicePreferences(syncPreferences, syncService)
+    }
+
+    @Composable
+    private fun getSyncServicePreferences(syncPreferences: SyncPreferences, syncService: Int): List<Preference> {
+        val syncServiceType = SyncManager.SyncService.fromInt(syncService)
+
+        val basePreferences = getBasePreferences(syncServiceType, syncPreferences)
+
+        return if (syncServiceType != SyncManager.SyncService.NONE) {
+            basePreferences + getAdditionalPreferences(syncPreferences)
+        } else {
+            basePreferences
+        }
+    }
+
+    @Composable
+    private fun getBasePreferences(
+        syncServiceType: SyncManager.SyncService,
+        syncPreferences: SyncPreferences,
+    ): List<Preference> {
+        return when (syncServiceType) {
+            SyncManager.SyncService.NONE -> emptyList()
+            SyncManager.SyncService.SYNCYOMI -> getSelfHostPreferences(syncPreferences)
+            SyncManager.SyncService.GOOGLE_DRIVE -> getGoogleDrivePreferences()
+        }
+    }
+
+    @Composable
+    private fun getAdditionalPreferences(syncPreferences: SyncPreferences): List<Preference> {
+        return listOf(getSyncNowPref(), getAutomaticSyncGroup(syncPreferences))
+    }
+
+    @Composable
+    private fun getGoogleDrivePreferences(): List<Preference> {
+        val context = LocalContext.current
+        val googleDriveSync = Injekt.get<GoogleDriveService>()
+        return listOf(
+            Preference.PreferenceItem.TextPreference(
+                title = stringResource(SYMR.strings.pref_google_drive_sign_in),
+                onClick = {
+                    val intent = googleDriveSync.getSignInIntent()
+                    context.startActivity(intent)
+                },
+            ),
+            getGoogleDrivePurge(),
+        )
+    }
+
+    @Composable
+    private fun getGoogleDrivePurge(): Preference.PreferenceItem.TextPreference {
+        val scope = rememberCoroutineScope()
+        val context = LocalContext.current
+        val googleDriveSync = remember { GoogleDriveSyncService(context) }
+        var showPurgeDialog by remember { mutableStateOf(false) }
+
+        if (showPurgeDialog) {
+            PurgeConfirmationDialog(
+                onConfirm = {
+                    showPurgeDialog = false
+                    scope.launch {
+                        val result = googleDriveSync.deleteSyncDataFromGoogleDrive()
+                        when (result) {
+                            GoogleDriveSyncService.DeleteSyncDataStatus.NOT_INITIALIZED -> context.toast(
+                                SYMR.strings.google_drive_not_signed_in,
+                                duration = 5000,
+                            )
+                            GoogleDriveSyncService.DeleteSyncDataStatus.NO_FILES -> context.toast(
+                                SYMR.strings.google_drive_sync_data_not_found,
+                                duration = 5000,
+                            )
+                            GoogleDriveSyncService.DeleteSyncDataStatus.SUCCESS -> context.toast(
+                                SYMR.strings.google_drive_sync_data_purged,
+                                duration = 5000,
+                            )
+                            GoogleDriveSyncService.DeleteSyncDataStatus.ERROR -> context.toast(
+                                SYMR.strings.google_drive_sync_data_purge_error,
+                                duration = 10000,
+                            )
+                        }
+                    }
+                },
+                onDismissRequest = { showPurgeDialog = false },
+            )
+        }
+
+        return Preference.PreferenceItem.TextPreference(
+            title = stringResource(SYMR.strings.pref_google_drive_purge_sync_data),
+            onClick = { showPurgeDialog = true },
+        )
+    }
+
+    @Composable
+    private fun PurgeConfirmationDialog(
+        onConfirm: () -> Unit,
+        onDismissRequest: () -> Unit,
+    ) {
+        AlertDialog(
+            onDismissRequest = onDismissRequest,
+            title = { Text(text = stringResource(SYMR.strings.pref_purge_confirmation_title)) },
+            text = { Text(text = stringResource(SYMR.strings.pref_purge_confirmation_message)) },
+            dismissButton = {
+                TextButton(onClick = onDismissRequest) {
+                    Text(text = stringResource(MR.strings.action_cancel))
+                }
+            },
+            confirmButton = {
+                TextButton(onClick = onConfirm) {
+                    Text(text = stringResource(MR.strings.action_ok))
+                }
+            },
+        )
+    }
+
+    @Composable
+    private fun getSelfHostPreferences(syncPreferences: SyncPreferences): List<Preference> {
+        val scope = rememberCoroutineScope()
+        return listOf(
+            Preference.PreferenceItem.EditTextPreference(
+                title = stringResource(SYMR.strings.pref_sync_host),
+                subtitle = stringResource(SYMR.strings.pref_sync_host_summ),
+                pref = syncPreferences.clientHost(),
+                onValueChanged = { newValue ->
+                    scope.launch {
+                        // Trim spaces at the beginning and end, then remove trailing slash if present
+                        val trimmedValue = newValue.trim()
+                        val modifiedValue = trimmedValue.trimEnd { it == '/' }
+                        syncPreferences.clientHost().set(modifiedValue)
+                    }
+                    true
+                },
+            ),
+            Preference.PreferenceItem.EditTextPreference(
+                title = stringResource(SYMR.strings.pref_sync_api_key),
+                subtitle = stringResource(SYMR.strings.pref_sync_api_key_summ),
+                pref = syncPreferences.clientAPIKey(),
+            ),
+        )
+    }
+
+    @Composable
+    private fun getSyncNowPref(): Preference.PreferenceGroup {
+        val navigator = LocalNavigator.currentOrThrow
+        return Preference.PreferenceGroup(
+            title = stringResource(SYMR.strings.pref_sync_now_group_title),
+            preferenceItems = persistentListOf(
+                getSyncOptionsPref(),
+                Preference.PreferenceItem.TextPreference(
+                    title = stringResource(SYMR.strings.pref_sync_now),
+                    subtitle = stringResource(SYMR.strings.pref_sync_now_subtitle),
+                    onClick = {
+                        navigator.push(SyncSettingsSelector())
+                    },
+                ),
+            ),
+        )
+    }
+
+    @Composable
+    private fun getSyncOptionsPref(): Preference.PreferenceItem.TextPreference {
+        val navigator = LocalNavigator.currentOrThrow
+        return Preference.PreferenceItem.TextPreference(
+            title = stringResource(SYMR.strings.pref_sync_options),
+            subtitle = stringResource(SYMR.strings.pref_sync_options_summ),
+            onClick = { navigator.push(SyncTriggerOptionsScreen()) },
+        )
+    }
+
+    @Composable
+    private fun getAutomaticSyncGroup(syncPreferences: SyncPreferences): Preference.PreferenceGroup {
+        val context = LocalContext.current
+        val syncIntervalPref = syncPreferences.syncInterval()
+        val lastSync by syncPreferences.lastSyncTimestamp().collectAsState()
+
+        return Preference.PreferenceGroup(
+            title = stringResource(SYMR.strings.pref_sync_automatic_category),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.ListPreference(
+                    pref = syncIntervalPref,
+                    title = stringResource(SYMR.strings.pref_sync_interval),
+                    entries = persistentMapOf(
+                        0 to stringResource(MR.strings.off),
+                        30 to stringResource(SYMR.strings.update_30min),
+                        60 to stringResource(SYMR.strings.update_1hour),
+                        180 to stringResource(SYMR.strings.update_3hour),
+                        360 to stringResource(MR.strings.update_6hour),
+                        720 to stringResource(MR.strings.update_12hour),
+                        1440 to stringResource(MR.strings.update_24hour),
+                        2880 to stringResource(MR.strings.update_48hour),
+                        10080 to stringResource(MR.strings.update_weekly),
+                    ),
+                    onValueChanged = {
+                        SyncDataJob.setupTask(context, it)
+                        true
+                    },
+                ),
+                Preference.PreferenceItem.InfoPreference(
+                    stringResource(SYMR.strings.last_synchronization, relativeTimeSpanString(lastSync)),
+                ),
+            ),
+        )
+    }
 }
@@ -235,11 +235,13 @@ object SettingsLibraryScreen : SearchableSettings {
                    pref = libraryPreferences.newShowUpdatesCount(),
                    title = stringResource(MR.strings.pref_library_update_show_tab_badge),
                ),
+                // SY -->
                Preference.PreferenceItem.SwitchPreference(
                    pref = libraryPreferences.libraryReadDuplicateChapters(),
-                    title = stringResource(MR.strings.pref_library_mark_duplicate_chapters),
-                    subtitle = stringResource(MR.strings.pref_library_mark_duplicate_chapters_summary),
+                    title = stringResource(SYMR.strings.pref_library_mark_duplicate_chapters),
+                    subtitle = stringResource(SYMR.strings.pref_library_mark_duplicate_chapters_summary),
                ),
+                // SY <--
            ),
        )
    }
@@ -35,6 +35,7 @@ object SettingsReaderScreen : SearchableSettings {
        // SY -->
        val forceHorizontalSeekbar by readerPref.forceHorizontalSeekbar().collectAsState()
        // SY <--
+
        return listOf(
            Preference.PreferenceItem.ListPreference(
                pref = readerPref.defaultReadingMode(),
@@ -81,12 +82,6 @@ object SettingsReaderScreen : SearchableSettings {
                enabled = !forceHorizontalSeekbar,
            ),
            // SY <--
-            Preference.PreferenceItem.SwitchPreference(
-                pref = readerPref.trueColor(),
-                title = stringResource(MR.strings.pref_true_color),
-                subtitle = stringResource(MR.strings.pref_true_color_summary),
-                enabled = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O,
-            ),
            /* SY -->
            Preference.PreferenceItem.SwitchPreference(
                pref = readerPref.pageTransitions(),
@@ -178,11 +173,13 @@ object SettingsReaderScreen : SearchableSettings {
                    pref = readerPreferences.skipDupe(),
                    title = stringResource(MR.strings.pref_skip_dupe_chapters),
                ),
+                // SY -->
                Preference.PreferenceItem.SwitchPreference(
                    pref = readerPreferences.markReadDupe(),
-                    title = stringResource(MR.strings.pref_mark_read_dupe_chapters),
-                    subtitle = stringResource(MR.strings.pref_mark_read_dupe_chapters_summary),
+                    title = stringResource(SYMR.strings.pref_mark_read_dupe_chapters),
+                    subtitle = stringResource(SYMR.strings.pref_mark_read_dupe_chapters_summary),
                ),
+                // SY <--
                Preference.PreferenceItem.SwitchPreference(
                    pref = readerPreferences.alwaysShowChapterTransition(),
                    title = stringResource(MR.strings.pref_always_show_chapter_transition),
@@ -570,10 +567,14 @@ object SettingsReaderScreen : SearchableSettings {
                        .toMap()
                        .toImmutableMap(),
                ),
-                Preference.PreferenceItem.SwitchPreference(
-                    pref = readerPreferences.cacheArchiveMangaOnDisk(),
-                    title = stringResource(SYMR.strings.cache_archived_manga_to_disk),
-                    subtitle = stringResource(SYMR.strings.cache_archived_manga_to_disk_subtitle),
+                Preference.PreferenceItem.ListPreference(
+                    pref = readerPreferences.archiveReaderMode(),
+                    title = stringResource(SYMR.strings.pref_archive_reader_mode),
+                    subtitle = stringResource(SYMR.strings.pref_archive_reader_mode_summary),
+                    entries = ReaderPreferences.archiveModeTypes
+                        .mapIndexed { index, it -> index to stringResource(it) }
+                        .toMap()
+                        .toImmutableMap(),
                ),
            ),
        )
@@ -56,10 +56,9 @@ import tachiyomi.presentation.core.icons.Reddit
 import tachiyomi.presentation.core.icons.X
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
+import java.time.Instant
 import java.time.LocalDateTime
 import java.time.ZoneId
-import java.time.format.DateTimeFormatter
-import java.util.Locale

 object AboutScreen : Screen() {

@@ -293,11 +292,15 @@ object AboutScreen : Screen() {

    internal fun getFormattedBuildTime(): String {
        return try {
-            val df = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm'Z'", Locale.US)
-                .withZone(ZoneId.of("UTC"))
-            val buildTime = LocalDateTime.from(df.parse(BuildConfig.BUILD_TIME))
-
-            buildTime!!.toDateTimestampString(UiPreferences.dateFormat(Injekt.get<UiPreferences>().dateFormat().get()))
+            LocalDateTime.ofInstant(
+                Instant.parse(BuildConfig.BUILD_TIME),
+                ZoneId.systemDefault(),
+            )
+                .toDateTimestampString(
+                    UiPreferences.dateFormat(
+                        Injekt.get<UiPreferences>().dateFormat().get(),
+                    ),
+                )
        } catch (e: Exception) {
            BuildConfig.BUILD_TIME
        }
@@ -32,12 +32,13 @@ class OpenSourceLicensesScreen : Screen() {
                    .fillMaxSize(),
                contentPadding = contentPadding,
                onLibraryClick = {
-                    val libraryLicenseScreen = OpenSourceLibraryLicenseScreen(
-                        name = it.library.name,
-                        website = it.library.website,
-                        license = it.library.licenses.firstOrNull()?.htmlReadyLicenseContent.orEmpty(),
+                    navigator.push(
+                        OpenSourceLibraryLicenseScreen(
+                            name = it.name,
+                            website = it.website,
+                            license = it.licenses.firstOrNull()?.htmlReadyLicenseContent.orEmpty(),
+                        )
                    )
-                    navigator.push(libraryLicenseScreen)
                },
            )
        }
@@ -8,11 +8,14 @@ import androidx.compose.ui.platform.LocalContext
 import cafe.adriel.voyager.core.model.rememberScreenModel
 import cafe.adriel.voyager.navigator.LocalNavigator
 import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.more.settings.screen.browse.components.ExtensionRepoConflictDialog
 import eu.kanade.presentation.more.settings.screen.browse.components.ExtensionRepoCreateDialog
 import eu.kanade.presentation.more.settings.screen.browse.components.ExtensionRepoDeleteDialog
 import eu.kanade.presentation.more.settings.screen.browse.components.ExtensionReposScreen
 import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.util.system.openInBrowser
 import eu.kanade.tachiyomi.util.system.toast
+import kotlinx.collections.immutable.toImmutableSet
 import kotlinx.coroutines.flow.collectLatest
 import tachiyomi.presentation.core.screens.LoadingScreen

@@ -42,17 +45,19 @@ class ExtensionReposScreen(
        ExtensionReposScreen(
            state = successState,
            onClickCreate = { screenModel.showDialog(RepoDialog.Create) },
+            onOpenWebsite = { context.openInBrowser(it.website) },
            onClickDelete = { screenModel.showDialog(RepoDialog.Delete(it)) },
+            onClickRefresh = { screenModel.refreshRepos() },
            navigateUp = navigator::pop,
        )

        when (val dialog = successState.dialog) {
            null -> {}
-            RepoDialog.Create -> {
+            is RepoDialog.Create -> {
                ExtensionRepoCreateDialog(
                    onDismissRequest = screenModel::dismissDialog,
                    onCreate = { screenModel.createRepo(it) },
-                    repos = successState.repos,
+                    repoUrls = successState.repos.map { it.baseUrl }.toImmutableSet(),
                )
            }
            is RepoDialog.Delete -> {
@@ -62,6 +67,15 @@ class ExtensionReposScreen(
                    repo = dialog.repo,
                )
            }
+
+            is RepoDialog.Conflict -> {
+                ExtensionRepoConflictDialog(
+                    onDismissRequest = screenModel::dismissDialog,
+                    onMigrate = { screenModel.replaceRepo(dialog.newRepo) },
+                    oldRepo = dialog.oldRepo,
+                    newRepo = dialog.newRepo,
+                )
+            }
        }

        LaunchedEffect(Unit) {
@@ -4,24 +4,29 @@ import androidx.compose.runtime.Immutable
 import cafe.adriel.voyager.core.model.StateScreenModel
 import cafe.adriel.voyager.core.model.screenModelScope
 import dev.icerock.moko.resources.StringResource
-import eu.kanade.domain.extension.interactor.CreateExtensionRepo
-import eu.kanade.domain.extension.interactor.DeleteExtensionRepo
-import eu.kanade.domain.extension.interactor.GetExtensionRepos
 import kotlinx.collections.immutable.ImmutableSet
 import kotlinx.collections.immutable.toImmutableSet
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.flow.update
+import mihon.domain.extensionrepo.interactor.CreateExtensionRepo
+import mihon.domain.extensionrepo.interactor.DeleteExtensionRepo
+import mihon.domain.extensionrepo.interactor.GetExtensionRepo
+import mihon.domain.extensionrepo.interactor.ReplaceExtensionRepo
+import mihon.domain.extensionrepo.interactor.UpdateExtensionRepo
+import mihon.domain.extensionrepo.model.ExtensionRepo
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.i18n.MR
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get

 class ExtensionReposScreenModel(
-    private val getExtensionRepos: GetExtensionRepos = Injekt.get(),
+    private val getExtensionRepo: GetExtensionRepo = Injekt.get(),
    private val createExtensionRepo: CreateExtensionRepo = Injekt.get(),
    private val deleteExtensionRepo: DeleteExtensionRepo = Injekt.get(),
+    private val replaceExtensionRepo: ReplaceExtensionRepo = Injekt.get(),
+    private val updateExtensionRepo: UpdateExtensionRepo = Injekt.get(),
 ) : StateScreenModel<RepoScreenState>(RepoScreenState.Loading) {

    private val _events: Channel<RepoEvent> = Channel(Int.MAX_VALUE)
@@ -29,7 +34,7 @@ class ExtensionReposScreenModel(

    init {
        screenModelScope.launchIO {
-            getExtensionRepos.subscribe()
+            getExtensionRepo.subscribeAll()
                .collectLatest { repos ->
                    mutableState.update {
                        RepoScreenState.Success(
@@ -43,25 +48,51 @@ class ExtensionReposScreenModel(
    /**
     * Creates and adds a new repo to the database.
     *
-     * @param name The name of the repo to create.
+     * @param baseUrl The baseUrl of the repo to create.
     */
-    fun createRepo(name: String) {
+    fun createRepo(baseUrl: String) {
        screenModelScope.launchIO {
-            when (createExtensionRepo.await(name)) {
-                is CreateExtensionRepo.Result.InvalidUrl -> _events.send(RepoEvent.InvalidUrl)
+            when (val result = createExtensionRepo.await(baseUrl)) {
+                CreateExtensionRepo.Result.InvalidUrl -> _events.send(RepoEvent.InvalidUrl)
+                CreateExtensionRepo.Result.RepoAlreadyExists -> _events.send(RepoEvent.RepoAlreadyExists)
+                is CreateExtensionRepo.Result.DuplicateFingerprint -> {
+                    showDialog(RepoDialog.Conflict(result.oldRepo, result.newRepo))
+                }
                else -> {}
            }
        }
    }

    /**
-     * Deletes the given repo from the database.
+     * Inserts a repo to the database, replace a matching repo with the same signing key fingerprint if found.
     *
-     * @param repo The repo to delete.
+     * @param newRepo The repo to insert
     */
-    fun deleteRepo(repo: String) {
+    fun replaceRepo(newRepo: ExtensionRepo) {
        screenModelScope.launchIO {
-            deleteExtensionRepo.await(repo)
+            replaceExtensionRepo.await(newRepo)
+        }
+    }
+
+    /**
+     * Refreshes information for each repository.
+     */
+    fun refreshRepos() {
+        val status = state.value
+
+        if (status is RepoScreenState.Success) {
+            screenModelScope.launchIO {
+                updateExtensionRepo.awaitAll()
+            }
+        }
+    }
+
+    /**
+     * Deletes the given repo from the database
+     */
+    fun deleteRepo(baseUrl: String) {
+        screenModelScope.launchIO {
+            deleteExtensionRepo.await(baseUrl)
        }
    }

@@ -87,11 +118,13 @@ class ExtensionReposScreenModel(
 sealed class RepoEvent {
    sealed class LocalizedMessage(val stringRes: StringResource) : RepoEvent()
    data object InvalidUrl : LocalizedMessage(MR.strings.invalid_repo_name)
+    data object RepoAlreadyExists : LocalizedMessage(MR.strings.error_repo_exists)
 }

 sealed class RepoDialog {
    data object Create : RepoDialog()
    data class Delete(val repo: String) : RepoDialog()
+    data class Conflict(val oldRepo: ExtensionRepo, val newRepo: ExtensionRepo) : RepoDialog()
 }

 sealed class RepoScreenState {
@@ -101,7 +134,8 @@ sealed class RepoScreenState {

    @Immutable
    data class Success(
-        val repos: ImmutableSet<String>,
+        val repos: ImmutableSet<ExtensionRepo>,
+        val oldRepos: ImmutableSet<String>? = null,
        val dialog: RepoDialog? = null,
    ) : RepoScreenState() {

@@ -9,6 +9,7 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.outlined.Label
+import androidx.compose.material.icons.automirrored.outlined.OpenInNew
 import androidx.compose.material.icons.outlined.ContentCopy
 import androidx.compose.material.icons.outlined.Delete
 import androidx.compose.material3.ElevatedCard
@@ -22,15 +23,17 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import eu.kanade.tachiyomi.util.system.copyToClipboard
 import kotlinx.collections.immutable.ImmutableSet
+import mihon.domain.extensionrepo.model.ExtensionRepo
 import tachiyomi.i18n.MR
 import tachiyomi.presentation.core.components.material.padding
 import tachiyomi.presentation.core.i18n.stringResource

@Composable
 fun ExtensionReposContent(
-    repos: ImmutableSet<String>,
+    repos: ImmutableSet<ExtensionRepo>,
    lazyListState: LazyListState,
    paddingValues: PaddingValues,
+    onOpenWebsite: (ExtensionRepo) -> Unit,
    onClickDelete: (String) -> Unit,
    modifier: Modifier = Modifier,
 ) {
@@ -45,7 +48,8 @@ fun ExtensionReposContent(
                ExtensionRepoListItem(
                    modifier = Modifier.animateItemPlacement(),
                    repo = it,
-                    onDelete = { onClickDelete(it) },
+                    onOpenWebsite = { onOpenWebsite(it) },
+                    onDelete = { onClickDelete(it.baseUrl) },
                )
            }
        }
@@ -54,7 +58,8 @@ fun ExtensionReposContent(

@Composable
 private fun ExtensionRepoListItem(
-    repo: String,
+    repo: ExtensionRepo,
+    onOpenWebsite: () -> Unit,
    onDelete: () -> Unit,
    modifier: Modifier = Modifier,
 ) {
@@ -74,16 +79,27 @@ private fun ExtensionRepoListItem(
            verticalAlignment = Alignment.CenterVertically,
        ) {
            Icon(imageVector = Icons.AutoMirrored.Outlined.Label, contentDescription = null)
-            Text(text = repo, modifier = Modifier.padding(start = MaterialTheme.padding.medium))
+            Text(
+                text = repo.name,
+                modifier = Modifier.padding(start = MaterialTheme.padding.medium),
+                style = MaterialTheme.typography.titleMedium,
+            )
        }

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.End,
        ) {
+            IconButton(onClick = onOpenWebsite) {
+                Icon(
+                    imageVector = Icons.AutoMirrored.Outlined.OpenInNew,
+                    contentDescription = stringResource(MR.strings.action_open_in_browser),
+                )
+            }
+
            IconButton(
                onClick = {
-                    val url = "$repo/index.min.json"
+                    val url = "${repo.baseUrl}/index.min.json"
                    context.copyToClipboard(url, url)
                },
            ) {
@@ -1,6 +1,7 @@
 package eu.kanade.presentation.more.settings.screen.browse.components

 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
@@ -14,8 +15,10 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.text.input.KeyboardType
 import kotlinx.collections.immutable.ImmutableSet
 import kotlinx.coroutines.delay
+import mihon.domain.extensionrepo.model.ExtensionRepo
 import tachiyomi.i18n.MR
 import tachiyomi.presentation.core.i18n.stringResource
 import kotlin.time.Duration.Companion.seconds
@@ -24,12 +27,12 @@ import kotlin.time.Duration.Companion.seconds
 fun ExtensionRepoCreateDialog(
    onDismissRequest: () -> Unit,
    onCreate: (String) -> Unit,
-    repos: ImmutableSet<String>,
+    repoUrls: ImmutableSet<String>,
 ) {
    var name by remember { mutableStateOf("") }

    val focusRequester = remember { FocusRequester() }
-    val nameAlreadyExists = remember(name) { repos.contains(name) }
+    val nameAlreadyExists = remember(name) { repoUrls.contains(name) }

    AlertDialog(
        onDismissRequest = onDismissRequest,
@@ -73,6 +76,7 @@ fun ExtensionRepoCreateDialog(
                        Text(text = stringResource(msgRes))
                    },
                    isError = name.isNotEmpty() && nameAlreadyExists,
+                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri),
                    singleLine = true,
                )
            }
@@ -115,3 +119,36 @@ fun ExtensionRepoDeleteDialog(
        },
    )
 }
+
+@Composable
+fun ExtensionRepoConflictDialog(
+    oldRepo: ExtensionRepo,
+    newRepo: ExtensionRepo,
+    onDismissRequest: () -> Unit,
+    onMigrate: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismissRequest,
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    onMigrate()
+                    onDismissRequest()
+                },
+            ) {
+                Text(text = stringResource(MR.strings.action_replace_repo))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismissRequest) {
+                Text(text = stringResource(MR.strings.action_cancel))
+            }
+        },
+        title = {
+            Text(text = stringResource(MR.strings.action_replace_repo_title))
+        },
+        text = {
+            Text(text = stringResource(MR.strings.action_replace_repo_message, newRepo.name, oldRepo.name))
+        },
+    )
+}
@@ -5,12 +5,17 @@ package eu.kanade.presentation.more.settings.screen.browse.components
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Refresh
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import eu.kanade.presentation.category.components.CategoryFloatingActionButton
 import eu.kanade.presentation.components.AppBar
 import eu.kanade.presentation.more.settings.screen.browse.RepoScreenState
+import mihon.domain.extensionrepo.model.ExtensionRepo
 import tachiyomi.i18n.MR
 import tachiyomi.presentation.core.components.material.Scaffold
 import tachiyomi.presentation.core.components.material.padding
@@ -23,7 +28,9 @@ import tachiyomi.presentation.core.util.plus
 fun ExtensionReposScreen(
    state: RepoScreenState.Success,
    onClickCreate: () -> Unit,
+    onOpenWebsite: (ExtensionRepo) -> Unit,
    onClickDelete: (String) -> Unit,
+    onClickRefresh: () -> Unit,
    navigateUp: () -> Unit,
 ) {
    val lazyListState = rememberLazyListState()
@@ -33,6 +40,14 @@ fun ExtensionReposScreen(
                navigateUp = navigateUp,
                title = stringResource(MR.strings.label_extension_repos),
                scrollBehavior = scrollBehavior,
+                actions = {
+                    IconButton(onClick = onClickRefresh) {
+                        Icon(
+                            imageVector = Icons.Outlined.Refresh,
+                            contentDescription = stringResource(resource = MR.strings.action_webview_refresh),
+                        )
+                    }
+                },
            )
        },
        floatingActionButton = {
@@ -55,6 +70,7 @@ fun ExtensionReposScreen(
            lazyListState = lazyListState,
            paddingValues = paddingValues + topSmallPaddingValues +
                PaddingValues(horizontal = MaterialTheme.padding.medium),
+            onOpenWebsite = onOpenWebsite,
            onClickDelete = onClickDelete,
        )
    }
@@ -0,0 +1,153 @@
+package eu.kanade.presentation.more.settings.screen.data
+
+import android.content.Context
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.platform.LocalContext
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.domain.sync.SyncPreferences
+import eu.kanade.domain.sync.models.SyncSettings
+import eu.kanade.presentation.components.AppBar
+import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.data.backup.create.BackupOptions
+import eu.kanade.tachiyomi.data.sync.SyncDataJob
+import eu.kanade.tachiyomi.util.system.toast
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.coroutines.flow.update
+import tachiyomi.i18n.MR
+import tachiyomi.i18n.sy.SYMR
+import tachiyomi.presentation.core.components.LabeledCheckbox
+import tachiyomi.presentation.core.components.LazyColumnWithAction
+import tachiyomi.presentation.core.components.SectionCard
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.i18n.stringResource
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class SyncSettingsSelector : Screen() {
+    @Composable
+    override fun Content() {
+        val context = LocalContext.current
+        val navigator = LocalNavigator.currentOrThrow
+        val model = rememberScreenModel { SyncSettingsSelectorModel() }
+        val state by model.state.collectAsState()
+
+        Scaffold(
+            topBar = {
+                AppBar(
+                    title = stringResource(SYMR.strings.pref_choose_what_to_sync),
+                    navigateUp = navigator::pop,
+                    scrollBehavior = it,
+                )
+            },
+        ) { contentPadding ->
+            LazyColumnWithAction(
+                contentPadding = contentPadding,
+                actionLabel = stringResource(SYMR.strings.label_sync),
+                actionEnabled = state.options.anyEnabled(),
+                onClickAction = {
+                    if (!SyncDataJob.isRunning(context)) {
+                        model.syncNow(context)
+                        navigator.pop()
+                    } else {
+                        context.toast(SYMR.strings.sync_in_progress)
+                    }
+                },
+            ) {
+                item {
+                    SectionCard(MR.strings.label_library) {
+                        Options(BackupOptions.libraryOptions, state, model)
+                    }
+                }
+
+                item {
+                    SectionCard(MR.strings.label_settings) {
+                        Options(BackupOptions.settingsOptions, state, model)
+                    }
+                }
+            }
+        }
+    }
+
+    @Composable
+    private fun Options(
+        options: ImmutableList<BackupOptions.Entry>,
+        state: SyncSettingsSelectorModel.State,
+        model: SyncSettingsSelectorModel,
+    ) {
+        options.forEach { option ->
+            LabeledCheckbox(
+                label = stringResource(option.label),
+                checked = option.getter(state.options),
+                onCheckedChange = {
+                    model.toggle(option.setter, it)
+                },
+                enabled = option.enabled(state.options),
+            )
+        }
+    }
+}
+
+private class SyncSettingsSelectorModel(
+    val syncPreferences: SyncPreferences = Injekt.get(),
+) : StateScreenModel<SyncSettingsSelectorModel.State>(
+    State(syncOptionsToBackupOptions(syncPreferences.getSyncSettings())),
+) {
+    fun toggle(setter: (BackupOptions, Boolean) -> BackupOptions, enabled: Boolean) {
+        mutableState.update {
+            val updatedOptions = setter(it.options, enabled)
+            syncPreferences.setSyncSettings(backupOptionsToSyncOptions(updatedOptions))
+            it.copy(options = updatedOptions)
+        }
+    }
+
+    fun syncNow(context: Context) {
+        SyncDataJob.startNow(context)
+    }
+
+    @Immutable
+    data class State(
+        val options: BackupOptions = BackupOptions(),
+    ) companion object {
+        private fun syncOptionsToBackupOptions(syncSettings: SyncSettings): BackupOptions {
+            return BackupOptions(
+                libraryEntries = syncSettings.libraryEntries,
+                categories = syncSettings.categories,
+                chapters = syncSettings.chapters,
+                tracking = syncSettings.tracking,
+                history = syncSettings.history,
+                appSettings = syncSettings.appSettings,
+                sourceSettings = syncSettings.sourceSettings,
+                privateSettings = syncSettings.privateSettings,
+
+                // SY -->
+                customInfo = syncSettings.customInfo,
+                readEntries = syncSettings.readEntries,
+                // SY <--
+            )
+        }
+
+        private fun backupOptionsToSyncOptions(backupOptions: BackupOptions): SyncSettings {
+            return SyncSettings(
+                libraryEntries = backupOptions.libraryEntries,
+                categories = backupOptions.categories,
+                chapters = backupOptions.chapters,
+                tracking = backupOptions.tracking,
+                history = backupOptions.history,
+                appSettings = backupOptions.appSettings,
+                sourceSettings = backupOptions.sourceSettings,
+                privateSettings = backupOptions.privateSettings,
+
+                // SY -->
+                customInfo = backupOptions.customInfo,
+                readEntries = backupOptions.readEntries,
+                // SY <--
+            )
+        }
+    }
+}
@@ -0,0 +1,102 @@
+package eu.kanade.presentation.more.settings.screen.data
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.domain.sync.SyncPreferences
+import eu.kanade.presentation.components.AppBar
+import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.data.sync.models.SyncTriggerOptions
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.coroutines.flow.update
+import tachiyomi.i18n.MR
+import tachiyomi.i18n.sy.SYMR
+import tachiyomi.presentation.core.components.LabeledCheckbox
+import tachiyomi.presentation.core.components.LazyColumnWithAction
+import tachiyomi.presentation.core.components.SectionCard
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.i18n.stringResource
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class SyncTriggerOptionsScreen : Screen() {
+
+    @Composable
+    override fun Content() {
+        val navigator = LocalNavigator.currentOrThrow
+        val model = rememberScreenModel { SyncOptionsScreenModel() }
+        val state by model.state.collectAsState()
+
+        Scaffold(
+            topBar = {
+                AppBar(
+                    title = stringResource(SYMR.strings.pref_sync_options),
+                    navigateUp = navigator::pop,
+                    scrollBehavior = it,
+                )
+            },
+        ) { contentPadding ->
+            LazyColumnWithAction(
+                contentPadding = contentPadding,
+                actionLabel = stringResource(MR.strings.action_save),
+                actionEnabled = true,
+                onClickAction = {
+                    navigator.pop()
+                },
+            ) {
+                item {
+                    SectionCard(SYMR.strings.label_triggers) {
+                        Options(SyncTriggerOptions.mainOptions, state, model)
+                    }
+                }
+            }
+        }
+    }
+
+    @Composable
+    private fun Options(
+        options: ImmutableList<SyncTriggerOptions.Entry>,
+        state: SyncOptionsScreenModel.State,
+        model: SyncOptionsScreenModel,
+    ) {
+        options.forEach { option ->
+            LabeledCheckbox(
+                label = stringResource(option.label),
+                checked = option.getter(state.options),
+                onCheckedChange = {
+                    model.toggle(option.setter, it)
+                },
+                enabled = option.enabled(state.options),
+            )
+        }
+    }
+}
+
+private class SyncOptionsScreenModel(
+    val syncPreferences: SyncPreferences = Injekt.get(),
+) : StateScreenModel<SyncOptionsScreenModel.State>(
+    State(
+        syncPreferences.getSyncTriggerOptions(),
+    ),
+) {
+
+    fun toggle(setter: (SyncTriggerOptions, Boolean) -> SyncTriggerOptions, enabled: Boolean) {
+        mutableState.update {
+            val updatedTriggerOptions = setter(it.options, enabled)
+            syncPreferences.setSyncTriggerOptions(updatedTriggerOptions)
+            it.copy(
+                options = updatedTriggerOptions,
+            )
+        }
+    }
+
+    @Immutable
+    data class State(
+        val options: SyncTriggerOptions = SyncTriggerOptions(),
+    )
+}
@@ -4,6 +4,7 @@ import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.CalendarMonth
 import androidx.compose.material.icons.outlined.FlipToBack
 import androidx.compose.material.icons.outlined.Refresh
 import androidx.compose.material.icons.outlined.SelectAll
@@ -50,6 +51,7 @@ fun UpdateScreen(
    onClickCover: (UpdatesItem) -> Unit,
    onSelectAll: (Boolean) -> Unit,
    onInvertSelection: () -> Unit,
+    onCalendarClicked: () -> Unit,
    onUpdateLibrary: () -> Boolean,
    onDownloadChapter: (List<UpdatesItem>, ChapterDownloadAction) -> Unit,
    onMultiBookmarkClicked: (List<UpdatesItem>, bookmark: Boolean) -> Unit,
@@ -63,6 +65,7 @@ fun UpdateScreen(
    Scaffold(
        topBar = { scrollBehavior ->
            UpdatesAppBar(
+                onCalendarClicked = { onCalendarClicked() },
                onUpdateLibrary = { onUpdateLibrary() },
                actionModeCounter = state.selected.size,
                onSelectAll = { onSelectAll(true) },
@@ -132,6 +135,7 @@ fun UpdateScreen(

@Composable
 private fun UpdatesAppBar(
+    onCalendarClicked: () -> Unit,
    onUpdateLibrary: () -> Unit,
    // For action mode
    actionModeCounter: Int,
@@ -147,6 +151,11 @@ private fun UpdatesAppBar(
        actions = {
            AppBarActions(
                persistentListOf(
+                    AppBar.Action(
+                        title = stringResource(MR.strings.action_view_upcoming),
+                        icon = Icons.Outlined.CalendarMonth,
+                        onClick = onCalendarClicked,
+                    ),
                    AppBar.Action(
                        title = stringResource(MR.strings.action_update_library),
                        icon = Icons.Outlined.Refresh,
@@ -30,12 +30,12 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Dialog
-import com.google.accompanist.web.AccompanistWebViewClient
-import com.google.accompanist.web.LoadingState
-import com.google.accompanist.web.WebContent
-import com.google.accompanist.web.WebView
-import com.google.accompanist.web.rememberWebViewNavigator
-import com.google.accompanist.web.rememberWebViewState
+import com.kevinnzou.web.AccompanistWebViewClient
+import com.kevinnzou.web.LoadingState
+import com.kevinnzou.web.WebContent
+import com.kevinnzou.web.WebView
+import com.kevinnzou.web.rememberWebViewNavigator
+import com.kevinnzou.web.rememberWebViewState
 import eu.kanade.presentation.components.AppBar
 import eu.kanade.tachiyomi.BuildConfig
 import eu.kanade.tachiyomi.util.system.setDefaultSettings
@@ -28,11 +28,11 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.unit.dp
-import com.google.accompanist.web.AccompanistWebViewClient
-import com.google.accompanist.web.LoadingState
-import com.google.accompanist.web.WebView
-import com.google.accompanist.web.rememberWebViewNavigator
-import com.google.accompanist.web.rememberWebViewState
+import com.kevinnzou.web.AccompanistWebViewClient
+import com.kevinnzou.web.LoadingState
+import com.kevinnzou.web.WebView
+import com.kevinnzou.web.rememberWebViewNavigator
+import com.kevinnzou.web.rememberWebViewState
 import eu.kanade.presentation.components.AppBar
 import eu.kanade.presentation.components.AppBarActions
 import eu.kanade.presentation.components.WarningBanner
@@ -17,8 +17,6 @@ import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.lifecycle.lifecycleScope
 import coil3.ImageLoader
 import coil3.SingletonImageLoader
-import coil3.disk.DiskCache
-import coil3.disk.directory
 import coil3.network.okhttp.OkHttpNetworkFetcherFactory
 import coil3.request.allowRgb565
 import coil3.request.crossfade
@@ -35,10 +33,12 @@ import com.google.firebase.ktx.Firebase
 import eu.kanade.domain.DomainModule
 import eu.kanade.domain.SYDomainModule
 import eu.kanade.domain.base.BasePreferences
+import eu.kanade.domain.sync.SyncPreferences
 import eu.kanade.domain.ui.UiPreferences
 import eu.kanade.domain.ui.model.setAppCompatDelegateThemeMode
 import eu.kanade.tachiyomi.crash.CrashActivity
 import eu.kanade.tachiyomi.crash.GlobalExceptionHandler
+import eu.kanade.tachiyomi.data.coil.BufferedSourceFetcher
 import eu.kanade.tachiyomi.data.coil.MangaCoverFetcher
 import eu.kanade.tachiyomi.data.coil.MangaCoverKeyer
 import eu.kanade.tachiyomi.data.coil.MangaKeyer
@@ -46,6 +46,7 @@ import eu.kanade.tachiyomi.data.coil.PagePreviewFetcher
 import eu.kanade.tachiyomi.data.coil.PagePreviewKeyer
 import eu.kanade.tachiyomi.data.coil.TachiyomiImageDecoder
 import eu.kanade.tachiyomi.data.notification.Notifications
+import eu.kanade.tachiyomi.data.sync.SyncDataJob
 import eu.kanade.tachiyomi.di.AppModule
 import eu.kanade.tachiyomi.di.PreferenceModule
 import eu.kanade.tachiyomi.di.SYPreferenceModule
@@ -70,8 +71,12 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import logcat.LogPriority
 import logcat.LogcatLogger
+import mihon.core.migration.Migrator
+import mihon.core.migration.migrations.migrations
 import org.conscrypt.Conscrypt
 import tachiyomi.core.common.i18n.stringResource
+import tachiyomi.core.common.preference.Preference
+import tachiyomi.core.common.preference.PreferenceStore
 import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.storage.service.StorageManager
 import tachiyomi.i18n.MR
@@ -166,25 +171,50 @@ class App : Application(), DefaultLifecycleObserver, SingletonImageLoader.Factor
        /*if (!LogcatLogger.isInstalled && networkPreferences.verboseLogging().get()) {
            LogcatLogger.install(AndroidLogcatLogger(LogPriority.VERBOSE))
        }*/
+
+        val syncPreferences: SyncPreferences = Injekt.get()
+        val syncTriggerOpt = syncPreferences.getSyncTriggerOptions()
+        if (syncPreferences.isSyncEnabled() && syncTriggerOpt.syncOnAppStart
+        ) {
+            SyncDataJob.startNow(this@App)
+        }
+
+        initializeMigrator()
+    }
+
+    private fun initializeMigrator() {
+        val preferenceStore = Injekt.get<PreferenceStore>()
+        // SY -->
+        val preference = preferenceStore.getInt(Preference.appStateKey("eh_last_version_code"), 0)
+        // SY <--
+        logcat { "Migration from ${preference.get()} to ${BuildConfig.VERSION_CODE}" }
+        Migrator.initialize(
+            old = preference.get(),
+            new = BuildConfig.VERSION_CODE,
+            migrations = migrations,
+            onMigrationComplete = {
+                logcat { "Updating last version to ${BuildConfig.VERSION_CODE}" }
+                preference.set(BuildConfig.VERSION_CODE)
+            },
+        )
    }

    override fun newImageLoader(context: Context): ImageLoader {
        return ImageLoader.Builder(this).apply {
            val callFactoryLazy = lazy { Injekt.get<NetworkHelper>().client }
-            val diskCacheLazy = lazy { CoilDiskCache.get(this@App) }
            components {
                add(OkHttpNetworkFetcherFactory(callFactoryLazy::value))
                add(TachiyomiImageDecoder.Factory())
-                add(MangaCoverFetcher.MangaFactory(callFactoryLazy, diskCacheLazy))
-                add(MangaCoverFetcher.MangaCoverFactory(callFactoryLazy, diskCacheLazy))
+                add(MangaCoverFetcher.MangaFactory(callFactoryLazy))
+                add(MangaCoverFetcher.MangaCoverFactory(callFactoryLazy))
                add(MangaKeyer())
                add(MangaCoverKeyer())
+                add(BufferedSourceFetcher.Factory())
                // SY -->
                add(PagePreviewKeyer())
-                add(PagePreviewFetcher.Factory(callFactoryLazy, diskCacheLazy))
+                add(PagePreviewFetcher.Factory(callFactoryLazy))
                // SY <--
            }
-            diskCache(diskCacheLazy::value)
            crossfade((300 * this@App.animatorDurationScale).toInt())
            allowRgb565(DeviceUtil.isLowRamDevice(this@App))
            if (networkPreferences.verboseLogging().get()) logger(DebugLogger())
@@ -197,6 +227,13 @@ class App : Application(), DefaultLifecycleObserver, SingletonImageLoader.Factor

    override fun onStart(owner: LifecycleOwner) {
        SecureActivityDelegate.onApplicationStart()
+
+        val syncPreferences: SyncPreferences = Injekt.get()
+        val syncTriggerOpt = syncPreferences.getSyncTriggerOptions()
+        if (syncPreferences.isSyncEnabled() && syncTriggerOpt.syncOnAppResume
+        ) {
+            SyncDataJob.startNow(this@App)
+        }
    }

    override fun onStop(owner: LifecycleOwner) {
@@ -230,6 +267,12 @@ class App : Application(), DefaultLifecycleObserver, SingletonImageLoader.Factor
        } catch (e: Exception) {
            logcat(LogPriority.ERROR, e) { "Failed to modify notification channels" }
        }
+
+        val syncPreferences: SyncPreferences = Injekt.get()
+        val syncTriggerOpt = syncPreferences.getSyncTriggerOptions()
+        if (syncPreferences.isSyncEnabled() && syncTriggerOpt.syncOnAppStart) {
+            SyncDataJob.startNow(this@App)
+        }
    }

    // EXH
@@ -327,24 +370,3 @@ class App : Application(), DefaultLifecycleObserver, SingletonImageLoader.Factor
 }

 private const val ACTION_DISABLE_INCOGNITO_MODE = "tachi.action.DISABLE_INCOGNITO_MODE"
-
-/**
- * Direct copy of Coil's internal SingletonDiskCache so that [MangaCoverFetcher] can access it.
- */
-private object CoilDiskCache {
-
-    private const val FOLDER_NAME = "image_cache"
-    private var instance: DiskCache? = null
-
-    @Synchronized
-    fun get(context: Context): DiskCache {
-        return instance ?: run {
-            val safeCacheDir = context.cacheDir.apply { mkdirs() }
-            // Create the singleton disk cache instance.
-            DiskCache.Builder()
-                .directory(safeCacheDir.resolve(FOLDER_NAME))
-                .build()
-                .also { instance = it }
-        }
-    }
-}
@@ -1,464 +0,0 @@
-package eu.kanade.tachiyomi
-
-import android.content.Context
-import androidx.core.content.edit
-import androidx.preference.PreferenceManager
-import eu.kanade.domain.base.BasePreferences
-import eu.kanade.domain.source.service.SourcePreferences
-import eu.kanade.domain.ui.UiPreferences
-import eu.kanade.tachiyomi.core.security.SecurityPreferences
-import eu.kanade.tachiyomi.data.backup.create.BackupCreateJob
-import eu.kanade.tachiyomi.data.library.LibraryUpdateJob
-import eu.kanade.tachiyomi.data.track.TrackerManager
-import eu.kanade.tachiyomi.network.NetworkPreferences
-import eu.kanade.tachiyomi.network.PREF_DOH_CLOUDFLARE
-import eu.kanade.tachiyomi.ui.reader.setting.ReaderOrientation
-import eu.kanade.tachiyomi.ui.reader.setting.ReaderPreferences
-import eu.kanade.tachiyomi.util.system.DeviceUtil
-import eu.kanade.tachiyomi.util.system.toast
-import eu.kanade.tachiyomi.util.system.workManager
-import tachiyomi.core.common.preference.Preference
-import tachiyomi.core.common.preference.PreferenceStore
-import tachiyomi.core.common.preference.TriState
-import tachiyomi.core.common.preference.getAndSet
-import tachiyomi.core.common.preference.getEnum
-import tachiyomi.core.common.preference.minusAssign
-import tachiyomi.core.common.preference.plusAssign
-import tachiyomi.domain.backup.service.BackupPreferences
-import tachiyomi.domain.library.service.LibraryPreferences
-import tachiyomi.domain.library.service.LibraryPreferences.Companion.MANGA_NON_COMPLETED
-import tachiyomi.i18n.MR
-import java.io.File
-
-object Migrations {
-
-    // TODO NATIVE TACHIYOMI MIGRATIONS ARE FUCKED UP DUE TO DIFFERING VERSION NUMBERS
-
-    /**
-     * Performs a migration when the application is updated.
-     *
-     * @return true if a migration is performed, false otherwise.
-     */
-    fun upgrade(
-        context: Context,
-        preferenceStore: PreferenceStore,
-        basePreferences: BasePreferences,
-        uiPreferences: UiPreferences,
-        networkPreferences: NetworkPreferences,
-        sourcePreferences: SourcePreferences,
-        securityPreferences: SecurityPreferences,
-        libraryPreferences: LibraryPreferences,
-        readerPreferences: ReaderPreferences,
-        backupPreferences: BackupPreferences,
-        trackerManager: TrackerManager,
-    ): Boolean {
-        val lastVersionCode = preferenceStore.getInt(Preference.appStateKey("last_version_code"), 0)
-        val oldVersion = lastVersionCode.get()
-        if (oldVersion < BuildConfig.VERSION_CODE) {
-            lastVersionCode.set(BuildConfig.VERSION_CODE)
-
-            // Always set up background tasks to ensure they're running
-            LibraryUpdateJob.setupTask(context)
-            BackupCreateJob.setupTask(context)
-
-            // Fresh install
-            if (oldVersion == 0) {
-                return false
-            }
-
-            val prefs = PreferenceManager.getDefaultSharedPreferences(context)
-
-            if (oldVersion < 15) {
-                // Delete internal chapter cache dir.
-                File(context.cacheDir, "chapter_disk_cache").deleteRecursively()
-            }
-            if (oldVersion < 19) {
-                // Move covers to external files dir.
-                val oldDir = File(context.externalCacheDir, "cover_disk_cache")
-                if (oldDir.exists()) {
-                    val destDir = context.getExternalFilesDir("covers")
-                    if (destDir != null) {
-                        oldDir.listFiles()?.forEach {
-                            it.renameTo(File(destDir, it.name))
-                        }
-                    }
-                }
-            }
-            if (oldVersion < 26) {
-                // Delete external chapter cache dir.
-                val extCache = context.externalCacheDir
-                if (extCache != null) {
-                    val chapterCache = File(extCache, "chapter_disk_cache")
-                    if (chapterCache.exists()) {
-                        chapterCache.deleteRecursively()
-                    }
-                }
-            }
-            if (oldVersion < 44) {
-                // Reset sorting preference if using removed sort by source
-                val oldSortingMode = prefs.getInt(libraryPreferences.sortingMode().key(), 0)
-
-                if (oldSortingMode == 5) { // SOURCE = 5
-                    prefs.edit {
-                        putInt(libraryPreferences.sortingMode().key(), 0) // ALPHABETICAL = 0
-                    }
-                }
-            }
-            if (oldVersion < 52) {
-                // Migrate library filters to tri-state versions
-                fun convertBooleanPrefToTriState(key: String): Int {
-                    val oldPrefValue = prefs.getBoolean(key, false)
-                    return if (oldPrefValue) {
-                        1
-                    } else {
-                        0
-                    }
-                }
-                prefs.edit {
-                    putInt(
-                        libraryPreferences.filterDownloaded().key(),
-                        convertBooleanPrefToTriState("pref_filter_downloaded_key"),
-                    )
-                    remove("pref_filter_downloaded_key")
-
-                    putInt(
-                        libraryPreferences.filterUnread().key(),
-                        convertBooleanPrefToTriState("pref_filter_unread_key"),
-                    )
-                    remove("pref_filter_unread_key")
-
-                    putInt(
-                        libraryPreferences.filterCompleted().key(),
-                        convertBooleanPrefToTriState("pref_filter_completed_key"),
-                    )
-                    remove("pref_filter_completed_key")
-                }
-            }
-            if (oldVersion < 54) {
-                // Force MAL log out due to login flow change
-                // v52: switched from scraping to WebView
-                // v53: switched from WebView to OAuth
-                if (trackerManager.myAnimeList.isLoggedIn) {
-                    trackerManager.myAnimeList.logout()
-                    context.toast(MR.strings.myanimelist_relogin)
-                }
-            }
-            if (oldVersion < 57) {
-                // Migrate DNS over HTTPS setting
-                val wasDohEnabled = prefs.getBoolean("enable_doh", false)
-                if (wasDohEnabled) {
-                    prefs.edit {
-                        putInt(networkPreferences.dohProvider().key(), PREF_DOH_CLOUDFLARE)
-                        remove("enable_doh")
-                    }
-                }
-            }
-            if (oldVersion < 59) {
-                // Reset rotation to Free after replacing Lock
-                if (prefs.contains("pref_rotation_type_key")) {
-                    prefs.edit {
-                        putInt("pref_rotation_type_key", 1)
-                    }
-                }
-            }
-            if (oldVersion < 60) {
-                // Migrate Rotation and Viewer values to default values for viewer_flags
-                val newOrientation = when (prefs.getInt("pref_rotation_type_key", 1)) {
-                    1 -> ReaderOrientation.FREE.flagValue
-                    2 -> ReaderOrientation.PORTRAIT.flagValue
-                    3 -> ReaderOrientation.LANDSCAPE.flagValue
-                    4 -> ReaderOrientation.LOCKED_PORTRAIT.flagValue
-                    5 -> ReaderOrientation.LOCKED_LANDSCAPE.flagValue
-                    else -> ReaderOrientation.FREE.flagValue
-                }
-
-                // Reading mode flag and prefValue is the same value
-                val newReadingMode = prefs.getInt("pref_default_viewer_key", 1)
-
-                prefs.edit {
-                    putInt("pref_default_orientation_type_key", newOrientation)
-                    remove("pref_rotation_type_key")
-                    putInt("pref_default_reading_mode_key", newReadingMode)
-                    remove("pref_default_viewer_key")
-                }
-            }
-            if (oldVersion < 61) {
-                // Handle removed every 1 or 2 hour library updates
-                val updateInterval = libraryPreferences.autoUpdateInterval().get()
-                if (updateInterval == 1 || updateInterval == 2) {
-                    libraryPreferences.autoUpdateInterval().set(3)
-                    LibraryUpdateJob.setupTask(context, 3)
-                }
-            }
-            if (oldVersion < 64) {
-                val oldSortingMode = prefs.getInt(libraryPreferences.sortingMode().key(), 0)
-                val oldSortingDirection = prefs.getBoolean("library_sorting_ascending", true)
-
-                @Suppress("DEPRECATION")
-                val newSortingMode = when (oldSortingMode) {
-                    0 -> "ALPHABETICAL"
-                    1 -> "LAST_READ"
-                    2 -> "LAST_CHECKED"
-                    3 -> "UNREAD"
-                    4 -> "TOTAL_CHAPTERS"
-                    6 -> "LATEST_CHAPTER"
-                    8 -> "DATE_FETCHED"
-                    7 -> "DATE_ADDED"
-                    else -> "ALPHABETICAL"
-                }
-
-                val newSortingDirection = when (oldSortingDirection) {
-                    true -> "ASCENDING"
-                    else -> "DESCENDING"
-                }
-
-                prefs.edit(commit = true) {
-                    remove(libraryPreferences.sortingMode().key())
-                    remove("library_sorting_ascending")
-                }
-
-                prefs.edit {
-                    putString(libraryPreferences.sortingMode().key(), newSortingMode)
-                    putString("library_sorting_ascending", newSortingDirection)
-                }
-            }
-            if (oldVersion < 70) {
-                if (sourcePreferences.enabledLanguages().isSet()) {
-                    sourcePreferences.enabledLanguages() += "all"
-                }
-            }
-            if (oldVersion < 71) {
-                // Handle removed every 3, 4, 6, and 8 hour library updates
-                val updateInterval = libraryPreferences.autoUpdateInterval().get()
-                if (updateInterval in listOf(3, 4, 6, 8)) {
-                    libraryPreferences.autoUpdateInterval().set(12)
-                    LibraryUpdateJob.setupTask(context, 12)
-                }
-            }
-            if (oldVersion < 72) {
-                val oldUpdateOngoingOnly = prefs.getBoolean("pref_update_only_non_completed_key", true)
-                if (!oldUpdateOngoingOnly) {
-                    libraryPreferences.autoUpdateMangaRestrictions() -= MANGA_NON_COMPLETED
-                }
-            }
-            if (oldVersion < 75) {
-                val oldSecureScreen = prefs.getBoolean("secure_screen", false)
-                if (oldSecureScreen) {
-                    securityPreferences.secureScreen().set(SecurityPreferences.SecureScreenMode.ALWAYS)
-                }
-                if (
-                    DeviceUtil.isMiui &&
-                    basePreferences.extensionInstaller().get() == BasePreferences.ExtensionInstaller.PACKAGEINSTALLER
-                ) {
-                    basePreferences.extensionInstaller().set(BasePreferences.ExtensionInstaller.LEGACY)
-                }
-            }
-            if (oldVersion < 77) {
-                val oldReaderTap = prefs.getBoolean("reader_tap", false)
-                if (!oldReaderTap) {
-                    readerPreferences.navigationModePager().set(5)
-                    readerPreferences.navigationModeWebtoon().set(5)
-                }
-            }
-            if (oldVersion < 81) {
-                // Handle renamed enum values
-                prefs.edit {
-                    val newSortingMode = when (
-                        val oldSortingMode = prefs.getString(
-                            libraryPreferences.sortingMode().key(),
-                            "ALPHABETICAL",
-                        )
-                    ) {
-                        "LAST_CHECKED" -> "LAST_MANGA_UPDATE"
-                        "UNREAD" -> "UNREAD_COUNT"
-                        "DATE_FETCHED" -> "CHAPTER_FETCH_DATE"
-                        else -> oldSortingMode
-                    }
-                    putString(libraryPreferences.sortingMode().key(), newSortingMode)
-                }
-            }
-            if (oldVersion < 82) {
-                prefs.edit {
-                    val sort = prefs.getString(libraryPreferences.sortingMode().key(), null) ?: return@edit
-                    val direction = prefs.getString("library_sorting_ascending", "ASCENDING")!!
-                    putString(libraryPreferences.sortingMode().key(), "$sort,$direction")
-                    remove("library_sorting_ascending")
-                }
-            }
-            if (oldVersion < 84) {
-                if (backupPreferences.backupInterval().get() == 0) {
-                    backupPreferences.backupInterval().set(12)
-                    BackupCreateJob.setupTask(context)
-                }
-            }
-            if (oldVersion < 85) {
-                val preferences = listOf(
-                    libraryPreferences.filterChapterByRead(),
-                    libraryPreferences.filterChapterByDownloaded(),
-                    libraryPreferences.filterChapterByBookmarked(),
-                    libraryPreferences.sortChapterBySourceOrNumber(),
-                    libraryPreferences.displayChapterByNameOrNumber(),
-                    libraryPreferences.sortChapterByAscendingOrDescending(),
-                )
-
-                prefs.edit {
-                    preferences.forEach { preference ->
-                        val key = preference.key()
-                        val value = prefs.getInt(key, Int.MIN_VALUE)
-                        if (value == Int.MIN_VALUE) return@forEach
-                        remove(key)
-                        putLong(key, value.toLong())
-                    }
-                }
-            }
-            if (oldVersion < 86) {
-                if (uiPreferences.themeMode().isSet()) {
-                    prefs.edit {
-                        val themeMode = prefs.getString(uiPreferences.themeMode().key(), null) ?: return@edit
-                        putString(uiPreferences.themeMode().key(), themeMode.uppercase())
-                    }
-                }
-            }
-            if (oldVersion < 92) {
-                val trackingQueuePref = context.getSharedPreferences("tracking_queue", Context.MODE_PRIVATE)
-                trackingQueuePref.all.forEach {
-                    val (_, lastChapterRead) = it.value.toString().split(":")
-                    trackingQueuePref.edit {
-                        remove(it.key)
-                        putFloat(it.key, lastChapterRead.toFloat())
-                    }
-                }
-            }
-            if (oldVersion < 96) {
-                LibraryUpdateJob.cancelAllWorks(context)
-                LibraryUpdateJob.setupTask(context)
-            }
-            if (oldVersion < 97) {
-                // Removed background jobs
-                context.workManager.cancelAllWorkByTag("UpdateChecker")
-                context.workManager.cancelAllWorkByTag("ExtensionUpdate")
-                prefs.edit {
-                    remove("automatic_ext_updates")
-                }
-            }
-            if (oldVersion < 99) {
-                val prefKeys = listOf(
-                    "pref_filter_library_downloaded",
-                    "pref_filter_library_unread",
-                    "pref_filter_library_started",
-                    "pref_filter_library_bookmarked",
-                    "pref_filter_library_completed",
-                ) + trackerManager.trackers.map { "pref_filter_library_tracked_${it.id}" }
-
-                prefKeys.forEach { key ->
-                    val pref = preferenceStore.getInt(key, 0)
-                    prefs.edit {
-                        remove(key)
-
-                        val newValue = when (pref.get()) {
-                            1 -> TriState.ENABLED_IS
-                            2 -> TriState.ENABLED_NOT
-                            else -> TriState.DISABLED
-                        }
-
-                        preferenceStore.getEnum("${key}_v2", TriState.DISABLED).set(newValue)
-                    }
-                }
-            }
-            if (oldVersion < 105) {
-                val pref = libraryPreferences.autoUpdateDeviceRestrictions()
-                if (pref.isSet() && "battery_not_low" in pref.get()) {
-                    pref.getAndSet { it - "battery_not_low" }
-                }
-            }
-            if (oldVersion < 106) {
-                val pref = preferenceStore.getInt("relative_time", 7)
-                if (pref.get() == 0) {
-                    uiPreferences.relativeTime().set(false)
-                }
-            }
-            if (oldVersion < 113) {
-                val prefsToReplace = listOf(
-                    "pref_download_only",
-                    "incognito_mode",
-                    "last_catalogue_source",
-                    "trusted_signatures",
-                    "last_app_closed",
-                    "library_update_last_timestamp",
-                    "library_unseen_updates_count",
-                    "last_used_category",
-                    "last_app_check",
-                    "last_ext_check",
-                    "last_version_code",
-                    "storage_dir",
-                )
-                replacePreferences(
-                    preferenceStore = preferenceStore,
-                    filterPredicate = { it.key in prefsToReplace },
-                    newKey = { Preference.appStateKey(it) },
-                )
-
-                // Deleting old download cache index files, but might as well clear it all out
-                context.cacheDir.deleteRecursively()
-            }
-            if (oldVersion < 114) {
-                sourcePreferences.extensionRepos().getAndSet {
-                    it.map { repo -> "https://raw.githubusercontent.com/$repo/repo" }.toSet()
-                }
-            }
-            if (oldVersion < 116) {
-                replacePreferences(
-                    preferenceStore = preferenceStore,
-                    filterPredicate = { it.key.startsWith("pref_mangasync_") || it.key.startsWith("track_token_") },
-                    newKey = { Preference.privateKey(it) },
-                )
-            }
-            if (oldVersion < 117) {
-                prefs.edit {
-                    remove(Preference.appStateKey("trusted_signatures"))
-                }
-            }
-            return true
-        }
-
-        return false
-    }
-}
-
-@Suppress("UNCHECKED_CAST")
-private fun replacePreferences(
-    preferenceStore: PreferenceStore,
-    filterPredicate: (Map.Entry<String, Any?>) -> Boolean,
-    newKey: (String) -> String,
-) {
-    preferenceStore.getAll()
-        .filter(filterPredicate)
-        .forEach { (key, value) ->
-            when (value) {
-                is Int -> {
-                    preferenceStore.getInt(newKey(key)).set(value)
-                    preferenceStore.getInt(key).delete()
-                }
-                is Long -> {
-                    preferenceStore.getLong(newKey(key)).set(value)
-                    preferenceStore.getLong(key).delete()
-                }
-                is Float -> {
-                    preferenceStore.getFloat(newKey(key)).set(value)
-                    preferenceStore.getFloat(key).delete()
-                }
-                is String -> {
-                    preferenceStore.getString(newKey(key)).set(value)
-                    preferenceStore.getString(key).delete()
-                }
-                is Boolean -> {
-                    preferenceStore.getBoolean(newKey(key)).set(value)
-                    preferenceStore.getBoolean(key).delete()
-                }
-                is Set<*> -> (value as? Set<String>)?.let {
-                    preferenceStore.getStringSet(newKey(key)).set(value)
-                    preferenceStore.getStringSet(key).delete()
-                }
-            }
-        }
-}
@@ -132,34 +132,34 @@ class BackupCreator(
        }
    }

-    private suspend fun backupCategories(options: BackupOptions): List<BackupCategory> {
+    suspend fun backupCategories(options: BackupOptions): List<BackupCategory> {
        if (!options.categories) return emptyList()

        return categoriesBackupCreator.backupCategories()
    }

-    private suspend fun backupMangas(mangas: List<Manga>, options: BackupOptions): List<BackupManga> {
+    suspend fun backupMangas(mangas: List<Manga>, options: BackupOptions): List<BackupManga> {
        return mangaBackupCreator.backupMangas(mangas, options)
    }

-    private fun backupSources(mangas: List<Manga>): List<BackupSource> {
+    fun backupSources(mangas: List<Manga>): List<BackupSource> {
        return sourcesBackupCreator.backupSources(mangas)
    }

-    private fun backupAppPreferences(options: BackupOptions): List<BackupPreference> {
+    fun backupAppPreferences(options: BackupOptions): List<BackupPreference> {
        if (!options.appSettings) return emptyList()

        return preferenceBackupCreator.backupAppPreferences(includePrivatePreferences = options.privateSettings)
    }

-    private fun backupSourcePreferences(options: BackupOptions): List<BackupSourcePreferences> {
+    fun backupSourcePreferences(options: BackupOptions): List<BackupSourcePreferences> {
        if (!options.sourceSettings) return emptyList()

        return preferenceBackupCreator.backupSourcePreferences(includePrivatePreferences = options.privateSettings)
    }

    // SY -->
-    private suspend fun backupSavedSearches(): List<BackupSavedSearch> {
+    suspend fun backupSavedSearches(): List<BackupSavedSearch> {
        return savedSearchBackupCreator.backupSavedSearches()
    }
    // SY <--
@@ -134,6 +134,7 @@ private fun Manga.toBackupManga(/* SY --> */customMangaInfo: CustomMangaInfo?/*
        updateStrategy = this.updateStrategy,
        lastModifiedAt = this.lastModifiedAt,
        favoriteModifiedAt = this.favoriteModifiedAt,
+        version = this.version,
        // SY -->
    ).also { backupManga ->
        customMangaInfo?.let {
@@ -4,6 +4,7 @@ import kotlinx.serialization.Serializable
 import kotlinx.serialization.protobuf.ProtoNumber
 import tachiyomi.domain.chapter.model.Chapter

+@Suppress("MagicNumber")
@Serializable
 data class BackupChapter(
    // in 1.x some of these values have different names
@@ -21,6 +22,7 @@ data class BackupChapter(
    @ProtoNumber(9) var chapterNumber: Float = 0F,
    @ProtoNumber(10) var sourceOrder: Long = 0,
    @ProtoNumber(11) var lastModifiedAt: Long = 0,
+    @ProtoNumber(12) var version: Long = 0,
 ) {
    fun toChapterImpl(): Chapter {
        return Chapter.create().copy(
@@ -35,36 +37,40 @@ data class BackupChapter(
            dateUpload = this@BackupChapter.dateUpload,
            sourceOrder = this@BackupChapter.sourceOrder,
            lastModifiedAt = this@BackupChapter.lastModifiedAt,
+            version = this@BackupChapter.version,
        )
    }
 }

-val backupChapterMapper =
-    { _: Long,
-            _: Long,
-            url: String,
-            name: String,
-            scanlator: String?,
-            read: Boolean,
-            bookmark: Boolean,
-            lastPageRead: Long,
-            chapterNumber: Double,
-            source_order: Long,
-            dateFetch: Long,
-            dateUpload: Long,
-            lastModifiedAt: Long,
-        ->
-        BackupChapter(
-            url = url,
-            name = name,
-            chapterNumber = chapterNumber.toFloat(),
-            scanlator = scanlator,
-            read = read,
-            bookmark = bookmark,
-            lastPageRead = lastPageRead,
-            dateFetch = dateFetch,
-            dateUpload = dateUpload,
-            sourceOrder = source_order,
-            lastModifiedAt = lastModifiedAt,
-        )
-    }
+val backupChapterMapper = {
+        _: Long,
+        _: Long,
+        url: String,
+        name: String,
+        scanlator: String?,
+        read: Boolean,
+        bookmark: Boolean,
+        lastPageRead: Long,
+        chapterNumber: Double,
+        sourceOrder: Long,
+        dateFetch: Long,
+        dateUpload: Long,
+        lastModifiedAt: Long,
+        version: Long,
+        _: Long,
+    ->
+    BackupChapter(
+        url = url,
+        name = name,
+        chapterNumber = chapterNumber.toFloat(),
+        scanlator = scanlator,
+        read = read,
+        bookmark = bookmark,
+        lastPageRead = lastPageRead,
+        dateFetch = dateFetch,
+        dateUpload = dateUpload,
+        sourceOrder = sourceOrder,
+        lastModifiedAt = lastModifiedAt,
+        version = version,
+    )
+}
@@ -6,7 +6,10 @@ import kotlinx.serialization.protobuf.ProtoNumber
 import tachiyomi.domain.manga.model.CustomMangaInfo
 import tachiyomi.domain.manga.model.Manga

-@Suppress("DEPRECATION")
+@Suppress(
+    "DEPRECATION",
+    "MagicNumber",
+)
@Serializable
 data class BackupManga(
    // in 1.x some of these values have different names
@@ -40,6 +43,7 @@ data class BackupManga(
    @ProtoNumber(106) var lastModifiedAt: Long = 0,
    @ProtoNumber(107) var favoriteModifiedAt: Long? = null,
    @ProtoNumber(108) var excludedScanlators: List<String> = emptyList(),
+    @ProtoNumber(109) var version: Long = 0,

    // SY specific values
    @ProtoNumber(600) var mergedMangaReferences: List<BackupMergedMangaReference> = emptyList(),
@@ -76,6 +80,7 @@ data class BackupManga(
            updateStrategy = this@BackupManga.updateStrategy,
            lastModifiedAt = this@BackupManga.lastModifiedAt,
            favoriteModifiedAt = this@BackupManga.favoriteModifiedAt,
+            version = this@BackupManga.version,
        )
    }
 }
@@ -34,7 +34,7 @@ class BackupRestorer(

    private val categoriesRestorer: CategoriesRestorer = CategoriesRestorer(),
    private val preferenceRestorer: PreferenceRestorer = PreferenceRestorer(context),
-    private val mangaRestorer: MangaRestorer = MangaRestorer(),
+    private val mangaRestorer: MangaRestorer = MangaRestorer(isSync),
    // SY -->
    private val savedSearchRestorer: SavedSearchRestorer = SavedSearchRestorer(),
    // SY <--
@@ -17,14 +17,19 @@ class CategoriesRestorer(
        if (backupCategories.isNotEmpty()) {
            val dbCategories = getCategories.await()
            val dbCategoriesByName = dbCategories.associateBy { it.name }
+            var nextOrder = dbCategories.maxOfOrNull { it.order }?.plus(1) ?: 0

-            val categories = backupCategories.map {
-                dbCategoriesByName[it.name]
-                    ?: handler.awaitOneExecutable {
-                        categoriesQueries.insert(it.name, it.order, it.flags)
-                        categoriesQueries.selectLastInsertedRowId()
-                    }.let { id -> it.toCategory(id) }
-            }
+            val categories = backupCategories
+                .sortedBy { it.order }
+                .distinctBy { it.name }
+                .map {
+                    val newOrder = nextOrder++
+                    dbCategoriesByName[it.name]
+                        ?: handler.awaitOneExecutable {
+                            categoriesQueries.insert(it.name, newOrder, it.flags)
+                            categoriesQueries.selectLastInsertedRowId()
+                        }.let { id -> it.toCategory(id).copy(order = newOrder) }
+                }

            libraryPreferences.categorizedDisplaySettings().set(
                (dbCategories + categories)
@@ -33,6 +33,8 @@ import java.util.Date
 import kotlin.math.max

 class MangaRestorer(
+    private var isSync: Boolean = false,
+
    private val handler: DatabaseHandler = Injekt.get(),
    private val getCategories: GetCategories = Injekt.get(),
    private val getMangaByUrlAndSourceId: GetMangaByUrlAndSourceId = Injekt.get(),
@@ -47,7 +49,6 @@ class MangaRestorer(
    private val getFlatMetadataById: GetFlatMetadataById = Injekt.get(),
    // SY <--
 ) {
-
    private var now = ZonedDateTime.now()
    private var currentFetchWindow = fetchInterval.getWindow(now)

@@ -97,6 +98,11 @@ class MangaRestorer(
                customManga = backupManga.getCustomMangaInfo(),
                // SY <--
            )
+
+            if (isSync) {
+                mangasQueries.resetIsSyncing()
+                chaptersQueries.resetIsSyncing()
+            }
        }
    }

@@ -105,7 +111,7 @@ class MangaRestorer(
    }

    private suspend fun restoreExistingManga(manga: Manga, dbManga: Manga): Manga {
-        return if (manga.lastModifiedAt > dbManga.lastModifiedAt) {
+        return if (manga.version > dbManga.version) {
            updateManga(dbManga.copyFrom(manga).copy(id = dbManga.id))
        } else {
            updateManga(manga.copyFrom(dbManga).copy(id = dbManga.id))
@@ -124,10 +130,11 @@ class MangaRestorer(
            ogStatus = newer.status,
            // SY <--
            initialized = this.initialized || newer.initialized,
+            version = newer.version,
        )
    }

-    private suspend fun updateManga(manga: Manga): Manga {
+    suspend fun updateManga(manga: Manga): Manga {
        handler.await(true) {
            mangasQueries.update(
                source = manga.source,
@@ -150,6 +157,8 @@ class MangaRestorer(
                dateAdded = manga.dateAdded,
                mangaId = manga.id,
                updateStrategy = manga.updateStrategy.let(UpdateStrategyColumnAdapter::encode),
+                version = manga.version,
+                isSyncing = 1,
            )
        }
        return manga
@@ -161,6 +170,7 @@ class MangaRestorer(
        return manga.copy(
            initialized = manga.description != null,
            id = insertManga(manga),
+            version = manga.version,
        )
    }

@@ -169,36 +179,15 @@ class MangaRestorer(
            .associateBy { it.url }

        val (existingChapters, newChapters) = backupChapters
-            .mapNotNull {
-                val chapter = it.toChapterImpl().copy(mangaId = manga.id)
-
+            .mapNotNull { backupChapter ->
+                val chapter = backupChapter.toChapterImpl().copy(mangaId = manga.id)
                val dbChapter = dbChaptersByUrl[chapter.url]
-                    ?: // New chapter
-                    return@mapNotNull chapter

-                if (chapter.forComparison() == dbChapter.forComparison()) {
-                    // Same state; skip
-                    return@mapNotNull null
+                when {
+                    dbChapter == null -> chapter // New chapter
+                    chapter.forComparison() == dbChapter.forComparison() -> null // Same state; skip
+                    else -> updateChapterBasedOnSyncState(chapter, dbChapter)
                }
-
-                // Update to an existing chapter
-                var updatedChapter = chapter
-                    .copyFrom(dbChapter)
-                    .copy(
-                        id = dbChapter.id,
-                        bookmark = chapter.bookmark || dbChapter.bookmark,
-                    )
-                if (dbChapter.read && !updatedChapter.read) {
-                    updatedChapter = updatedChapter.copy(
-                        read = true,
-                        lastPageRead = dbChapter.lastPageRead,
-                    )
-                } else if (updatedChapter.lastPageRead == 0L && dbChapter.lastPageRead != 0L) {
-                    updatedChapter = updatedChapter.copy(
-                        lastPageRead = dbChapter.lastPageRead,
-                    )
-                }
-                updatedChapter
            }
            .partition { it.id > 0 }

@@ -206,8 +195,29 @@ class MangaRestorer(
        updateExistingChapters(existingChapters)
    }

+    private fun updateChapterBasedOnSyncState(chapter: Chapter, dbChapter: Chapter): Chapter {
+        return if (isSync) {
+            chapter.copy(
+                id = dbChapter.id,
+                bookmark = chapter.bookmark || dbChapter.bookmark,
+                read = chapter.read,
+                lastPageRead = chapter.lastPageRead,
+            )
+        } else {
+            chapter.copyFrom(dbChapter).let {
+                when {
+                    dbChapter.read && !it.read -> it.copy(read = true, lastPageRead = dbChapter.lastPageRead)
+                    it.lastPageRead == 0L && dbChapter.lastPageRead != 0L -> it.copy(
+                        lastPageRead = dbChapter.lastPageRead,
+                    )
+                    else -> it
+                }
+            }
+        }
+    }
+
    private fun Chapter.forComparison() =
-        this.copy(id = 0L, mangaId = 0L, dateFetch = 0L, dateUpload = 0L, lastModifiedAt = 0L)
+        this.copy(id = 0L, mangaId = 0L, dateFetch = 0L, dateUpload = 0L, lastModifiedAt = 0L, version = 0L)

    private suspend fun insertNewChapters(chapters: List<Chapter>) {
        handler.await(true) {
@@ -224,6 +234,7 @@ class MangaRestorer(
                    chapter.sourceOrder,
                    chapter.dateFetch,
                    chapter.dateUpload,
+                    chapter.version,
                )
            }
        }
@@ -245,6 +256,8 @@ class MangaRestorer(
                    dateFetch = null,
                    dateUpload = null,
                    chapterId = chapter.id,
+                    version = chapter.version,
+                    isSyncing = 1,
                )
            }
        }
@@ -277,6 +290,7 @@ class MangaRestorer(
                coverLastModified = manga.coverLastModified,
                dateAdded = manga.dateAdded,
                updateStrategy = manga.updateStrategy,
+                version = manga.version,
            )
            mangasQueries.selectLastInsertedRowId()
        }
@@ -299,7 +313,7 @@ class MangaRestorer(
        restoreCategories(manga, categories, backupCategories)
        restoreChapters(manga, chapters)
        restoreTracking(manga, tracks)
-        restoreHistory(history)
+        restoreHistory(manga, history)
        restoreExcludedScanlators(manga, excludedScanlators)
        updateManga.awaitUpdateFetchInterval(manga, now, currentFetchWindow)
        // SY -->
@@ -345,13 +359,14 @@ class MangaRestorer(
        }
    }

-    private suspend fun restoreHistory(backupHistory: List<BackupHistory>) {
+    private suspend fun restoreHistory(manga: Manga, backupHistory: List<BackupHistory>) {
        val toUpdate = backupHistory.mapNotNull { history ->
-            val dbHistory = handler.awaitOneOrNull { historyQueries.getHistoryByChapterUrl(history.url) }
+            val dbHistory = handler.awaitOneOrNull { historyQueries.getHistoryByChapterUrl(manga.id, history.url) }
            val item = history.getHistoryImpl()

            if (dbHistory == null) {
-                val chapter = handler.awaitOneOrNull { chaptersQueries.getChapterByUrl(history.url) }
+                val chapter = handler.awaitList { chaptersQueries.getChapterByUrl(history.url) }
+                    .find { it.manga_id == manga.id }
                return@mapNotNull if (chapter == null) {
                    // Chapter doesn't exist; skip
                    null
@@ -0,0 +1,38 @@
+package eu.kanade.tachiyomi.data.coil
+
+import coil3.ImageLoader
+import coil3.decode.DataSource
+import coil3.decode.ImageSource
+import coil3.fetch.FetchResult
+import coil3.fetch.Fetcher
+import coil3.fetch.SourceFetchResult
+import coil3.request.Options
+import okio.BufferedSource
+
+class BufferedSourceFetcher(
+    private val data: BufferedSource,
+    private val options: Options,
+) : Fetcher {
+
+    override suspend fun fetch(): FetchResult {
+        return SourceFetchResult(
+            source = ImageSource(
+                source = data,
+                fileSystem = options.fileSystem,
+            ),
+            mimeType = null,
+            dataSource = DataSource.MEMORY,
+        )
+    }
+
+    class Factory : Fetcher.Factory<BufferedSource> {
+
+        override fun create(
+            data: BufferedSource,
+            options: Options,
+            imageLoader: ImageLoader,
+        ): Fetcher {
+            return BufferedSourceFetcher(data, options)
+        }
+    }
+}
@@ -46,6 +46,7 @@ import java.io.IOException
 * Available request parameter:
 * - [USE_CUSTOM_COVER_KEY]: Use custom cover if set by user, default is true
 */
+@Suppress("LongParameterList")
 class MangaCoverFetcher(
    private val url: String?,
    private val isLibraryManga: Boolean,
@@ -55,7 +56,7 @@ class MangaCoverFetcher(
    private val diskCacheKeyLazy: Lazy<String>,
    private val sourceLazy: Lazy<HttpSource?>,
    private val callFactoryLazy: Lazy<Call.Factory>,
-    private val diskCacheLazy: Lazy<DiskCache>,
+    private val imageLoader: ImageLoader,
 ) : Fetcher {

    private val diskCacheKey: String
@@ -207,7 +208,7 @@ class MangaCoverFetcher(
    private fun moveSnapshotToCoverCache(snapshot: DiskCache.Snapshot, cacheFile: File?): File? {
        if (cacheFile == null) return null
        return try {
-            diskCacheLazy.value.run {
+            imageLoader.diskCache?.run {
                fileSystem.source(snapshot.data).use { input ->
                    writeSourceToCoverCache(input, cacheFile)
                }
@@ -248,7 +249,7 @@ class MangaCoverFetcher(

    private fun readFromDiskCache(): DiskCache.Snapshot? {
        return if (options.diskCachePolicy.readEnabled) {
-            diskCacheLazy.value.openSnapshot(diskCacheKey)
+            imageLoader.diskCache?.openSnapshot(diskCacheKey)
        } else {
            null
        }
@@ -257,9 +258,10 @@ class MangaCoverFetcher(
    private fun writeToDiskCache(
        response: Response,
    ): DiskCache.Snapshot? {
-        val editor = diskCacheLazy.value.openEditor(diskCacheKey) ?: return null
+        val diskCache = imageLoader.diskCache
+        val editor = diskCache?.openEditor(diskCacheKey) ?: return null
        try {
-            diskCacheLazy.value.fileSystem.write(editor.data) {
+            diskCache.fileSystem.write(editor.data) {
                response.body.source().readAll(this)
            }
            return editor.commitAndOpenSnapshot()
@@ -299,7 +301,6 @@ class MangaCoverFetcher(

    class MangaFactory(
        private val callFactoryLazy: Lazy<Call.Factory>,
-        private val diskCacheLazy: Lazy<DiskCache>,
    ) : Fetcher.Factory<Manga> {

        private val coverCache: CoverCache by injectLazy()
@@ -312,17 +313,16 @@ class MangaCoverFetcher(
                options = options,
                coverFileLazy = lazy { coverCache.getCoverFile(data.thumbnailUrl) },
                customCoverFileLazy = lazy { coverCache.getCustomCoverFile(data.id) },
-                diskCacheKeyLazy = lazy { MangaKeyer().key(data, options) },
+                diskCacheKeyLazy = lazy { imageLoader.components.key(data, options)!! },
                sourceLazy = lazy { sourceManager.get(data.source) as? HttpSource },
                callFactoryLazy = callFactoryLazy,
-                diskCacheLazy = diskCacheLazy,
+                imageLoader = imageLoader,
            )
        }
    }

    class MangaCoverFactory(
        private val callFactoryLazy: Lazy<Call.Factory>,
-        private val diskCacheLazy: Lazy<DiskCache>,
    ) : Fetcher.Factory<MangaCover> {

        private val coverCache: CoverCache by injectLazy()
@@ -335,10 +335,10 @@ class MangaCoverFetcher(
                options = options,
                coverFileLazy = lazy { coverCache.getCoverFile(data.url) },
                customCoverFileLazy = lazy { coverCache.getCustomCoverFile(data.mangaId) },
-                diskCacheKeyLazy = lazy { MangaCoverKeyer().key(data, options) },
+                diskCacheKeyLazy = lazy { imageLoader.components.key(data, options)!! },
                sourceLazy = lazy { sourceManager.get(data.sourceId) as? HttpSource },
                callFactoryLazy = callFactoryLazy,
-                diskCacheLazy = diskCacheLazy,
+                imageLoader = imageLoader,
            )
        }
    }
@@ -34,6 +34,7 @@ import java.io.IOException
 * Disk caching is handled by [PagePreviewCache], otherwise
 * handled by Coil's [DiskCache].
 */
+@Suppress("LongParameterList")
 class PagePreviewFetcher(
    private val page: PagePreview,
    private val options: Options,
@@ -43,7 +44,7 @@ class PagePreviewFetcher(
    private val diskCacheKeyLazy: Lazy<String>,
    private val sourceLazy: Lazy<PagePreviewSource?>,
    private val callFactoryLazy: Lazy<Call.Factory>,
-    private val diskCacheLazy: Lazy<DiskCache>,
+    private val imageLoader: ImageLoader,
 ) : Fetcher {

    private val diskCacheKey: String
@@ -164,7 +165,7 @@ class PagePreviewFetcher(

    private fun moveSnapshotToPagePreviewCache(snapshot: DiskCache.Snapshot): File? {
        return try {
-            diskCacheLazy.value.run {
+            imageLoader.diskCache?.run {
                fileSystem.source(snapshot.data).use { input ->
                    writeSourceToPagePreviewCache(input)
                }
@@ -203,15 +204,16 @@ class PagePreviewFetcher(
    }

    private fun readFromDiskCache(): DiskCache.Snapshot? {
-        return if (options.diskCachePolicy.readEnabled) diskCacheLazy.value.openSnapshot(diskCacheKey) else null
+        return if (options.diskCachePolicy.readEnabled) imageLoader.diskCache?.openSnapshot(diskCacheKey) else null
    }

    private fun writeToDiskCache(
        response: Response,
    ): DiskCache.Snapshot? {
-        val editor = diskCacheLazy.value.openEditor(diskCacheKey) ?: return null
+        val diskCache = imageLoader.diskCache
+        val editor = diskCache?.openEditor(diskCacheKey) ?: return null
        try {
-            diskCacheLazy.value.fileSystem.write(editor.data) {
+            diskCache.fileSystem.write(editor.data) {
                response.body.source().readAll(this)
            }
            return editor.commitAndOpenSnapshot()
@@ -235,7 +237,6 @@ class PagePreviewFetcher(

    class Factory(
        private val callFactoryLazy: Lazy<Call.Factory>,
-        private val diskCacheLazy: Lazy<DiskCache>,
    ) : Fetcher.Factory<PagePreview> {

        private val pagePreviewCache: PagePreviewCache by injectLazy()
@@ -248,10 +249,10 @@ class PagePreviewFetcher(
                pagePreviewFile = { pagePreviewCache.getImageFile(data.imageUrl) },
                isInCache = { pagePreviewCache.isImageInCache(data.imageUrl) },
                writeToCache = { pagePreviewCache.putImageToCache(data.imageUrl, it) },
-                diskCacheKeyLazy = lazy { PagePreviewKeyer().key(data, options) },
+                diskCacheKeyLazy = lazy { imageLoader.components.key(data, options)!! },
                sourceLazy = lazy { sourceManager.get(data.source) as? PagePreviewSource },
                callFactoryLazy = callFactoryLazy,
-                diskCacheLazy = diskCacheLazy,
+                imageLoader = imageLoader,
            )
        }
    }
@@ -1,16 +1,18 @@
 package eu.kanade.tachiyomi.data.coil

+import android.graphics.Bitmap
 import android.os.Build
-import androidx.core.graphics.drawable.toDrawable
 import coil3.ImageLoader
 import coil3.asCoilImage
 import coil3.decode.DecodeResult
+import coil3.decode.DecodeUtils
 import coil3.decode.Decoder
 import coil3.decode.ImageSource
 import coil3.fetch.SourceFetchResult
 import coil3.request.Options
-import coil3.request.allowRgb565
+import coil3.request.bitmapConfig
 import eu.kanade.tachiyomi.util.storage.CbzCrypto
+import eu.kanade.tachiyomi.util.system.GLUtil
 import net.lingala.zip4j.ZipFile
 import net.lingala.zip4j.model.FileHeader
 import okio.BufferedSource
@@ -39,29 +41,58 @@ class TachiyomiImageDecoder(private val resources: ImageSource, private val opti
        }
        val decoder = resources.sourceOrNull()?.use {
            zip4j.use { zipFile ->
-                ImageDecoder.newInstance(zipFile?.getInputStream(entry) ?: it.inputStream())
+                ImageDecoder.newInstance(zipFile?.getInputStream(entry) ?: it.inputStream(), options.cropBorders, displayProfile)
            }
        }
        // SY <--

        check(decoder != null && decoder.width > 0 && decoder.height > 0) { "Failed to initialize decoder" }

-        val bitmap = decoder.decode(rgb565 = options.allowRgb565)
+        val srcWidth = decoder.width
+        val srcHeight = decoder.height
+
+        val dstWidth = options.size.widthPx(options.scale) { srcWidth }
+        val dstHeight = options.size.heightPx(options.scale) { srcHeight }
+
+        val sampleSize = DecodeUtils.calculateInSampleSize(
+            srcWidth = srcWidth,
+            srcHeight = srcHeight,
+            dstWidth = dstWidth,
+            dstHeight = dstHeight,
+            scale = options.scale,
+        )
+
+        var bitmap = decoder.decode(sampleSize = sampleSize)
        decoder.recycle()

        check(bitmap != null) { "Failed to decode image" }

+        if (
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
+            options.bitmapConfig == Bitmap.Config.HARDWARE &&
+            maxOf(bitmap.width, bitmap.height) <= GLUtil.maxTextureSize
+        ) {
+            val hwBitmap = bitmap.copy(Bitmap.Config.HARDWARE, false)
+            if (hwBitmap != null) {
+                bitmap.recycle()
+                bitmap = hwBitmap
+            }
+        }
+
        return DecodeResult(
            image = bitmap.asCoilImage(),
-            isSampled = false,
+            isSampled = sampleSize > 1,
        )
    }

    class Factory : Decoder.Factory {

        override fun create(result: SourceFetchResult, options: Options, imageLoader: ImageLoader): Decoder? {
-            if (!isApplicable(result.source.source())) return null
-            return TachiyomiImageDecoder(result.source, options)
+            return if (options.customDecoder || isApplicable(result.source.source())) {
+                TachiyomiImageDecoder(result.source, options)
+            } else {
+                null
+            }
        }

        private fun isApplicable(source: BufferedSource): Boolean {
@@ -84,4 +115,8 @@ class TachiyomiImageDecoder(private val resources: ImageSource, private val opti

        override fun hashCode() = javaClass.hashCode()
    }
+
+    companion object {
+        var displayProfile: ByteArray? = null
+    }
 }
@@ -0,0 +1,44 @@
+package eu.kanade.tachiyomi.data.coil
+
+import coil3.Extras
+import coil3.getExtra
+import coil3.request.ImageRequest
+import coil3.request.Options
+import coil3.size.Dimension
+import coil3.size.Scale
+import coil3.size.Size
+import coil3.size.isOriginal
+import coil3.size.pxOrElse
+
+internal inline fun Size.widthPx(scale: Scale, original: () -> Int): Int {
+    return if (isOriginal) original() else width.toPx(scale)
+}
+
+internal inline fun Size.heightPx(scale: Scale, original: () -> Int): Int {
+    return if (isOriginal) original() else height.toPx(scale)
+}
+
+internal fun Dimension.toPx(scale: Scale): Int = pxOrElse {
+    when (scale) {
+        Scale.FILL -> Int.MIN_VALUE
+        Scale.FIT -> Int.MAX_VALUE
+    }
+}
+
+fun ImageRequest.Builder.cropBorders(enable: Boolean) = apply {
+    extras[cropBordersKey] = enable
+}
+
+val Options.cropBorders: Boolean
+    get() = getExtra(cropBordersKey)
+
+private val cropBordersKey = Extras.Key(default = false)
+
+fun ImageRequest.Builder.customDecoder(enable: Boolean) = apply {
+    extras[customDecoderKey] = enable
+}
+
+val Options.customDecoder: Boolean
+    get() = getExtra(customDecoderKey)
+
+private val customDecoderKey = Extras.Key(default = false)
@@ -21,6 +21,8 @@ interface Chapter : SChapter, Serializable {
    var source_order: Int

    var last_modified: Long
+
+    var version: Long
 }

 fun Chapter.toDomainChapter(): DomainChapter? {
@@ -39,5 +41,6 @@ fun Chapter.toDomainChapter(): DomainChapter? {
        chapterNumber = chapter_number.toDouble(),
        scanlator = scanlator,
        lastModifiedAt = last_modified,
+        version = version,
    )
 }
@@ -28,6 +28,8 @@ class ChapterImpl : Chapter {

    override var last_modified: Long = 0

+    override var version: Long = 0
+
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other == null || javaClass != other.javaClass) return false
@@ -18,6 +18,7 @@ import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onStart
@@ -336,19 +337,15 @@ class DownloadCache(
            }

            // Try to wait until extensions and sources have loaded
-            var sources = getSources()
-            if (sources.isEmpty()) {
-                withTimeoutOrNull(30.seconds) {
-                    while (!extensionManager.isInitialized) {
-                        delay(2.seconds)
-                    }
+            // SY -->
+            var sources = emptyList<Source>()
+            withTimeoutOrNull(30.seconds) {
+                extensionManager.isInitialized.first { it }
+                sourceManager.isInitialized.first { it }

-                    while (extensionManager.availableExtensionsFlow.value.isNotEmpty() && sources.isEmpty()) {
-                        delay(2.seconds)
-                        sources = getSources()
-                    }
-                }
+                sources = getSources()
            }
+            // SY <--

            val sourceMap = sources.associate { provider.getSourceDirName(it).lowercase() to it.id }

@@ -475,7 +475,7 @@ class DownloadManager(

    fun renameMangaDir(oldTitle: String, newTitle: String, source: Long) {
        val sourceDir = provider.findSourceDir(sourceManager.getOrStub(source)) ?: return
-        val mangaDir = sourceDir.findFile(DiskUtil.buildValidFilename(oldTitle), true) ?: return
+        val mangaDir = sourceDir.findFile(DiskUtil.buildValidFilename(oldTitle)) ?: return
        mangaDir.renameTo(DiskUtil.buildValidFilename(newTitle))
    }
 }
@@ -57,7 +57,7 @@ class DownloadProvider(
     * @param source the source to query.
     */
    fun findSourceDir(source: Source): UniFile? {
-        return downloadsDir?.findFile(getSourceDirName(source), true)
+        return downloadsDir?.findFile(getSourceDirName(source))
    }

    /**
@@ -68,7 +68,7 @@ class DownloadProvider(
     */
    fun findMangaDir(mangaTitle: String, source: Source): UniFile? {
        val sourceDir = findSourceDir(source)
-        return sourceDir?.findFile(getMangaDirName(mangaTitle), true)
+        return sourceDir?.findFile(getMangaDirName(mangaTitle))
    }

    /**
@@ -82,7 +82,7 @@ class DownloadProvider(
    fun findChapterDir(chapterName: String, chapterScanlator: String?, mangaTitle: String, source: Source): UniFile? {
        val mangaDir = findMangaDir(mangaTitle, source)
        return getValidChapterDirNames(chapterName, chapterScanlator).asSequence()
-            .mapNotNull { mangaDir?.findFile(it, true) }
+            .mapNotNull { mangaDir?.findFile(it) }
            .firstOrNull()
    }

@@ -97,7 +97,7 @@ class DownloadProvider(
        val mangaDir = findMangaDir(/* SY --> */ manga.ogTitle /* SY <-- */, source) ?: return null to emptyList()
        return mangaDir to chapters.mapNotNull { chapter ->
            getValidChapterDirNames(chapter.name, chapter.scanlator).asSequence()
-                .mapNotNull { mangaDir.findFile(it, true) }
+                .mapNotNull { mangaDir.findFile(it) }
                .firstOrNull()
        }
    }
@@ -13,10 +13,10 @@ import eu.kanade.tachiyomi.source.UnmeteredSource
 import eu.kanade.tachiyomi.source.model.Page
 import eu.kanade.tachiyomi.source.online.HttpSource
 import eu.kanade.tachiyomi.util.storage.CbzCrypto
-import eu.kanade.tachiyomi.util.storage.CbzCrypto.addFilesToZip
 import eu.kanade.tachiyomi.util.storage.DiskUtil
 import eu.kanade.tachiyomi.util.storage.DiskUtil.NOMEDIA_FILE
 import eu.kanade.tachiyomi.util.storage.saveTo
+import exh.source.isEhBasedSource
 import exh.util.DataSaver
 import exh.util.DataSaver.Companion.getImage
 import kotlinx.coroutines.CancellationException
@@ -46,6 +46,7 @@ import logcat.LogPriority
 import nl.adaptivity.xmlutil.serialization.XML
 import okhttp3.Response
 import tachiyomi.core.common.i18n.stringResource
+import tachiyomi.core.common.storage.addFilesToZip
 import tachiyomi.core.common.storage.extension
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.core.common.util.lang.launchNow
@@ -511,6 +512,9 @@ class Downloader(
            .retryWhen { _, attempt ->
                if (attempt < 3) {
                    delay((2L shl attempt.toInt()) * 1000)
+                    if (source.isEhBasedSource()) {
+                        page.imageUrl = source.getImageUrl(page)
+                    }
                    true
                } else {
                    false
@@ -572,10 +576,6 @@ class Downloader(
                tmpDir,
                imageFile,
                filenamePrefix,
-                // SY -->
-                zip4jFile = null,
-                zip4jEntry = null,
-                // SY <--
            )
        } catch (e: Exception) {
            logcat(LogPriority.ERROR, e) { "Failed to split downloaded image" }
@@ -713,7 +713,7 @@ class Downloader(
        )

        // Remove the old file
-        dir.findFile(COMIC_INFO_FILE, true)?.delete()
+        dir.findFile(COMIC_INFO_FILE)?.delete()
        dir.createFile(COMIC_INFO_FILE)!!.openOutputStream().use {
            val comicInfoString = xml.encodeToString(ComicInfo.serializer(), comicInfo)
            it.write(comicInfoString.toByteArray())
@@ -21,11 +21,13 @@ import eu.kanade.domain.chapter.interactor.SyncChaptersWithSource
 import eu.kanade.domain.manga.interactor.UpdateManga
 import eu.kanade.domain.manga.model.copyFrom
 import eu.kanade.domain.manga.model.toSManga
+import eu.kanade.domain.sync.SyncPreferences
 import eu.kanade.domain.track.model.toDbTrack
 import eu.kanade.domain.track.model.toDomainTrack
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.notification.Notifications
+import eu.kanade.tachiyomi.data.sync.SyncDataJob
 import eu.kanade.tachiyomi.data.track.TrackStatus
 import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.source.model.SManga
@@ -801,6 +803,7 @@ class LibraryUpdateJob(private val context: Context, workerParams: WorkerParamet
            // SY <--
        ): Boolean {
            val wm = context.workManager
+            // Check if the LibraryUpdateJob is already running
            if (wm.isRunning(TAG)) {
                // Already running either as a scheduled or manual job
                return false
@@ -814,12 +817,41 @@ class LibraryUpdateJob(private val context: Context, workerParams: WorkerParamet
                KEY_GROUP_EXTRA to groupExtra,
                // SY <--
            )
-            val request = OneTimeWorkRequestBuilder<LibraryUpdateJob>()
-                .addTag(TAG)
-                .addTag(WORK_NAME_MANUAL)
-                .setInputData(inputData)
-                .build()
-            wm.enqueueUniqueWork(WORK_NAME_MANUAL, ExistingWorkPolicy.KEEP, request)
+
+            val syncPreferences: SyncPreferences = Injekt.get()
+
+            // Always sync the data before library update if syncing is enabled.
+            if (syncPreferences.isSyncEnabled()) {
+                // Check if SyncDataJob is already running
+                if (SyncDataJob.isRunning(context)) {
+                    // SyncDataJob is already running
+                    return false
+                }
+
+                // Define the SyncDataJob
+                val syncDataJob = OneTimeWorkRequestBuilder<SyncDataJob>()
+                    .addTag(SyncDataJob.TAG_MANUAL)
+                    .build()
+
+                // Chain SyncDataJob to run before LibraryUpdateJob
+                val libraryUpdateJob = OneTimeWorkRequestBuilder<LibraryUpdateJob>()
+                    .addTag(TAG)
+                    .addTag(WORK_NAME_MANUAL)
+                    .setInputData(inputData)
+                    .build()
+
+                wm.beginUniqueWork(WORK_NAME_MANUAL, ExistingWorkPolicy.KEEP, syncDataJob)
+                    .then(libraryUpdateJob)
+                    .enqueue()
+            } else {
+                val request = OneTimeWorkRequestBuilder<LibraryUpdateJob>()
+                    .addTag(TAG)
+                    .addTag(WORK_NAME_MANUAL)
+                    .setInputData(inputData)
+                    .build()
+
+                wm.enqueueUniqueWork(WORK_NAME_MANUAL, ExistingWorkPolicy.KEEP, request)
+            }

            return true
        }
@@ -10,6 +10,7 @@ import androidx.core.net.toUri
 import eu.kanade.tachiyomi.data.backup.restore.BackupRestoreJob
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.library.LibraryUpdateJob
+import eu.kanade.tachiyomi.data.sync.SyncDataJob
 import eu.kanade.tachiyomi.data.updater.AppUpdateDownloadJob
 import eu.kanade.tachiyomi.ui.main.MainActivity
 import eu.kanade.tachiyomi.ui.reader.ReaderActivity
@@ -71,6 +72,8 @@ class NotificationReceiver : BroadcastReceiver() {
                    "application/x-protobuf+gzip",
                )
            ACTION_CANCEL_RESTORE -> cancelRestore(context)
+
+            ACTION_CANCEL_SYNC -> cancelSync(context)
            // Cancel library update and dismiss notification
            ACTION_CANCEL_LIBRARY_UPDATE -> cancelLibraryUpdate(context)
            // Start downloading app update
@@ -188,6 +191,15 @@ class NotificationReceiver : BroadcastReceiver() {
        AppUpdateDownloadJob.stop(context)
    }

+    /**
+     * Method called when user wants to stop a backup restore job.
+     *
+     * @param context context of application
+     */
+    private fun cancelSync(context: Context) {
+        SyncDataJob.stop(context)
+    }
+
    /**
     * Method called when user wants to mark manga chapters as read
     *
@@ -240,6 +252,8 @@ class NotificationReceiver : BroadcastReceiver() {

        private const val ACTION_CANCEL_RESTORE = "$ID.$NAME.CANCEL_RESTORE"

+        private const val ACTION_CANCEL_SYNC = "$ID.$NAME.CANCEL_SYNC"
+
        private const val ACTION_CANCEL_LIBRARY_UPDATE = "$ID.$NAME.CANCEL_LIBRARY_UPDATE"

        private const val ACTION_START_APP_UPDATE = "$ID.$NAME.ACTION_START_APP_UPDATE"
@@ -618,5 +632,25 @@ class NotificationReceiver : BroadcastReceiver() {
                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
            )
        }
+
+        /**
+         * Returns [PendingIntent] that cancels a sync restore job.
+         *
+         * @param context context of application
+         * @param notificationId id of notification
+         * @return [PendingIntent]
+         */
+        internal fun cancelSyncPendingBroadcast(context: Context, notificationId: Int): PendingIntent {
+            val intent = Intent(context, NotificationReceiver::class.java).apply {
+                action = ACTION_CANCEL_SYNC
+                putExtra(EXTRA_NOTIFICATION_ID, notificationId)
+            }
+            return PendingIntent.getBroadcast(
+                context,
+                0,
+                intent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+            )
+        }
    }
 }
@@ -79,7 +79,7 @@ class ImageSaver(
            MediaStore.Images.Media.RELATIVE_PATH to relativePath,
            MediaStore.Images.Media.DISPLAY_NAME to image.name,
            MediaStore.Images.Media.MIME_TYPE to type.mime,
-            MediaStore.Images.Media.DATE_MODIFIED to Instant.now().toEpochMilli(),
+            MediaStore.Images.Media.DATE_MODIFIED to Instant.now().epochSecond,
        )

        val picture = findUriOrDefault(relativePath, filename) {
@@ -0,0 +1,126 @@
+package eu.kanade.tachiyomi.data.sync
+
+import android.content.Context
+import android.content.pm.ServiceInfo
+import android.os.Build
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ExistingWorkPolicy
+import androidx.work.ForegroundInfo
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkInfo
+import androidx.work.WorkQuery
+import androidx.work.WorkerParameters
+import eu.kanade.domain.sync.SyncPreferences
+import eu.kanade.tachiyomi.data.notification.Notifications
+import eu.kanade.tachiyomi.util.system.cancelNotification
+import eu.kanade.tachiyomi.util.system.isRunning
+import eu.kanade.tachiyomi.util.system.setForegroundSafely
+import eu.kanade.tachiyomi.util.system.workManager
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.util.concurrent.TimeUnit
+
+class SyncDataJob(private val context: Context, workerParams: WorkerParameters) :
+    CoroutineWorker(context, workerParams) {
+
+    private val notifier = SyncNotifier(context)
+
+    override suspend fun doWork(): Result {
+        if (tags.contains(TAG_AUTO)) {
+            // Find a running manual worker. If exists, try again later
+            if (context.workManager.isRunning(TAG_MANUAL)) {
+                return Result.retry()
+            }
+        }
+
+        setForegroundSafely()
+
+        return try {
+            SyncManager(context).syncData()
+            Result.success()
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            notifier.showSyncError(e.message)
+            Result.failure()
+        } finally {
+            context.cancelNotification(Notifications.ID_RESTORE_PROGRESS)
+        }
+    }
+
+    override suspend fun getForegroundInfo(): ForegroundInfo {
+        return ForegroundInfo(
+            Notifications.ID_RESTORE_PROGRESS,
+            notifier.showSyncProgress().build(),
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+            } else {
+                0
+            },
+        )
+    }
+
+    companion object {
+        private const val TAG_JOB = "SyncDataJob"
+        private const val TAG_AUTO = "$TAG_JOB:auto"
+        const val TAG_MANUAL = "$TAG_JOB:manual"
+
+        fun isRunning(context: Context): Boolean {
+            return context.workManager.isRunning(TAG_JOB)
+        }
+
+        fun setupTask(context: Context, prefInterval: Int? = null) {
+            val syncPreferences = Injekt.get<SyncPreferences>()
+            val interval = prefInterval ?: syncPreferences.syncInterval().get()
+
+            if (interval > 0) {
+                val request = PeriodicWorkRequestBuilder<SyncDataJob>(
+                    interval.toLong(),
+                    TimeUnit.MINUTES,
+                    10,
+                    TimeUnit.MINUTES,
+                )
+                    .addTag(TAG_JOB)
+                    .addTag(TAG_AUTO)
+                    .build()
+
+                context.workManager.enqueueUniquePeriodicWork(TAG_AUTO, ExistingPeriodicWorkPolicy.UPDATE, request)
+            } else {
+                context.workManager.cancelUniqueWork(TAG_AUTO)
+            }
+        }
+
+        fun startNow(context: Context) {
+            val wm = context.workManager
+            if (wm.isRunning(TAG_JOB)) {
+                // Already running either as a scheduled or manual job
+                return
+            }
+            val request = OneTimeWorkRequestBuilder<SyncDataJob>()
+                .addTag(TAG_JOB)
+                .addTag(TAG_MANUAL)
+                .build()
+            context.workManager.enqueueUniqueWork(TAG_MANUAL, ExistingWorkPolicy.KEEP, request)
+        }
+
+        fun stop(context: Context) {
+            val wm = context.workManager
+            val workQuery = WorkQuery.Builder.fromTags(listOf(TAG_JOB, TAG_AUTO, TAG_MANUAL))
+                .addStates(listOf(WorkInfo.State.RUNNING))
+                .build()
+            wm.getWorkInfos(workQuery).get()
+                // Should only return one work but just in case
+                .forEach {
+                    wm.cancelWorkById(it.id)
+
+                    // Re-enqueue cancelled scheduled work
+                    if (it.tags.contains(TAG_AUTO)) {
+                        setupTask(context)
+                    }
+                }
+        }
+    }
+}
@@ -0,0 +1,349 @@
+package eu.kanade.tachiyomi.data.sync
+
+import android.content.Context
+import android.net.Uri
+import eu.kanade.domain.sync.SyncPreferences
+import eu.kanade.tachiyomi.data.backup.create.BackupCreator
+import eu.kanade.tachiyomi.data.backup.create.BackupOptions
+import eu.kanade.tachiyomi.data.backup.models.Backup
+import eu.kanade.tachiyomi.data.backup.models.BackupChapter
+import eu.kanade.tachiyomi.data.backup.models.BackupManga
+import eu.kanade.tachiyomi.data.backup.models.BackupSerializer
+import eu.kanade.tachiyomi.data.backup.restore.BackupRestoreJob
+import eu.kanade.tachiyomi.data.backup.restore.RestoreOptions
+import eu.kanade.tachiyomi.data.backup.restore.restorers.MangaRestorer
+import eu.kanade.tachiyomi.data.sync.service.GoogleDriveSyncService
+import eu.kanade.tachiyomi.data.sync.service.SyncData
+import eu.kanade.tachiyomi.data.sync.service.SyncYomiSyncService
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.protobuf.ProtoBuf
+import logcat.LogPriority
+import logcat.logcat
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.data.Chapters
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.data.manga.MangaMapper.mapManga
+import tachiyomi.domain.category.interactor.GetCategories
+import tachiyomi.domain.manga.model.Manga
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.io.File
+import java.io.IOException
+import java.util.Date
+import kotlin.system.measureTimeMillis
+
+/**
+ * A manager to handle synchronization tasks in the app, such as updating
+ * sync preferences and performing synchronization with a remote server.
+ *
+ * @property context The application context.
+ */
+class SyncManager(
+    private val context: Context,
+    private val handler: DatabaseHandler = Injekt.get(),
+    private val syncPreferences: SyncPreferences = Injekt.get(),
+    private var json: Json = Json {
+        encodeDefaults = true
+        ignoreUnknownKeys = true
+    },
+    private val getCategories: GetCategories = Injekt.get(),
+) {
+    private val backupCreator: BackupCreator = BackupCreator(context, false)
+    private val notifier: SyncNotifier = SyncNotifier(context)
+    private val mangaRestorer: MangaRestorer = MangaRestorer()
+
+    enum class SyncService(val value: Int) {
+        NONE(0),
+        SYNCYOMI(1),
+        GOOGLE_DRIVE(2),
+        ;
+
+        companion object {
+            fun fromInt(value: Int) = entries.firstOrNull { it.value == value } ?: NONE
+        }
+    }
+
+    /**
+     * Syncs data with a sync service.
+     *
+     * This function retrieves local data (favorites, manga, extensions, and categories)
+     * from the database using the BackupManager, then synchronizes the data with a sync service.
+     */
+    suspend fun syncData() {
+        // Reset isSyncing in case it was left over or failed syncing during restore.
+        handler.await(inTransaction = true) {
+            mangasQueries.resetIsSyncing()
+            chaptersQueries.resetIsSyncing()
+        }
+
+        val syncOptions = syncPreferences.getSyncSettings()
+        val databaseManga = getAllMangaThatNeedsSync()
+
+        val backupOptions = BackupOptions(
+            libraryEntries = syncOptions.libraryEntries,
+            categories = syncOptions.categories,
+            chapters = syncOptions.chapters,
+            tracking = syncOptions.tracking,
+            history = syncOptions.history,
+            appSettings = syncOptions.appSettings,
+            sourceSettings = syncOptions.sourceSettings,
+            privateSettings = syncOptions.privateSettings,
+
+            // SY -->
+            customInfo = syncOptions.customInfo,
+            readEntries = syncOptions.readEntries,
+            // SY <--
+        )
+
+        logcat(LogPriority.DEBUG) { "Begin create backup" }
+        val backup = Backup(
+            backupManga = backupCreator.backupMangas(databaseManga, backupOptions),
+            backupCategories = backupCreator.backupCategories(backupOptions),
+            backupSources = backupCreator.backupSources(databaseManga),
+            backupPreferences = backupCreator.backupAppPreferences(backupOptions),
+            backupSourcePreferences = backupCreator.backupSourcePreferences(backupOptions),
+
+            // SY -->
+            backupSavedSearches = backupCreator.backupSavedSearches(),
+            // SY <--
+        )
+        logcat(LogPriority.DEBUG) { "End create backup" }
+
+        // Create the SyncData object
+        val syncData = SyncData(
+            deviceId = syncPreferences.uniqueDeviceID(),
+            backup = backup,
+        )
+
+        // Handle sync based on the selected service
+        val syncService = when (val syncService = SyncService.fromInt(syncPreferences.syncService().get())) {
+            SyncService.SYNCYOMI -> {
+                SyncYomiSyncService(
+                    context,
+                    json,
+                    syncPreferences,
+                    notifier,
+                )
+            }
+
+            SyncService.GOOGLE_DRIVE -> {
+                GoogleDriveSyncService(context, json, syncPreferences)
+            }
+
+            else -> {
+                logcat(LogPriority.ERROR) { "Invalid sync service type: $syncService" }
+                null
+            }
+        }
+
+        val remoteBackup = syncService?.doSync(syncData)
+
+        if (remoteBackup == null) {
+            logcat(LogPriority.DEBUG) { "Skip restore due to network issues" }
+            // should we call showSyncError?
+            return
+        }
+
+        if (remoteBackup === syncData.backup){
+            // nothing changed
+            logcat(LogPriority.DEBUG) { "Skip restore due to remote was overwrite from local" }
+            syncPreferences.lastSyncTimestamp().set(Date().time)
+            notifier.showSyncSuccess("Sync completed successfully")
+            return
+        }
+
+        // Stop the sync early if the remote backup is null or empty
+        if (remoteBackup.backupManga?.size == 0) {
+            notifier.showSyncError("No data found on remote server.")
+            return
+        }
+
+        // Check if it's first sync based on lastSyncTimestamp
+        if (syncPreferences.lastSyncTimestamp().get() == 0L && databaseManga.isNotEmpty()) {
+            // It's first sync no need to restore data. (just update remote data)
+            syncPreferences.lastSyncTimestamp().set(Date().time)
+            notifier.showSyncSuccess("Updated remote data successfully")
+            return
+        }
+
+        val (filteredFavorites, nonFavorites) = filterFavoritesAndNonFavorites(remoteBackup)
+        updateNonFavorites(nonFavorites)
+
+        val newSyncData = backup.copy(
+            backupManga = filteredFavorites,
+            backupCategories = remoteBackup.backupCategories,
+            backupSources = remoteBackup.backupSources,
+            backupPreferences = remoteBackup.backupPreferences,
+            backupSourcePreferences = remoteBackup.backupSourcePreferences,
+
+            // SY -->
+            backupSavedSearches = remoteBackup.backupSavedSearches,
+            // SY <--
+        )
+
+        // It's local sync no need to restore data. (just update remote data)
+        if (filteredFavorites.isEmpty()) {
+            // update the sync timestamp
+            syncPreferences.lastSyncTimestamp().set(Date().time)
+            notifier.showSyncSuccess("Sync completed successfully")
+            return
+        }
+
+        val backupUri = writeSyncDataToCache(context, newSyncData)
+        logcat(LogPriority.DEBUG) { "Got Backup Uri: $backupUri" }
+        if (backupUri != null) {
+            BackupRestoreJob.start(
+                context,
+                backupUri,
+                sync = true,
+                options = RestoreOptions(
+                    appSettings = true,
+                    sourceSettings = true,
+                    library = true,
+                ),
+            )
+
+            // update the sync timestamp
+            syncPreferences.lastSyncTimestamp().set(Date().time)
+        } else {
+            logcat(LogPriority.ERROR) { "Failed to write sync data to file" }
+        }
+    }
+
+    private fun writeSyncDataToCache(context: Context, backup: Backup): Uri? {
+        val cacheFile = File(context.cacheDir, "tachiyomi_sync_data.proto.gz")
+        return try {
+            cacheFile.outputStream().use { output ->
+                output.write(ProtoBuf.encodeToByteArray(BackupSerializer, backup))
+                Uri.fromFile(cacheFile)
+            }
+        } catch (e: IOException) {
+            logcat(LogPriority.ERROR, throwable = e) { "Failed to write sync data to cache" }
+            null
+        }
+    }
+
+    /**
+     * Retrieves all manga from the local database.
+     *
+     * @return a list of all manga stored in the database
+     */
+    private suspend fun getAllMangaFromDB(): List<Manga> {
+        return handler.awaitList { mangasQueries.getAllManga(::mapManga) }
+    }
+
+    private suspend fun getAllMangaThatNeedsSync(): List<Manga> {
+        return handler.awaitList { mangasQueries.getMangasWithFavoriteTimestamp(::mapManga) }
+    }
+
+    private suspend fun isMangaDifferent(localManga: Manga, remoteManga: BackupManga): Boolean {
+        val localChapters = handler.await { chaptersQueries.getChaptersByMangaId(localManga.id, 0).executeAsList() }
+        val localCategories = getCategories.await(localManga.id).map { it.order }
+
+        if (areChaptersDifferent(localChapters, remoteManga.chapters)) {
+            return true
+        }
+
+        if (localManga.version != remoteManga.version) {
+            return true
+        }
+
+        if (localCategories.toSet() != remoteManga.categories.toSet()) {
+            return true
+        }
+
+        return false
+    }
+
+    private fun areChaptersDifferent(localChapters: List<Chapters>, remoteChapters: List<BackupChapter>): Boolean {
+        val localChapterMap = localChapters.associateBy { it.url }
+        val remoteChapterMap = remoteChapters.associateBy { it.url }
+
+        if (localChapterMap.size != remoteChapterMap.size) {
+            return true
+        }
+
+        for ((url, localChapter) in localChapterMap) {
+            val remoteChapter = remoteChapterMap[url]
+
+            // If a matching remote chapter doesn't exist, or the version numbers are different, consider them different
+            if (remoteChapter == null || localChapter.version != remoteChapter.version) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    /**
+     * Filters the favorite and non-favorite manga from the backup and checks
+     * if the favorite manga is different from the local database.
+     * @param backup the Backup object containing the backup data.
+     * @return a Pair of lists, where the first list contains different favorite manga
+     * and the second list contains non-favorite manga.
+     */
+    private suspend fun filterFavoritesAndNonFavorites(backup: Backup): Pair<List<BackupManga>, List<BackupManga>> {
+        val favorites = mutableListOf<BackupManga>()
+        val nonFavorites = mutableListOf<BackupManga>()
+        val logTag = "filterFavoritesAndNonFavorites"
+
+        val elapsedTimeMillis = measureTimeMillis {
+            val databaseManga = getAllMangaFromDB()
+            val localMangaMap = databaseManga.associateBy {
+                Triple(it.source, it.url, it.title)
+            }
+
+            logcat(LogPriority.DEBUG, logTag) { "Starting to filter favorites and non-favorites from backup data." }
+
+            backup.backupManga.forEach { remoteManga ->
+                val compositeKey = Triple(remoteManga.source, remoteManga.url, remoteManga.title)
+                val localManga = localMangaMap[compositeKey]
+                when {
+                    // Checks if the manga is in favorites and needs updating or adding
+                    remoteManga.favorite -> {
+                        if (localManga == null || isMangaDifferent(localManga, remoteManga)) {
+                            logcat(LogPriority.DEBUG, logTag) { "Adding to favorites: ${remoteManga.title}" }
+                            favorites.add(remoteManga)
+                        } else {
+                            logcat(LogPriority.DEBUG, logTag) { "Already up-to-date favorite: ${remoteManga.title}" }
+                        }
+                    }
+                    // Handle non-favorites
+                    !remoteManga.favorite -> {
+                        logcat(LogPriority.DEBUG, logTag) { "Adding to non-favorites: ${remoteManga.title}" }
+                        nonFavorites.add(remoteManga)
+                    }
+                }
+            }
+        }
+
+        val minutes = elapsedTimeMillis / 60000
+        val seconds = (elapsedTimeMillis % 60000) / 1000
+        logcat(LogPriority.DEBUG, logTag) {
+            "Filtering completed in ${minutes}m ${seconds}s. Favorites found: ${favorites.size}, " +
+                "Non-favorites found: ${nonFavorites.size}"
+        }
+
+        return Pair(favorites, nonFavorites)
+    }
+
+    /**
+     * Updates the non-favorite manga in the local database with their favorite status from the backup.
+     * @param nonFavorites the list of non-favorite BackupManga objects from the backup.
+     */
+    private suspend fun updateNonFavorites(nonFavorites: List<BackupManga>) {
+        val localMangaList = getAllMangaFromDB()
+
+        val localMangaMap = localMangaList.associateBy { Triple(it.source, it.url, it.title) }
+
+        nonFavorites.forEach { nonFavorite ->
+            val key = Triple(nonFavorite.source, nonFavorite.url, nonFavorite.title)
+            localMangaMap[key]?.let { localManga ->
+                if (localManga.favorite != nonFavorite.favorite) {
+                    val updatedManga = localManga.copy(favorite = nonFavorite.favorite)
+                    mangaRestorer.updateManga(updatedManga)
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,86 @@
+package eu.kanade.tachiyomi.data.sync
+
+import android.content.Context
+import android.graphics.BitmapFactory
+import androidx.core.app.NotificationCompat
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.core.security.SecurityPreferences
+import eu.kanade.tachiyomi.data.notification.NotificationReceiver
+import eu.kanade.tachiyomi.data.notification.Notifications
+import eu.kanade.tachiyomi.util.system.cancelNotification
+import eu.kanade.tachiyomi.util.system.notificationBuilder
+import eu.kanade.tachiyomi.util.system.notify
+import uy.kohesive.injekt.injectLazy
+
+class SyncNotifier(private val context: Context) {
+
+    private val preferences: SecurityPreferences by injectLazy()
+
+    private val progressNotificationBuilder = context.notificationBuilder(
+        Notifications.CHANNEL_BACKUP_RESTORE_PROGRESS,
+    ) {
+        setLargeIcon(BitmapFactory.decodeResource(context.resources, R.mipmap.ic_launcher))
+        setSmallIcon(R.drawable.ic_tachi)
+        setAutoCancel(false)
+        setOngoing(true)
+        setOnlyAlertOnce(true)
+    }
+
+    private val completeNotificationBuilder = context.notificationBuilder(
+        Notifications.CHANNEL_BACKUP_RESTORE_PROGRESS,
+    ) {
+        setLargeIcon(BitmapFactory.decodeResource(context.resources, R.mipmap.ic_launcher))
+        setSmallIcon(R.drawable.ic_tachi)
+        setAutoCancel(false)
+    }
+
+    private fun NotificationCompat.Builder.show(id: Int) {
+        context.notify(id, build())
+    }
+
+    fun showSyncProgress(content: String = "", progress: Int = 0, maxAmount: Int = 100): NotificationCompat.Builder {
+        val builder = with(progressNotificationBuilder) {
+            setContentTitle(context.getString(R.string.syncing_library))
+
+            if (!preferences.hideNotificationContent().get()) {
+                setContentText(content)
+            }
+
+            setProgress(maxAmount, progress, true)
+            setOnlyAlertOnce(true)
+
+            clearActions()
+            addAction(
+                R.drawable.ic_close_24dp,
+                context.getString(R.string.action_cancel),
+                NotificationReceiver.cancelSyncPendingBroadcast(context, Notifications.ID_RESTORE_PROGRESS),
+            )
+        }
+
+        builder.show(Notifications.ID_RESTORE_PROGRESS)
+
+        return builder
+    }
+
+    fun showSyncError(error: String?) {
+        context.cancelNotification(Notifications.ID_RESTORE_PROGRESS)
+
+        with(completeNotificationBuilder) {
+            setContentTitle(context.getString(R.string.sync_error))
+            setContentText(error)
+
+            show(Notifications.ID_RESTORE_COMPLETE)
+        }
+    }
+
+    fun showSyncSuccess(message: String?) {
+        context.cancelNotification(Notifications.ID_RESTORE_PROGRESS)
+
+        with(completeNotificationBuilder) {
+            setContentTitle(context.getString(R.string.sync_complete))
+            setContentText(message)
+
+            show(Notifications.ID_RESTORE_COMPLETE)
+        }
+    }
+}
@@ -0,0 +1,63 @@
+package eu.kanade.tachiyomi.data.sync.models
+
+import dev.icerock.moko.resources.StringResource
+import kotlinx.collections.immutable.persistentListOf
+import tachiyomi.i18n.sy.SYMR
+
+data class SyncTriggerOptions(
+    val syncOnChapterRead: Boolean = false,
+    val syncOnChapterOpen: Boolean = false,
+    val syncOnAppStart: Boolean = false,
+    val syncOnAppResume: Boolean = false,
+) {
+    fun asBooleanArray() = booleanArrayOf(
+        syncOnChapterRead,
+        syncOnChapterOpen,
+        syncOnAppStart,
+        syncOnAppResume,
+    )
+
+    fun anyEnabled() = syncOnChapterRead ||
+        syncOnChapterOpen ||
+        syncOnAppStart ||
+        syncOnAppResume
+
+    companion object {
+        val mainOptions = persistentListOf(
+            Entry(
+                label = SYMR.strings.sync_on_chapter_read,
+                getter = SyncTriggerOptions::syncOnChapterRead,
+                setter = { options, enabled -> options.copy(syncOnChapterRead = enabled) },
+            ),
+            Entry(
+                label = SYMR.strings.sync_on_chapter_open,
+                getter = SyncTriggerOptions::syncOnChapterOpen,
+                setter = { options, enabled -> options.copy(syncOnChapterOpen = enabled) },
+            ),
+            Entry(
+                label = SYMR.strings.sync_on_app_start,
+                getter = SyncTriggerOptions::syncOnAppStart,
+                setter = { options, enabled -> options.copy(syncOnAppStart = enabled) },
+            ),
+            Entry(
+                label = SYMR.strings.sync_on_app_resume,
+                getter = SyncTriggerOptions::syncOnAppResume,
+                setter = { options, enabled -> options.copy(syncOnAppResume = enabled) },
+            ),
+        )
+
+        fun fromBooleanArray(array: BooleanArray) = SyncTriggerOptions(
+            syncOnChapterRead = array[0],
+            syncOnChapterOpen = array[1],
+            syncOnAppStart = array[2],
+            syncOnAppResume = array[3],
+        )
+    }
+
+    data class Entry(
+        val label: StringResource,
+        val getter: (SyncTriggerOptions) -> Boolean,
+        val setter: (SyncTriggerOptions, Boolean) -> SyncTriggerOptions,
+        val enabled: (SyncTriggerOptions) -> Boolean = { true },
+    )
+}
@@ -0,0 +1,539 @@
+package eu.kanade.tachiyomi.data.sync.service
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import com.google.api.client.auth.oauth2.TokenResponseException
+import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow
+import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeTokenRequest
+import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets
+import com.google.api.client.googleapis.auth.oauth2.GoogleCredential
+import com.google.api.client.googleapis.auth.oauth2.GoogleTokenResponse
+import com.google.api.client.http.ByteArrayContent
+import com.google.api.client.http.InputStreamContent
+import com.google.api.client.http.javanet.NetHttpTransport
+import com.google.api.client.json.JsonFactory
+import com.google.api.client.json.jackson2.JacksonFactory
+import com.google.api.services.drive.Drive
+import com.google.api.services.drive.DriveScopes
+import com.google.api.services.drive.model.File
+import eu.kanade.domain.sync.SyncPreferences
+import eu.kanade.tachiyomi.data.backup.models.Backup
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
+import kotlinx.serialization.json.encodeToStream
+import logcat.LogPriority
+import logcat.logcat
+import tachiyomi.core.common.i18n.stringResource
+import tachiyomi.core.common.util.lang.withIOContext
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.i18n.MR
+import tachiyomi.i18n.sy.SYMR
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.io.IOException
+import java.io.PipedInputStream
+import java.io.PipedOutputStream
+import java.time.Instant
+import java.util.zip.GZIPInputStream
+import java.util.zip.GZIPOutputStream
+
+class GoogleDriveSyncService(context: Context, json: Json, syncPreferences: SyncPreferences) : SyncService(
+    context,
+    json,
+    syncPreferences,
+) {
+    constructor(context: Context) : this(
+        context,
+        Json {
+            encodeDefaults = true
+            ignoreUnknownKeys = true
+        },
+        Injekt.get<SyncPreferences>(),
+    )
+
+    enum class DeleteSyncDataStatus {
+        NOT_INITIALIZED,
+        NO_FILES,
+        SUCCESS,
+        ERROR,
+    }
+
+    private val appName = context.stringResource(MR.strings.app_name)
+
+    private val remoteFileName = "${appName}_sync_data.gz"
+
+    private val lockFileName = "${appName}_sync.lock"
+
+    private val googleDriveService = GoogleDriveService(context)
+
+    override suspend fun doSync(syncData: SyncData): Backup? {
+        beforeSync()
+
+        try {
+            val remoteSData = pullSyncData()
+
+            if (remoteSData != null ){
+                // Get local unique device ID
+                val localDeviceId = syncPreferences.uniqueDeviceID()
+                val lastSyncDeviceId = remoteSData.deviceId
+
+                // Log the device IDs
+                logcat(LogPriority.DEBUG, "SyncService") {
+                    "Local device ID: $localDeviceId, Last sync device ID: $lastSyncDeviceId"
+                }
+
+                // check if the last sync was done by the same device if so overwrite the remote data with the local data
+                return if (lastSyncDeviceId == localDeviceId) {
+                    pushSyncData(syncData)
+                    syncData.backup
+                }else{
+                    // Merge the local and remote sync data
+                    val mergedSyncData = mergeSyncData(syncData, remoteSData)
+                    pushSyncData(mergedSyncData)
+                    mergedSyncData.backup
+                }
+            }
+
+            pushSyncData(syncData)
+            return syncData.backup
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, "SyncService") { "Error syncing: ${e.message}" }
+            return null
+        }
+    }
+
+    private suspend fun beforeSync() {
+        try {
+            googleDriveService.refreshToken()
+            val drive = googleDriveService.driveService
+                ?: throw Exception(context.stringResource(SYMR.strings.google_drive_not_signed_in))
+
+            var backoff = 1000L
+            var retries = 0 // Retry counter
+            val maxRetries = 10 // Maximum number of retries
+
+            while (retries < maxRetries) {
+                val lockFiles = findLockFile(drive)
+                logcat(LogPriority.DEBUG) { "Found ${lockFiles.size} lock file(s)" }
+
+                when {
+                    lockFiles.isEmpty() -> {
+                        logcat(LogPriority.DEBUG) { "No lock file found, creating a new one" }
+                        createLockFile(drive)
+                        break
+                    }
+                    lockFiles.size == 1 -> {
+                        val lockFile = lockFiles.first()
+                        val createdTime = Instant.parse(lockFile.createdTime.toString())
+                        val ageMinutes = java.time.Duration.between(createdTime, Instant.now()).toMinutes()
+                        logcat(LogPriority.DEBUG) { "Lock file age: $ageMinutes minutes" }
+                        if (ageMinutes <= 3) {
+                            logcat(LogPriority.DEBUG) { "Lock file is new, proceeding with sync" }
+                            break
+                        } else {
+                            logcat(LogPriority.DEBUG) { "Lock file is old, deleting and creating a new one" }
+                            deleteLockFile(drive)
+                            createLockFile(drive)
+                            break
+                        }
+                    }
+                    else -> {
+                        logcat(LogPriority.DEBUG) { "Multiple lock files found, applying backoff" }
+                        delay(backoff) // Apply backoff strategy
+                        backoff = (backoff * 2).coerceAtMost(16000L)
+                        logcat(LogPriority.DEBUG) { "Backoff increased to $backoff milliseconds" }
+                    }
+                }
+                retries++ // Increment retry counter
+                logcat(LogPriority.DEBUG) { "Loop iteration complete, retry count: $retries, backoff time: $backoff" }
+            }
+
+            if (retries >= maxRetries) {
+                logcat(LogPriority.ERROR) { "Max retries reached, exiting sync process" }
+                throw Exception(context.stringResource(SYMR.strings.error_before_sync_gdrive) + ": Max retries reached.")
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e) { "Error in GoogleDrive beforeSync" }
+            throw Exception(context.stringResource(SYMR.strings.error_before_sync_gdrive) + ": ${e.message}", e)
+        }
+    }
+
+    private fun pullSyncData(): SyncData? {
+        val drive = googleDriveService.driveService ?:
+        throw Exception(context.stringResource(SYMR.strings.google_drive_not_signed_in))
+
+        val fileList = getAppDataFileList(drive)
+        if (fileList.isEmpty()) {
+            logcat(LogPriority.INFO) { "No files found in app data" }
+            return null
+        }
+
+        val gdriveFileId = fileList[0].id
+        logcat(LogPriority.DEBUG) { "Google Drive File ID: $gdriveFileId" }
+
+        try {
+            drive.files().get(gdriveFileId).executeMediaAsInputStream().use { inputStream ->
+                GZIPInputStream(inputStream).use { gzipInputStream ->
+                    return Json.decodeFromStream(SyncData.serializer(), gzipInputStream)
+                }
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e) { "Error downloading file" }
+            throw Exception("Failed to download sync data: ${e.message}", e)
+        }
+    }
+
+    private suspend fun pushSyncData(syncData: SyncData) {
+        val drive = googleDriveService.driveService
+            ?: throw Exception(context.stringResource(SYMR.strings.google_drive_not_signed_in))
+
+        val fileList = getAppDataFileList(drive)
+
+        PipedOutputStream().use { pos ->
+            PipedInputStream(pos).use { pis ->
+                withIOContext {
+                    // Start a coroutine or a background thread to write JSON to the PipedOutputStream
+                    launch {
+                        GZIPOutputStream(pos).use { gzipOutputStream ->
+                            Json.encodeToStream(SyncData.serializer(), syncData, gzipOutputStream)
+                        }
+                    }
+
+                    if (fileList.isNotEmpty()) {
+                        val fileId = fileList[0].id
+                        val mediaContent = InputStreamContent("application/gzip", pis)
+                        drive.files().update(fileId, null, mediaContent).execute()
+                        logcat(LogPriority.DEBUG) { "Updated existing sync data file in Google Drive with file ID: $fileId" }
+                    } else {
+                        val fileMetadata = File().apply {
+                            name = remoteFileName
+                            mimeType = "application/gzip"
+                            parents = listOf("appDataFolder")
+                        }
+                        val mediaContent = InputStreamContent("application/gzip", pis)
+                        val uploadedFile = drive.files().create(fileMetadata, mediaContent)
+                            .setFields("id")
+                            .execute()
+                        logcat(LogPriority.DEBUG) { "Created new sync data file in Google Drive with file ID: ${uploadedFile.id}" }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun getAppDataFileList(drive: Drive): MutableList<File> {
+        try {
+            // Search for the existing file by name in the appData folder
+            val query = "mimeType='application/gzip' and name = '$remoteFileName'"
+            val fileList = drive.files()
+                .list()
+                .setSpaces("appDataFolder")
+                .setQ(query)
+                .setFields("files(id, name, createdTime)")
+                .execute()
+                .files
+            logcat { "AppData folder file list: $fileList" }
+
+            return fileList
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e) { "Error no sync data found in appData folder" }
+            return mutableListOf()
+        }
+    }
+
+    private fun createLockFile(drive: Drive) {
+        try {
+            val fileMetadata = File().apply {
+                name = lockFileName
+                mimeType = "text/plain"
+                parents = listOf("appDataFolder")
+            }
+
+            // Create an empty content to upload as the lock file
+            val emptyContent = ByteArrayContent.fromString("text/plain", "")
+
+            val file = drive.files().create(fileMetadata, emptyContent)
+                .setFields("id, name, createdTime")
+                .execute()
+
+            logcat { "Created lock file with ID: ${file.id}" }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e) { "Error creating lock file" }
+            throw Exception(e.message, e)
+        }
+    }
+
+    private fun findLockFile(drive: Drive): MutableList<File> {
+        return try {
+            val query = "mimeType='text/plain' and name = '$lockFileName'"
+            val fileList = drive.files()
+                .list()
+                .setSpaces("appDataFolder")
+                .setQ(query)
+                .setFields("files(id, name, createdTime)")
+                .execute().files
+            logcat { "Lock file search result: $fileList" }
+            fileList
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e) { "Error finding lock file" }
+            mutableListOf()
+        }
+    }
+
+    private fun deleteLockFile(drive: Drive) {
+        try {
+            val lockFiles = findLockFile(drive)
+
+            if (lockFiles.isNotEmpty()) {
+                for (file in lockFiles) {
+                    drive.files().delete(file.id).execute()
+                    logcat { "Deleted lock file with ID: ${file.id}" }
+                }
+            } else {
+                logcat { "No lock file found to delete." }
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e) { "Error deleting lock file" }
+            throw Exception(context.stringResource(SYMR.strings.error_deleting_google_drive_lock_file), e)
+        }
+    }
+
+    suspend fun deleteSyncDataFromGoogleDrive(): DeleteSyncDataStatus {
+        val drive = googleDriveService.driveService
+
+        if (drive == null) {
+            logcat(LogPriority.ERROR) { "Google Drive service not initialized" }
+            return DeleteSyncDataStatus.NOT_INITIALIZED
+        }
+        googleDriveService.refreshToken()
+
+        return withIOContext {
+            try {
+                val appDataFileList = getAppDataFileList(drive)
+
+                if (appDataFileList.isEmpty()) {
+                    this@GoogleDriveSyncService
+                        .logcat(LogPriority.DEBUG) { "No sync data file found in appData folder of Google Drive" }
+                    DeleteSyncDataStatus.NO_FILES
+                } else {
+                    for (file in appDataFileList) {
+                        drive.files().delete(file.id).execute()
+                        this@GoogleDriveSyncService.logcat(
+                            LogPriority.DEBUG,
+                        ) { "Deleted sync data file in appData folder of Google Drive with file ID: ${file.id}" }
+                    }
+                    DeleteSyncDataStatus.SUCCESS
+                }
+            } catch (e: Exception) {
+                this@GoogleDriveSyncService.logcat(LogPriority.ERROR, throwable = e) {
+                    "Error occurred while interacting with Google Drive"
+                }
+                DeleteSyncDataStatus.ERROR
+            }
+        }
+    }
+}
+
+class GoogleDriveService(private val context: Context) {
+    var driveService: Drive? = null
+    companion object {
+        const val REDIRECT_URI = "eu.kanade.google.oauth:/oauth2redirect"
+    }
+    private val syncPreferences = Injekt.get<SyncPreferences>()
+
+    init {
+        initGoogleDriveService()
+    }
+
+    /**
+     * Initializes the Google Drive service by obtaining the access token and refresh token from the SyncPreferences
+     * and setting up the service using the obtained tokens.
+     */
+    private fun initGoogleDriveService() {
+        val accessToken = syncPreferences.googleDriveAccessToken().get()
+        val refreshToken = syncPreferences.googleDriveRefreshToken().get()
+
+        if (accessToken == "" || refreshToken == "") {
+            driveService = null
+            return
+        }
+
+        setupGoogleDriveService(accessToken, refreshToken)
+    }
+
+    /**
+     * Launches an Intent to open the user's default browser for Google Drive sign-in.
+     * The Intent carries the authorization URL, which prompts the user to sign in
+     * and grant the application permission to access their Google Drive account.
+     * @return An Intent configured to launch a browser for Google Drive OAuth sign-in.
+     */
+    fun getSignInIntent(): Intent {
+        val authorizationUrl = generateAuthorizationUrl()
+
+        return Intent(Intent.ACTION_VIEW).apply {
+            data = Uri.parse(authorizationUrl)
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+    }
+
+    /**
+     * Generates the authorization URL required for the user to grant the application
+     * permission to access their Google Drive account.
+     * Sets the approval prompt to "force" to ensure that the user is always prompted to grant access,
+     * even if they have previously granted access.
+     * @return The authorization URL.
+     */
+    private fun generateAuthorizationUrl(): String {
+        val jsonFactory: JsonFactory = JacksonFactory.getDefaultInstance()
+        val secrets = GoogleClientSecrets.load(
+            jsonFactory,
+            context.assets.open("client_secrets.json").reader(),
+        )
+
+        val flow = GoogleAuthorizationCodeFlow.Builder(
+            NetHttpTransport(),
+            jsonFactory,
+            secrets,
+            listOf(DriveScopes.DRIVE_FILE, DriveScopes.DRIVE_APPDATA),
+        ).setAccessType("offline").build()
+
+        return flow.newAuthorizationUrl()
+            .setRedirectUri(REDIRECT_URI)
+            .setApprovalPrompt("force")
+            .build()
+    }
+    internal suspend fun refreshToken() = withIOContext {
+        val refreshToken = syncPreferences.googleDriveRefreshToken().get()
+
+        val jsonFactory: JsonFactory = JacksonFactory.getDefaultInstance()
+        val secrets = GoogleClientSecrets.load(
+            jsonFactory,
+            context.assets.open("client_secrets.json").reader(),
+        )
+
+        val credential = GoogleCredential.Builder()
+            .setJsonFactory(jsonFactory)
+            .setTransport(NetHttpTransport())
+            .setClientSecrets(secrets)
+            .build()
+
+        if (refreshToken == "") {
+            throw Exception(context.stringResource(SYMR.strings.google_drive_not_signed_in))
+        }
+
+        credential.refreshToken = refreshToken
+
+        try {
+            credential.refreshToken()
+            val newAccessToken = credential.accessToken
+            // Save the new access token
+            syncPreferences.googleDriveAccessToken().set(newAccessToken)
+            setupGoogleDriveService(newAccessToken, credential.refreshToken)
+        } catch (e: TokenResponseException) {
+            if (e.details.error == "invalid_grant") {
+                // The refresh token is invalid, prompt the user to sign in again
+                this@GoogleDriveService.logcat(LogPriority.ERROR, throwable = e) {
+                    "Refresh token is invalid, prompt user to sign in again"
+                }
+                throw e.message?.let { Exception(it, e) } ?: Exception("Unknown error", e)
+            } else {
+                // Token refresh failed; handle this situation
+                this@GoogleDriveService.logcat(LogPriority.ERROR) { "Failed to refresh access token ${e.message}" }
+                this@GoogleDriveService.logcat(LogPriority.ERROR) { "Google Drive sync will be disabled" }
+                throw e.message?.let { Exception(it, e) } ?: Exception("Unknown error", e)
+            }
+        } catch (e: IOException) {
+            // Token refresh failed; handle this situation
+            this@GoogleDriveService.logcat(LogPriority.ERROR, throwable = e) { "Failed to refresh access token" }
+            this@GoogleDriveService.logcat(LogPriority.ERROR) { "Google Drive sync will be disabled" }
+            throw e.message?.let { Exception(it, e) } ?: Exception("Unknown error", e)
+        }
+    }
+
+    /**
+     * Sets up the Google Drive service using the provided access token and refresh token.
+     * @param accessToken The access token obtained from the SyncPreferences.
+     * @param refreshToken The refresh token obtained from the SyncPreferences.
+     */
+    private fun setupGoogleDriveService(accessToken: String, refreshToken: String) {
+        val jsonFactory: JsonFactory = JacksonFactory.getDefaultInstance()
+        val secrets = GoogleClientSecrets.load(
+            jsonFactory,
+            context.assets.open("client_secrets.json").reader(),
+        )
+
+        val credential = GoogleCredential.Builder()
+            .setJsonFactory(jsonFactory)
+            .setTransport(NetHttpTransport())
+            .setClientSecrets(secrets)
+            .build()
+
+        credential.accessToken = accessToken
+        credential.refreshToken = refreshToken
+
+        driveService = Drive.Builder(
+            NetHttpTransport(),
+            jsonFactory,
+            credential,
+        ).setApplicationName(context.stringResource(MR.strings.app_name))
+            .build()
+    }
+
+    /**
+     * Handles the authorization code returned after the user has granted the application permission to access their
+     * Google Drive account.
+     * It obtains the access token and refresh token using the authorization code, saves the tokens to the
+     * SyncPreferences, sets up the Google Drive service using the obtained tokens, and initializes the service.
+     * @param authorizationCode The authorization code obtained from the OAuthCallbackServer.
+     * @param activity The current activity.
+     * @param onSuccess A callback function to be called on successful authorization.
+     * @param onFailure A callback function to be called on authorization failure.
+     */
+    fun handleAuthorizationCode(
+        authorizationCode: String,
+        activity: Activity,
+        onSuccess: () -> Unit,
+        onFailure: (String) -> Unit,
+    ) {
+        val jsonFactory: JsonFactory = JacksonFactory.getDefaultInstance()
+        val secrets = GoogleClientSecrets.load(
+            jsonFactory,
+            context.assets.open("client_secrets.json").reader(),
+        )
+
+        val tokenResponse: GoogleTokenResponse = GoogleAuthorizationCodeTokenRequest(
+            NetHttpTransport(),
+            jsonFactory,
+            secrets.installed.clientId,
+            secrets.installed.clientSecret,
+            authorizationCode,
+            REDIRECT_URI,
+        ).setGrantType("authorization_code").execute()
+
+        try {
+            // Save the access token and refresh token
+            val accessToken = tokenResponse.accessToken
+            val refreshToken = tokenResponse.refreshToken
+
+            // Save the tokens to SyncPreferences
+            syncPreferences.googleDriveAccessToken().set(accessToken)
+            syncPreferences.googleDriveRefreshToken().set(refreshToken)
+
+            setupGoogleDriveService(accessToken, refreshToken)
+            initGoogleDriveService()
+
+            activity.runOnUiThread {
+                onSuccess()
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e) { "Failed to handle authorization code" }
+            activity.runOnUiThread {
+                onFailure(e.localizedMessage ?: "Unknown error")
+            }
+        }
+    }
+}
@@ -0,0 +1,515 @@
+package eu.kanade.tachiyomi.data.sync.service
+
+import android.content.Context
+import eu.kanade.domain.sync.SyncPreferences
+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.BackupManga
+import eu.kanade.tachiyomi.data.backup.models.BackupPreference
+import eu.kanade.tachiyomi.data.backup.models.BackupSavedSearch
+import eu.kanade.tachiyomi.data.backup.models.BackupSource
+import eu.kanade.tachiyomi.data.backup.models.BackupSourcePreferences
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import logcat.LogPriority
+import logcat.logcat
+
+@Serializable
+data class SyncData(
+    val deviceId: String = "",
+    val backup: Backup? = null,
+)
+
+abstract class SyncService(
+    val context: Context,
+    val json: Json,
+    val syncPreferences: SyncPreferences,
+) {
+    abstract suspend fun doSync(syncData: SyncData): Backup?;
+
+    /**
+     * Merges the local and remote sync data into a single JSON string.
+     *
+     * @param localSyncData The SData containing the local sync data.
+     * @param remoteSyncData The SData containing the remote sync data.
+     * @return The JSON string containing the merged sync data.
+     */
+    protected fun mergeSyncData(localSyncData: SyncData, remoteSyncData: SyncData): SyncData {
+        val mergedCategoriesList =
+            mergeCategoriesLists(localSyncData.backup?.backupCategories, remoteSyncData.backup?.backupCategories)
+
+        val mergedMangaList = mergeMangaLists(
+            localSyncData.backup?.backupManga,
+            remoteSyncData.backup?.backupManga,
+            localSyncData.backup?.backupCategories ?: emptyList(),
+            remoteSyncData.backup?.backupCategories ?: emptyList(),
+            mergedCategoriesList)
+
+        val mergedSourcesList =
+            mergeSourcesLists(localSyncData.backup?.backupSources, remoteSyncData.backup?.backupSources)
+        val mergedPreferencesList =
+            mergePreferencesLists(localSyncData.backup?.backupPreferences, remoteSyncData.backup?.backupPreferences)
+        val mergedSourcePreferencesList = mergeSourcePreferencesLists(
+            localSyncData.backup?.backupSourcePreferences,
+            remoteSyncData.backup?.backupSourcePreferences,
+        )
+
+        // SY -->
+        val mergedSavedSearchesList = mergeSavedSearchesLists(
+            localSyncData.backup?.backupSavedSearches,
+            remoteSyncData.backup?.backupSavedSearches,
+        )
+        // SY <--
+
+        // Create the merged Backup object
+        val mergedBackup = Backup(
+            backupManga = mergedMangaList,
+            backupCategories = mergedCategoriesList,
+            backupSources = mergedSourcesList,
+            backupPreferences = mergedPreferencesList,
+            backupSourcePreferences = mergedSourcePreferencesList,
+
+            // SY -->
+            backupSavedSearches = mergedSavedSearchesList,
+            // SY <--
+        )
+
+        // Create the merged SData object
+        return SyncData(
+            deviceId = syncPreferences.uniqueDeviceID(),
+            backup = mergedBackup,
+        )
+    }
+
+    /**
+     * Merges two lists of BackupManga objects, selecting the most recent manga based on the lastModifiedAt value.
+     * If lastModifiedAt is null for a manga, it treats that manga as the oldest possible for comparison purposes.
+     * This function is designed to reconcile local and remote manga lists, ensuring the most up-to-date manga is retained.
+     *
+     * @param localMangaList The list of local BackupManga objects or null.
+     * @param remoteMangaList The list of remote BackupManga objects or null.
+     * @return A list of BackupManga objects, each representing the most recent version of the manga from either local or remote sources.
+     */
+    private fun mergeMangaLists(
+        localMangaList: List<BackupManga>?,
+        remoteMangaList: List<BackupManga>?,
+        localCategories: List<BackupCategory>,
+        remoteCategories: List<BackupCategory>,
+        mergedCategories: List<BackupCategory>,
+    ): List<BackupManga> {
+        val logTag = "MergeMangaLists"
+
+        val localMangaListSafe = localMangaList.orEmpty()
+        val remoteMangaListSafe = remoteMangaList.orEmpty()
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Starting merge. Local list size: ${localMangaListSafe.size}, Remote list size: ${remoteMangaListSafe.size}"
+        }
+
+        fun mangaCompositeKey(manga: BackupManga): String {
+            return "${manga.source}|${manga.url}|${manga.title.lowercase().trim()}|${manga.author?.lowercase()?.trim()}"
+        }
+
+        // Create maps using composite keys
+        val localMangaMap = localMangaListSafe.associateBy { mangaCompositeKey(it) }
+        val remoteMangaMap = remoteMangaListSafe.associateBy { mangaCompositeKey(it) }
+
+        val localCategoriesMapByOrder = localCategories.associateBy { it.order }
+        val remoteCategoriesMapByOrder = remoteCategories.associateBy { it.order }
+        val mergedCategoriesMapByName = mergedCategories.associateBy { it.name }
+
+        fun updateCategories(theManga: BackupManga, theMap: Map<Long, BackupCategory>): BackupManga {
+            return theManga.copy(categories = theManga.categories.mapNotNull {
+                theMap[it]?.let { category ->
+                    mergedCategoriesMapByName[category.name]?.order
+                }
+            })
+        }
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Starting merge. Local list size: ${localMangaListSafe.size}, Remote list size: ${remoteMangaListSafe.size}"
+        }
+
+        val mergedList = (localMangaMap.keys + remoteMangaMap.keys).distinct().mapNotNull { compositeKey ->
+            val local = localMangaMap[compositeKey]
+            val remote = remoteMangaMap[compositeKey]
+
+            // New version comparison logic
+            when {
+                local != null && remote == null -> updateCategories(local, localCategoriesMapByOrder)
+                local == null && remote != null -> updateCategories(remote, remoteCategoriesMapByOrder)
+                local != null && remote != null -> {
+                    // Compare versions to decide which manga to keep
+                    if (local.version >= remote.version) {
+                        logcat(LogPriority.DEBUG, logTag) {
+                            "Keeping local version of ${local.title} with merged chapters."
+                        }
+                        updateCategories(
+                            local.copy(chapters = mergeChapters(local.chapters, remote.chapters)),
+                            localCategoriesMapByOrder
+                        )
+                    } else {
+                        logcat(LogPriority.DEBUG, logTag) {
+                            "Keeping remote version of ${remote.title} with merged chapters."
+                        }
+                        updateCategories(
+                            remote.copy(chapters = mergeChapters(local.chapters, remote.chapters)),
+                            remoteCategoriesMapByOrder
+                        )
+                    }
+                }
+                else -> null // No manga found for key
+            }
+        }
+
+        // Counting favorites and non-favorites
+        val (favorites, nonFavorites) = mergedList.partition { it.favorite }
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Merge completed. Total merged manga: ${mergedList.size}, Favorites: ${favorites.size}, " +
+                "Non-Favorites: ${nonFavorites.size}"
+        }
+
+        return mergedList
+    }
+
+/**
+     * Merges two lists of BackupChapter objects, selecting the most recent chapter based on the lastModifiedAt value.
+     * If lastModifiedAt is null for a chapter, it treats that chapter as the oldest possible for comparison purposes.
+     * This function is designed to reconcile local and remote chapter lists, ensuring the most up-to-date chapter is retained.
+     *
+     * @param localChapters The list of local BackupChapter objects.
+     * @param remoteChapters The list of remote BackupChapter objects.
+     * @return A list of BackupChapter objects, each representing the most recent version of the chapter from either local or remote sources.
+     *
+     * - This function is used in scenarios where local and remote chapter lists need to be synchronized.
+     * - It iterates over the union of the URLs from both local and remote chapters.
+     * - For each URL, it compares the corresponding local and remote chapters based on the lastModifiedAt value.
+     * - If only one source (local or remote) has the chapter for a URL, that chapter is used.
+     * - If both sources have the chapter, the one with the more recent lastModifiedAt value is chosen.
+     * - If lastModifiedAt is null or missing, the chapter is considered the oldest for safety, ensuring that any chapter with a valid timestamp is preferred.
+     * - The resulting list contains the most recent chapters from the combined set of local and remote chapters.
+     */
+    private fun mergeChapters(
+        localChapters: List<BackupChapter>,
+        remoteChapters: List<BackupChapter>,
+    ): List<BackupChapter> {
+        val logTag = "MergeChapters"
+
+        fun chapterCompositeKey(chapter: BackupChapter): String {
+            return "${chapter.url}|${chapter.name}|${chapter.chapterNumber}"
+        }
+
+        val localChapterMap = localChapters.associateBy { chapterCompositeKey(it) }
+        val remoteChapterMap = remoteChapters.associateBy { chapterCompositeKey(it) }
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Starting chapter merge. Local chapters: ${localChapters.size}, Remote chapters: ${remoteChapters.size}"
+        }
+
+        // Merge both chapter maps based on version numbers
+        val mergedChapters = (localChapterMap.keys + remoteChapterMap.keys).distinct().mapNotNull { compositeKey ->
+            val localChapter = localChapterMap[compositeKey]
+            val remoteChapter = remoteChapterMap[compositeKey]
+
+            logcat(LogPriority.DEBUG, logTag) {
+                "Processing chapter key: $compositeKey. Local chapter: ${localChapter != null}, " +
+                    "Remote chapter: ${remoteChapter != null}"
+            }
+
+            when {
+                localChapter != null && remoteChapter == null -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Keeping local chapter: ${localChapter.name}." }
+                    localChapter
+                }
+                localChapter == null && remoteChapter != null -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Taking remote chapter: ${remoteChapter.name}." }
+                    remoteChapter
+                }
+                localChapter != null && remoteChapter != null -> {
+                    // Use version number to decide which chapter to keep
+                    val chosenChapter = if (localChapter.version >= remoteChapter.version) {
+                        localChapter
+                    } else {
+                        remoteChapter
+                    }
+                    logcat(LogPriority.DEBUG, logTag) {
+                        "Merging chapter: ${chosenChapter.name}. Chosen version from: ${
+                            if (localChapter.version >= remoteChapter.version) "Local" else "Remote"
+                        }, Local version: ${localChapter.version}, Remote version: ${remoteChapter.version}."
+                    }
+                    chosenChapter
+                }
+                else -> {
+                    logcat(LogPriority.DEBUG, logTag) {
+                        "No chapter found for composite key: $compositeKey. Skipping."
+                    }
+                    null
+                }
+            }
+        }
+
+        logcat(LogPriority.DEBUG, logTag) { "Chapter merge completed. Total merged chapters: ${mergedChapters.size}" }
+
+        return mergedChapters
+    }
+
+    /**
+     * Merges two lists of SyncCategory objects, prioritizing the category with the most recent order value.
+     *
+     * @param localCategoriesList The list of local SyncCategory objects.
+     * @param remoteCategoriesList The list of remote SyncCategory objects.
+     * @return The merged list of SyncCategory objects.
+     */
+    private fun mergeCategoriesLists(
+        localCategoriesList: List<BackupCategory>?,
+        remoteCategoriesList: List<BackupCategory>?,
+    ): List<BackupCategory> {
+        if (localCategoriesList == null) return remoteCategoriesList ?: emptyList()
+        if (remoteCategoriesList == null) return localCategoriesList
+        val localCategoriesMap = localCategoriesList.associateBy { it.name }
+        val remoteCategoriesMap = remoteCategoriesList.associateBy { it.name }
+
+        val mergedCategoriesMap = mutableMapOf<String, BackupCategory>()
+
+        localCategoriesMap.forEach { (name, localCategory) ->
+            val remoteCategory = remoteCategoriesMap[name]
+            if (remoteCategory != null) {
+                // Compare and merge local and remote categories
+                val mergedCategory = if (localCategory.order > remoteCategory.order) {
+                    localCategory
+                } else {
+                    remoteCategory
+                }
+                mergedCategoriesMap[name] = mergedCategory
+            } else {
+                // If the category is only in the local list, add it to the merged list
+                mergedCategoriesMap[name] = localCategory
+            }
+        }
+
+        // Add any categories from the remote list that are not in the local list
+        remoteCategoriesMap.forEach { (name, remoteCategory) ->
+            if (!mergedCategoriesMap.containsKey(name)) {
+                mergedCategoriesMap[name] = remoteCategory
+            }
+        }
+
+        return mergedCategoriesMap.values.toList()
+    }
+
+    private fun mergeSourcesLists(
+        localSources: List<BackupSource>?,
+        remoteSources: List<BackupSource>?
+    ): List<BackupSource> {
+        val logTag = "MergeSources"
+
+        // Create maps using sourceId as key
+        val localSourceMap = localSources?.associateBy { it.sourceId } ?: emptyMap()
+        val remoteSourceMap = remoteSources?.associateBy { it.sourceId } ?: emptyMap()
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Starting source merge. Local sources: ${localSources?.size}, Remote sources: ${remoteSources?.size}"
+        }
+
+        // Merge both source maps
+        val mergedSources = (localSourceMap.keys + remoteSourceMap.keys).distinct().mapNotNull { sourceId ->
+            val localSource = localSourceMap[sourceId]
+            val remoteSource = remoteSourceMap[sourceId]
+
+            logcat(LogPriority.DEBUG, logTag) {
+                "Processing source ID: $sourceId. Local source: ${localSource != null}, " +
+                    "Remote source: ${remoteSource != null}"
+            }
+
+            when {
+                localSource != null && remoteSource == null -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Using local source: ${localSource.name}." }
+                    localSource
+                }
+                remoteSource != null && localSource == null -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Using remote source: ${remoteSource.name}." }
+                    remoteSource
+                }
+                else -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Remote and local is not empty: $sourceId. Skipping." }
+                    null
+                }
+            }
+        }
+
+        logcat(LogPriority.DEBUG, logTag) { "Source merge completed. Total merged sources: ${mergedSources.size}" }
+
+        return mergedSources
+    }
+
+    private fun mergePreferencesLists(
+        localPreferences: List<BackupPreference>?,
+        remotePreferences: List<BackupPreference>?
+    ): List<BackupPreference> {
+        val logTag = "MergePreferences"
+
+        // Create maps using key as the unique identifier
+        val localPreferencesMap = localPreferences?.associateBy { it.key } ?: emptyMap()
+        val remotePreferencesMap = remotePreferences?.associateBy { it.key } ?: emptyMap()
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Starting preferences merge. Local preferences: ${localPreferences?.size}, " +
+                "Remote preferences: ${remotePreferences?.size}"
+        }
+
+        // Merge both preferences maps
+        val mergedPreferences = (localPreferencesMap.keys + remotePreferencesMap.keys).distinct().mapNotNull { key ->
+            val localPreference = localPreferencesMap[key]
+            val remotePreference = remotePreferencesMap[key]
+
+            logcat(LogPriority.DEBUG, logTag) {
+                "Processing preference key: $key. Local preference: ${localPreference != null}, " +
+                    "Remote preference: ${remotePreference != null}"
+            }
+
+            when {
+                localPreference != null && remotePreference == null -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Using local preference: ${localPreference.key}." }
+                    localPreference
+                }
+                remotePreference != null && localPreference == null -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Using remote preference: ${remotePreference.key}." }
+                    remotePreference
+                }
+                else -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Both remote and local have keys. Skipping: $key" }
+                    null
+                }
+            }
+        }
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Preferences merge completed. Total merged preferences: ${mergedPreferences.size}"
+        }
+
+        return mergedPreferences
+    }
+
+    private fun mergeSourcePreferencesLists(
+        localPreferences: List<BackupSourcePreferences>?,
+        remotePreferences: List<BackupSourcePreferences>?
+    ): List<BackupSourcePreferences> {
+        val logTag = "MergeSourcePreferences"
+
+        // Create maps using sourceKey as the unique identifier
+        val localPreferencesMap = localPreferences?.associateBy { it.sourceKey } ?: emptyMap()
+        val remotePreferencesMap = remotePreferences?.associateBy { it.sourceKey } ?: emptyMap()
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Starting source preferences merge. Local source preferences: ${localPreferences?.size}, " +
+                "Remote source preferences: ${remotePreferences?.size}"
+        }
+
+        // Merge both source preferences maps
+        val mergedSourcePreferences = (localPreferencesMap.keys + remotePreferencesMap.keys).distinct().mapNotNull { sourceKey ->
+            val localSourcePreference = localPreferencesMap[sourceKey]
+            val remoteSourcePreference = remotePreferencesMap[sourceKey]
+
+            logcat(LogPriority.DEBUG, logTag) {
+                "Processing source preference key: $sourceKey. " +
+                    "Local source preference: ${localSourcePreference != null}, " +
+                    "Remote source preference: ${remoteSourcePreference != null}"
+            }
+
+            when {
+                localSourcePreference != null && remoteSourcePreference == null -> {
+                    logcat(LogPriority.DEBUG, logTag) {
+                        "Using local source preference: ${localSourcePreference.sourceKey}."
+                    }
+                    localSourcePreference
+                }
+                remoteSourcePreference != null && localSourcePreference == null -> {
+                    logcat(LogPriority.DEBUG, logTag) {
+                        "Using remote source preference: ${remoteSourcePreference.sourceKey}."
+                    }
+                    remoteSourcePreference
+                }
+                localSourcePreference != null && remoteSourcePreference != null -> {
+                    // Merge the individual preferences within the source preferences
+                    val mergedPrefs =
+                        mergeIndividualPreferences(localSourcePreference.prefs, remoteSourcePreference.prefs)
+                    BackupSourcePreferences(sourceKey, mergedPrefs)
+                }
+                else -> null
+            }
+        }
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Source preferences merge completed. Total merged source preferences: ${mergedSourcePreferences.size}"
+        }
+
+        return mergedSourcePreferences
+    }
+
+    private fun mergeIndividualPreferences(
+        localPrefs: List<BackupPreference>,
+        remotePrefs: List<BackupPreference>
+    ): List<BackupPreference> {
+        val mergedPrefsMap = (localPrefs + remotePrefs).associateBy { it.key }
+        return mergedPrefsMap.values.toList()
+    }
+
+    // SY -->
+    private fun mergeSavedSearchesLists(
+        localSearches: List<BackupSavedSearch>?,
+        remoteSearches: List<BackupSavedSearch>?
+    ): List<BackupSavedSearch> {
+        val logTag = "MergeSavedSearches"
+
+        // Define a function to create a composite key from a BackupSavedSearch
+        fun searchCompositeKey(search: BackupSavedSearch): String {
+            return "${search.name}|${search.source}"
+        }
+
+        // Create maps using the composite key
+        val localSearchMap = localSearches?.associateBy { searchCompositeKey(it) } ?: emptyMap()
+        val remoteSearchMap = remoteSearches?.associateBy { searchCompositeKey(it) } ?: emptyMap()
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Starting saved searches merge. Local saved searches: ${localSearches?.size}, " +
+                "Remote saved searches: ${remoteSearches?.size}"
+        }
+
+        // Merge both saved searches maps
+        val mergedSearches = (localSearchMap.keys + remoteSearchMap.keys).distinct().mapNotNull { compositeKey ->
+            val localSearch = localSearchMap[compositeKey]
+            val remoteSearch = remoteSearchMap[compositeKey]
+
+            logcat(LogPriority.DEBUG, logTag) {
+                "Processing saved search key: $compositeKey. Local search: ${localSearch != null}, " +
+                    "Remote search: ${remoteSearch != null}"
+            }
+
+            when {
+                localSearch != null && remoteSearch == null -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Using local saved search: ${localSearch.name}." }
+                    localSearch
+                }
+                remoteSearch != null && localSearch == null -> {
+                    logcat(LogPriority.DEBUG, logTag) { "Using remote saved search: ${remoteSearch.name}." }
+                    remoteSearch
+                }
+                else -> {
+                    logcat(LogPriority.DEBUG, logTag) {
+                        "No saved search found for composite key: $compositeKey. Skipping."
+                    }
+                    null
+                }
+            }
+        }
+
+        logcat(LogPriority.DEBUG, logTag) {
+            "Saved searches merge completed. Total merged saved searches: ${mergedSearches.size}"
+        }
+
+        return mergedSearches
+    }
+    // SY <--
+}
@@ -0,0 +1,180 @@
+package eu.kanade.tachiyomi.data.sync.service
+
+import android.content.Context
+import eu.kanade.domain.sync.SyncPreferences
+import eu.kanade.tachiyomi.data.backup.models.Backup
+import eu.kanade.tachiyomi.data.backup.models.BackupSerializer
+import eu.kanade.tachiyomi.data.sync.SyncNotifier
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.PUT
+import eu.kanade.tachiyomi.network.await
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.protobuf.ProtoBuf
+import logcat.LogPriority
+import logcat.logcat
+import okhttp3.Headers
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.apache.http.HttpStatus
+import tachiyomi.core.common.i18n.stringResource
+import tachiyomi.i18n.MR
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.util.concurrent.TimeUnit
+
+class SyncYomiSyncService(
+    context: Context,
+    json: Json,
+    syncPreferences: SyncPreferences,
+    private val notifier: SyncNotifier,
+
+    private val protoBuf: ProtoBuf = Injekt.get(),
+) : SyncService(context, json, syncPreferences) {
+
+    private class SyncYomiException(message: String?) : Exception(message)
+
+    override suspend fun doSync(syncData: SyncData): Backup? {
+        try {
+            val (remoteData, etag) = pullSyncData()
+
+            val finalSyncData = if (remoteData != null){
+                assert(etag.isNotEmpty()) { "ETag should never be empty if remote data is not null" }
+                logcat(LogPriority.DEBUG, "SyncService") {
+                    "Try update remote data with ETag($etag)"
+                }
+                mergeSyncData(syncData, remoteData)
+            } else {
+                // init or overwrite remote data
+                logcat(LogPriority.DEBUG) {
+                    "Try overwrite remote data with ETag($etag)"
+                }
+                syncData
+            }
+
+            pushSyncData(finalSyncData, etag)
+            return finalSyncData.backup
+
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR) { "Error syncing: ${e.message}" }
+            notifier.showSyncError(e.message)
+            return null
+        }
+    }
+
+    private suspend fun pullSyncData(): Pair<SyncData?, String> {
+        val host = syncPreferences.clientHost().get()
+        val apiKey = syncPreferences.clientAPIKey().get()
+        val downloadUrl = "$host/api/sync/content"
+
+        val headersBuilder = Headers.Builder().add("X-API-Token", apiKey)
+        val lastETag = syncPreferences.lastSyncEtag().get()
+        if (lastETag != "") {
+            headersBuilder.add("If-None-Match", lastETag)
+        }
+        val headers = headersBuilder.build()
+
+        val downloadRequest = GET(
+            url = downloadUrl,
+            headers = headers,
+        )
+
+        val client = OkHttpClient()
+        val response = client.newCall(downloadRequest).await()
+
+        if (response.code == HttpStatus.SC_NOT_MODIFIED) {
+            // not modified
+            assert(lastETag.isNotEmpty())
+            logcat(LogPriority.INFO) {
+                "Remote server not modified"
+            }
+            return Pair(null, lastETag)
+        } else if (response.code == HttpStatus.SC_NOT_FOUND) {
+            // maybe got deleted from remote
+            return Pair(null, "")
+        }
+
+        if (response.isSuccessful) {
+            val newETag = response.headers["ETag"]
+                .takeIf { it?.isNotEmpty() == true } ?: throw SyncYomiException("Missing ETag")
+
+            val byteArray = response.body.byteStream().use {
+                return@use it.readBytes()
+            }
+
+            return try {
+                val backup = protoBuf.decodeFromByteArray(BackupSerializer, byteArray)
+                return Pair(SyncData(backup = backup), newETag)
+            } catch (_: SerializationException) {
+                logcat(LogPriority.INFO) {
+                    "Bad content responsed from server"
+                }
+                // the body is invalid
+                // return default value so we can overwrite it
+                Pair(null, "")
+            }
+
+        } else {
+            val responseBody = response.body.string()
+            notifier.showSyncError("Failed to download sync data: $responseBody")
+            logcat(LogPriority.ERROR) { "SyncError: $responseBody" }
+            throw SyncYomiException("Failed to download sync data: $responseBody")
+        }
+    }
+
+    /**
+     * Return true if update success
+     */
+    private suspend fun pushSyncData(syncData: SyncData, eTag: String) {
+        val backup = syncData.backup ?: return
+
+        val host = syncPreferences.clientHost().get()
+        val apiKey = syncPreferences.clientAPIKey().get()
+        val uploadUrl = "$host/api/sync/content"
+        val timeout = 30L
+
+        val headersBuilder = Headers.Builder().add("X-API-Token", apiKey)
+        if (eTag.isNotEmpty()) {
+            headersBuilder.add("If-Match", eTag)
+        }
+        val headers = headersBuilder.build()
+
+        // Set timeout to 30 seconds
+        val client = OkHttpClient.Builder()
+            .connectTimeout(timeout, TimeUnit.SECONDS)
+            .readTimeout(timeout, TimeUnit.SECONDS)
+            .writeTimeout(timeout, TimeUnit.SECONDS)
+            .build()
+
+        val byteArray = protoBuf.encodeToByteArray(BackupSerializer, backup)
+        if (byteArray.isEmpty()) {
+            throw IllegalStateException(context.stringResource(MR.strings.empty_backup_error))
+        }
+        val body = byteArray.toRequestBody("application/octet-stream".toMediaType())
+
+        val uploadRequest = PUT(
+            url = uploadUrl,
+            headers = headers,
+            body = body,
+        )
+
+        val response = client.newCall(uploadRequest).await()
+
+        if (response.isSuccessful) {
+            val newETag = response.headers["ETag"]
+                .takeIf { it?.isNotEmpty() == true } ?: throw SyncYomiException("Missing ETag")
+            syncPreferences.lastSyncEtag().set(newETag)
+            logcat(LogPriority.DEBUG) { "SyncYomi sync completed" }
+
+        } else if (response.code == HttpStatus.SC_PRECONDITION_FAILED) {
+            // other clients updated remote data, will try next time
+            logcat(LogPriority.DEBUG) { "SyncYomi sync failed with 412" }
+
+        } else {
+            val responseBody = response.body.string()
+            notifier.showSyncError("Failed to upload sync data: $responseBody")
+            logcat(LogPriority.ERROR) { "SyncError: $responseBody" }
+        }
+    }
+}
@@ -41,7 +41,7 @@ class AnilistInterceptor(val anilist: Anilist, private var token: String?) : Int
        // Add the authorization header to the original request.
        val authRequest = originalRequest.newBuilder()
            .addHeader("Authorization", "Bearer ${oauth!!.access_token}")
-            .header("User-Agent", "TachiyomiSY v${BuildConfig.VERSION_NAME} (${BuildConfig.APPLICATION_ID})")
+            .header("User-Agent", "TachiSY v${BuildConfig.VERSION_NAME} (${BuildConfig.APPLICATION_ID})")
            .build()

        return chain.proceed(authRequest)
@@ -17,6 +17,7 @@ import eu.kanade.tachiyomi.data.download.DownloadCache
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.download.DownloadProvider
 import eu.kanade.tachiyomi.data.saver.ImageSaver
+import eu.kanade.tachiyomi.data.sync.service.GoogleDriveService
 import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.extension.ExtensionManager
 import eu.kanade.tachiyomi.network.JavaScriptEngine
@@ -185,5 +186,7 @@ class AppModule(val app: Application) : InjektModule {
            get<GetCustomMangaInfo>()
            // SY <--
        }
+
+        addSingletonFactory { GoogleDriveService(app) }
    }
 }
@@ -3,6 +3,7 @@ package eu.kanade.tachiyomi.di
 import android.app.Application
 import eu.kanade.domain.base.BasePreferences
 import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.domain.sync.SyncPreferences
 import eu.kanade.domain.track.service.TrackPreferences
 import eu.kanade.domain.ui.UiPreferences
 import eu.kanade.tachiyomi.core.security.SecurityPreferences
@@ -66,5 +67,9 @@ class PreferenceModule(val app: Application) : InjektModule {
        addSingletonFactory {
            BasePreferences(app, get())
        }
+
+        addSingletonFactory {
+            SyncPreferences(get())
+        }
    }
 }
@@ -20,18 +20,17 @@ import exh.source.BlacklistedSources
 import exh.source.EH_SOURCE_ID
 import exh.source.EXH_SOURCE_ID
 import exh.source.MERGED_SOURCE_ID
-import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.async
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.emptyFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import logcat.LogPriority
-import tachiyomi.core.common.util.lang.launchNow
 import tachiyomi.core.common.util.lang.withUIContext
 import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.source.model.StubSource
@@ -53,8 +52,10 @@ class ExtensionManager(
    private val trustExtension: TrustExtension = Injekt.get(),
 ) {

-    var isInitialized = false
-        private set
+    val scope = CoroutineScope(SupervisorJob())
+
+    private val _isInitialized = MutableStateFlow(false)
+    val isInitialized: StateFlow<Boolean> = _isInitialized.asStateFlow()

    /**
     * API where all the available extensions can be found.
@@ -68,13 +69,31 @@ class ExtensionManager(

    private val iconMap = mutableMapOf<String, Drawable>()

-    private val _installedExtensionsFlow = MutableStateFlow(emptyList<Extension.Installed>())
-    val installedExtensionsFlow = _installedExtensionsFlow.asStateFlow()
+    private val _installedExtensionsMapFlow = MutableStateFlow(emptyMap<String, Extension.Installed>())
+    val installedExtensionsFlow = _installedExtensionsMapFlow.mapExtensions(scope)
+
+    private val _availableExtensionsMapFlow = MutableStateFlow(emptyMap<String, Extension.Available>())
+    // SY -->
+    val availableExtensionsFlow = _availableExtensionsMapFlow.map { it.filterNotBlacklisted().values.toList() }
+        .stateIn(scope, SharingStarted.Lazily, _availableExtensionsMapFlow.value.values.toList())
+    // SY <--
+
+    private val _untrustedExtensionsMapFlow = MutableStateFlow(emptyMap<String, Extension.Untrusted>())
+    val untrustedExtensionsFlow = _untrustedExtensionsMapFlow.mapExtensions(scope)
+
+    init {
+        initExtensions()
+        ExtensionInstallReceiver(InstallationListener()).register(context)
+    }

    private var subLanguagesEnabledOnFirstRun = preferences.enabledLanguages().isSet()

    fun getAppIconForSource(sourceId: Long): Drawable? {
-        val pkgName = _installedExtensionsFlow.value.find { ext -> ext.sources.any { it.id == sourceId } }?.pkgName
+        val pkgName = _installedExtensionsMapFlow.value.values
+            .find { ext ->
+                ext.sources.any { it.id == sourceId }
+            }
+            ?.pkgName
        if (pkgName != null) {
            return iconMap[pkgName] ?: iconMap.getOrPut(pkgName) {
                ExtensionLoader.getExtensionPackageInfoFromPkgName(context, pkgName)!!.applicationInfo
@@ -92,15 +111,6 @@ class ExtensionManager(
        // SY <--
    }

-    private val _availableExtensionsFlow = MutableStateFlow(emptyList<Extension.Available>())
-
-    // SY -->
-    @OptIn(DelicateCoroutinesApi::class)
-    val availableExtensionsFlow = _availableExtensionsFlow
-        .map { it.filterNotBlacklisted() }
-        .stateIn(GlobalScope, SharingStarted.Eagerly, emptyList())
-    // SY <--
-
    private var availableExtensionsSourcesData: Map<Long, StubSource> = emptyMap()

    private fun setupAvailableExtensionsSourcesDataMap(extensions: List<Extension.Available>) {
@@ -112,38 +122,30 @@ class ExtensionManager(

    fun getSourceData(id: Long) = availableExtensionsSourcesData[id]

-    private val _untrustedExtensionsFlow = MutableStateFlow(emptyList<Extension.Untrusted>())
-    val untrustedExtensionsFlow = _untrustedExtensionsFlow.asStateFlow()
-
-    init {
-        initExtensions()
-        ExtensionInstallReceiver(InstallationListener()).register(context)
-    }
-
    /**
     * Loads and registers the installed extensions.
     */
    private fun initExtensions() {
        val extensions = ExtensionLoader.loadExtensions(context)

-        _installedExtensionsFlow.value = extensions
+        _installedExtensionsMapFlow.value = extensions
            .filterIsInstance<LoadResult.Success>()
-            .map { it.extension }
+            .associate { it.extension.pkgName to it.extension }

-        _untrustedExtensionsFlow.value = extensions
+        _untrustedExtensionsMapFlow.value = extensions
            .filterIsInstance<LoadResult.Untrusted>()
-            .map { it.extension }
+            .associate { it.extension.pkgName to it.extension }
            // SY -->
            .filterNotBlacklisted()
        // SY <--

-        isInitialized = true
+        _isInitialized.value = true
    }

    // EXH -->
-    private fun <T : Extension> Iterable<T>.filterNotBlacklisted(): List<T> {
+    private fun <T : Extension> Map<String, T>.filterNotBlacklisted(): Map<String, T> {
        val blacklistEnabled = preferences.enableSourceBlacklist().get()
-        return filterNot { extension ->
+        return filterNot { (_, extension) ->
            extension.isBlacklisted(blacklistEnabled)
                .also {
                    if (it) this@ExtensionManager.xLogD("Removing blacklisted extension: (name: %s, pkgName: %s)!", extension.name, extension.pkgName)
@@ -157,7 +159,7 @@ class ExtensionManager(
    // EXH <--

    /**
-     * Finds the available extensions in the [api] and updates [availableExtensions].
+     * Finds the available extensions in the [api] and updates [_availableExtensionsMapFlow].
     */
    suspend fun findAvailableExtensions() {
        val extensions: List<Extension.Available> = try {
@@ -170,7 +172,7 @@ class ExtensionManager(

        enableAdditionalSubLanguages(extensions)

-        _availableExtensionsFlow.value = extensions
+        _availableExtensionsMapFlow.value = extensions.associateBy { it.pkgName }
        updatedInstalledExtensionsStatuses(extensions)
        setupAvailableExtensionsSourcesDataMap(extensions)
    }
@@ -216,42 +218,36 @@ class ExtensionManager(
            return
        }

-        val mutInstalledExtensions = _installedExtensionsFlow.value.toMutableList()
+        val installedExtensionsMap = _installedExtensionsMapFlow.value.toMutableMap()
        var changed = false
+        for ((pkgName, extension) in installedExtensionsMap) {
+            val availableExt = availableExtensions.find { it.pkgName == pkgName }

-        for ((index, installedExt) in mutInstalledExtensions.withIndex()) {
-            val pkgName = installedExt.pkgName
-            // SY -->
-            val availableExt = _availableExtensionsFlow.value.find { it.pkgName == pkgName }
-            // SY <--
-
-            if (availableExt == null && !installedExt.isObsolete) {
-                mutInstalledExtensions[index] = installedExt.copy(isObsolete = true)
+            if (availableExt == null && !extension.isObsolete) {
+                installedExtensionsMap[pkgName] = extension.copy(isObsolete = true)
                changed = true
                // SY -->
-            } else if (installedExt.isBlacklisted() && !installedExt.isRedundant) {
-                mutInstalledExtensions[index] = installedExt.copy(isRedundant = true)
+            } else if (extension.isBlacklisted() && !extension.isRedundant) {
+                installedExtensionsMap[pkgName] = extension.copy(isRedundant = true)
                changed = true
                // SY <--
            } else if (availableExt != null) {
-                val hasUpdate = installedExt.updateExists(availableExt)
-
-                if (installedExt.hasUpdate != hasUpdate) {
-                    mutInstalledExtensions[index] = installedExt.copy(
+                val hasUpdate = extension.updateExists(availableExt)
+                if (extension.hasUpdate != hasUpdate) {
+                    installedExtensionsMap[pkgName] = extension.copy(
                        hasUpdate = hasUpdate,
                        repoUrl = availableExt.repoUrl,
                    )
-                    changed = true
                } else {
-                    mutInstalledExtensions[index] = installedExt.copy(
+                    installedExtensionsMap[pkgName] = extension.copy(
                        repoUrl = availableExt.repoUrl,
                    )
-                    changed = true
                }
+                changed = true
            }
        }
        if (changed) {
-            _installedExtensionsFlow.value = mutInstalledExtensions
+            _installedExtensionsMapFlow.value = installedExtensionsMap
        }
        updatePendingUpdatesCount()
    }
@@ -275,8 +271,7 @@ class ExtensionManager(
     * @param extension The extension to be updated.
     */
    fun updateExtension(extension: Extension.Installed): Flow<InstallStep> {
-        val availableExt = _availableExtensionsFlow.value.find { it.pkgName == extension.pkgName }
-            ?: return emptyFlow()
+        val availableExt = _availableExtensionsMapFlow.value[extension.pkgName] ?: return emptyFlow()
        return installExtension(availableExt)
    }

@@ -312,24 +307,16 @@ class ExtensionManager(
     *
     * @param extension the extension to trust
     */
-    fun trust(extension: Extension.Untrusted) {
-        val untrustedPkgNames = _untrustedExtensionsFlow.value.map { it.pkgName }.toSet()
-        if (extension.pkgName !in untrustedPkgNames) return
+    suspend fun trust(extension: Extension.Untrusted) {
+        _untrustedExtensionsMapFlow.value[extension.pkgName] ?: return

        trustExtension.trust(extension.pkgName, extension.versionCode, extension.signatureHash)

-        val nowTrustedExtensions = _untrustedExtensionsFlow.value
-            .filter { it.pkgName == extension.pkgName && it.versionCode == extension.versionCode }
-        _untrustedExtensionsFlow.value -= nowTrustedExtensions
+        _untrustedExtensionsMapFlow.value -= extension.pkgName

-        launchNow {
-            nowTrustedExtensions
-                .map { extension ->
-                    async { ExtensionLoader.loadExtensionFromPkgName(context, extension.pkgName) }.await()
-                }
-                .filterIsInstance<LoadResult.Success>()
-                .forEach { registerNewExtension(it.extension) }
-        }
+        ExtensionLoader.loadExtensionFromPkgName(context, extension.pkgName)
+            .let { it as? LoadResult.Success }
+            ?.let { registerNewExtension(it.extension) }
    }

    /**
@@ -345,7 +332,7 @@ class ExtensionManager(
        }
        // SY <--

-        _installedExtensionsFlow.value += extension
+        _installedExtensionsMapFlow.value += extension
    }

    /**
@@ -362,13 +349,7 @@ class ExtensionManager(
        }
        // SY <--

-        val mutInstalledExtensions = _installedExtensionsFlow.value.toMutableList()
-        val oldExtension = mutInstalledExtensions.find { it.pkgName == extension.pkgName }
-        if (oldExtension != null) {
-            mutInstalledExtensions -= oldExtension
-        }
-        mutInstalledExtensions += extension
-        _installedExtensionsFlow.value = mutInstalledExtensions
+        _installedExtensionsMapFlow.value += extension
    }

    /**
@@ -378,14 +359,8 @@ class ExtensionManager(
     * @param pkgName The package name of the uninstalled application.
     */
    private fun unregisterExtension(pkgName: String) {
-        val installedExtension = _installedExtensionsFlow.value.find { it.pkgName == pkgName }
-        if (installedExtension != null) {
-            _installedExtensionsFlow.value -= installedExtension
-        }
-        val untrustedExtension = _untrustedExtensionsFlow.value.find { it.pkgName == pkgName }
-        if (untrustedExtension != null) {
-            _untrustedExtensionsFlow.value -= untrustedExtension
-        }
+        _installedExtensionsMapFlow.value -= pkgName
+        _untrustedExtensionsMapFlow.value -= pkgName
    }

    /**
@@ -404,14 +379,9 @@ class ExtensionManager(
        }

        override fun onExtensionUntrusted(extension: Extension.Untrusted) {
-            val installedExtension = _installedExtensionsFlow.value
-                .find { it.pkgName == extension.pkgName }
-
-            if (installedExtension != null) {
-                _installedExtensionsFlow.value -= installedExtension
-            } else {
-                _untrustedExtensionsFlow.value += extension
-            }
+            _installedExtensionsMapFlow.value -= extension.pkgName
+            _untrustedExtensionsMapFlow.value += extension
+            updatePendingUpdatesCount()
        }

        override fun onPackageUninstalled(pkgName: String) {
@@ -433,17 +403,24 @@ class ExtensionManager(
    }

    private fun Extension.Installed.updateExists(availableExtension: Extension.Available? = null): Boolean {
-        val availableExt = availableExtension ?: _availableExtensionsFlow.value.find { it.pkgName == pkgName }
+        val availableExt = availableExtension
+            ?: _availableExtensionsMapFlow.value[pkgName]
            ?: return false

        return (availableExt.versionCode > versionCode || availableExt.libVersion > libVersion)
    }

    private fun updatePendingUpdatesCount() {
-        val pendingUpdateCount = _installedExtensionsFlow.value.count { it.hasUpdate }
+        val pendingUpdateCount = _installedExtensionsMapFlow.value.values.count { it.hasUpdate }
        preferences.extensionUpdatesCount().set(pendingUpdateCount)
        if (pendingUpdateCount == 0) {
            ExtensionUpdateNotifier(context).dismiss()
        }
    }
+
+    private operator fun <T : Extension> Map<String, T>.plus(extension: T) = plus(extension.pkgName to extension)
+
+    private fun <T : Extension> StateFlow<Map<String, T>>.mapExtensions(scope: CoroutineScope): StateFlow<List<T>> {
+        return map { it.values.toList() }.stateIn(scope, SharingStarted.Lazily, value.values.toList())
+    }
 }
@@ -11,9 +11,14 @@ import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.network.awaitSuccess
 import eu.kanade.tachiyomi.network.parseAs
 import exh.source.BlacklistedSources
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import logcat.LogPriority
+import mihon.domain.extensionrepo.interactor.GetExtensionRepo
+import mihon.domain.extensionrepo.interactor.UpdateExtensionRepo
+import mihon.domain.extensionrepo.model.ExtensionRepo
 import tachiyomi.core.common.preference.Preference
 import tachiyomi.core.common.preference.PreferenceStore
 import tachiyomi.core.common.util.lang.withIOContext
@@ -26,8 +31,12 @@ internal class ExtensionApi {

    private val networkService: NetworkHelper by injectLazy()
    private val preferenceStore: PreferenceStore by injectLazy()
-    private val sourcePreferences: SourcePreferences by injectLazy()
+    private val getExtensionRepo: GetExtensionRepo by injectLazy()
+    private val updateExtensionRepo: UpdateExtensionRepo by injectLazy()
    private val extensionManager: ExtensionManager by injectLazy()
+    // SY -->
+    private val sourcePreferences: SourcePreferences by injectLazy()
+    // SY <--
    private val json: Json by injectLazy()

    private val lastExtCheck: Preference<Long> by lazy {
@@ -36,11 +45,15 @@ internal class ExtensionApi {

    suspend fun findExtensions(): List<Extension.Available> {
        return withIOContext {
-            sourcePreferences.extensionRepos().get().flatMap { getExtensions(it) }
+            getExtensionRepo.getAll()
+                .map { async { getExtensions(it) } }
+                .awaitAll()
+                .flatten()
        }
    }

-    private suspend fun getExtensions(repoBaseUrl: String): List<Extension.Available> {
+    private suspend fun getExtensions(extRepo: ExtensionRepo): List<Extension.Available> {
+        val repoBaseUrl = extRepo.baseUrl
        return try {
            val response = networkService.client
                .newCall(GET("$repoBaseUrl/index.min.json"))
@@ -68,6 +81,9 @@ internal class ExtensionApi {
            return null
        }

+        // Update extension repo details
+        updateExtensionRepo.awaitAll()
+
        val extensions = if (fromAvailableExtensionList) {
            extensionManager.availableExtensionsFlow.value
        } else {
@@ -3,6 +3,7 @@ package eu.kanade.tachiyomi.extension.installer
 import android.app.Service
 import android.content.pm.PackageManager
 import android.os.Build
+import android.os.Process
 import eu.kanade.tachiyomi.extension.model.InstallStep
 import eu.kanade.tachiyomi.util.system.getUriSize
 import eu.kanade.tachiyomi.util.system.toast
@@ -51,7 +52,8 @@ class ShizukuInstaller(private val service: Service) : Installer(service) {
                val size = service.getUriSize(entry.uri) ?: throw IllegalStateException()
                service.contentResolver.openInputStream(entry.uri)!!.use {
                    val createCommand = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-                        "pm install-create --user current -r -i ${service.packageName} -S $size"
+                        val userId = Process.myUserHandle().hashCode()
+                        "pm install-create --user $userId -r -i ${service.packageName} -S $size"
                    } else {
                        "pm install-create -r -i ${service.packageName} -S $size"
                    }
@@ -9,12 +9,10 @@ import androidx.core.content.ContextCompat
 import eu.kanade.tachiyomi.BuildConfig
 import eu.kanade.tachiyomi.extension.model.Extension
 import eu.kanade.tachiyomi.extension.model.LoadResult
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.async
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 import logcat.LogPriority
-import tachiyomi.core.common.util.lang.launchNow
 import tachiyomi.core.common.util.system.logcat

 /**
@@ -23,29 +21,23 @@ import tachiyomi.core.common.util.system.logcat
 *
 * @param listener The listener that should be notified of extension installation events.
 */
-internal class ExtensionInstallReceiver(private val listener: Listener) :
-    BroadcastReceiver() {
+internal class ExtensionInstallReceiver(private val listener: Listener) : BroadcastReceiver() {
+
+    val scope = CoroutineScope(SupervisorJob())

-    /**
-     * Registers this broadcast receiver
-     */
    fun register(context: Context) {
        ContextCompat.registerReceiver(context, this, filter, ContextCompat.RECEIVER_NOT_EXPORTED)
    }

-    /**
-     * Returns the intent filter this receiver should subscribe to.
-     */
-    private val filter
-        get() = IntentFilter().apply {
-            addAction(Intent.ACTION_PACKAGE_ADDED)
-            addAction(Intent.ACTION_PACKAGE_REPLACED)
-            addAction(Intent.ACTION_PACKAGE_REMOVED)
-            addAction(ACTION_EXTENSION_ADDED)
-            addAction(ACTION_EXTENSION_REPLACED)
-            addAction(ACTION_EXTENSION_REMOVED)
-            addDataScheme("package")
-        }
+    private val filter = IntentFilter().apply {
+        addAction(Intent.ACTION_PACKAGE_ADDED)
+        addAction(Intent.ACTION_PACKAGE_REPLACED)
+        addAction(Intent.ACTION_PACKAGE_REMOVED)
+        addAction(ACTION_EXTENSION_ADDED)
+        addAction(ACTION_EXTENSION_REPLACED)
+        addAction(ACTION_EXTENSION_REMOVED)
+        addDataScheme("package")
+    }

    /**
     * Called when one of the events of the [filter] is received. When the package is an extension,
@@ -58,7 +50,7 @@ internal class ExtensionInstallReceiver(private val listener: Listener) :
            Intent.ACTION_PACKAGE_ADDED, ACTION_EXTENSION_ADDED -> {
                if (isReplacing(intent)) return

-                launchNow {
+                scope.launch {
                    when (val result = getExtensionFromIntent(context, intent)) {
                        is LoadResult.Success -> listener.onExtensionInstalled(result.extension)
                        is LoadResult.Untrusted -> listener.onExtensionUntrusted(result.extension)
@@ -67,7 +59,7 @@ internal class ExtensionInstallReceiver(private val listener: Listener) :
                }
            }
            Intent.ACTION_PACKAGE_REPLACED, ACTION_EXTENSION_REPLACED -> {
-                launchNow {
+                scope.launch {
                    when (val result = getExtensionFromIntent(context, intent)) {
                        is LoadResult.Success -> listener.onExtensionUpdated(result.extension)
                        is LoadResult.Untrusted -> listener.onExtensionUntrusted(result.extension)
@@ -107,9 +99,7 @@ internal class ExtensionInstallReceiver(private val listener: Listener) :
            logcat(LogPriority.WARN) { "Package name not found" }
            return LoadResult.Error
        }
-        return GlobalScope.async(Dispatchers.Default, CoroutineStart.DEFAULT) {
-            ExtensionLoader.loadExtensionFromPkgName(context, pkgName)
-        }.await()
+        return ExtensionLoader.loadExtensionFromPkgName(context, pkgName)
    }

    /**
@@ -172,7 +172,7 @@ internal object ExtensionLoader {
     * Attempts to load an extension from the given package name. It checks if the extension
     * contains the required feature flag before trying to load it.
     */
-    fun loadExtensionFromPkgName(context: Context, pkgName: String): LoadResult {
+    suspend fun loadExtensionFromPkgName(context: Context, pkgName: String): LoadResult {
        val extensionPackage = getExtensionInfoFromPkgName(context, pkgName)
        if (extensionPackage == null) {
            logcat(LogPriority.ERROR) { "Extension package is not found ($pkgName)" }
@@ -223,7 +223,8 @@ internal object ExtensionLoader {
     * @param context The application context.
     * @param extensionInfo The extension to load.
     */
-    private fun loadExtension(context: Context, extensionInfo: ExtensionInfo): LoadResult {
+    @Suppress("LongMethod", "CyclomaticComplexMethod", "ReturnCount")
+    private suspend fun loadExtension(context: Context, extensionInfo: ExtensionInfo): LoadResult {
        val pkgManager = context.packageManager
        val pkgInfo = extensionInfo.packageInfo
        val appInfo = pkgInfo.applicationInfo
@@ -252,7 +253,7 @@ internal object ExtensionLoader {
        if (signatures.isNullOrEmpty()) {
            logcat(LogPriority.WARN) { "Package $pkgName isn't signed" }
            return LoadResult.Error
-        } else if (!trustExtension.isTrusted(pkgInfo, signatures.last())) {
+        } else if (!trustExtension.isTrusted(pkgInfo, signatures)) {
            val extension = Extension.Untrusted(
                extName,
                pkgName,
@@ -29,6 +29,8 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.map
@@ -103,6 +105,7 @@ class AndroidSourceManager(
                        }
                    }
                    sourcesMapFlow.value = mutableMap
+                    _isInitialized.value = true
                }
        }

@@ -186,6 +189,9 @@ class AndroidSourceManager(
    }

    // SY -->
+    private val _isInitialized = MutableStateFlow(false)
+    override val isInitialized: StateFlow<Boolean> = _isInitialized.asStateFlow()
+
    override fun getVisibleOnlineSources() = sourcesMapFlow.value.values
        .filterIsInstance<HttpSource>()
        .filter {
@@ -806,6 +806,11 @@ class EHentai(
    override fun pageListParse(response: Response) =
        throw UnsupportedOperationException("Unused method was called somehow!")

+    override suspend fun getImageUrl(page: Page): String {
+        val imageUrlResponse = client.newCall(imageUrlRequest(page)).awaitSuccess()
+        return realImageUrlParse(imageUrlResponse, page)
+    }
+
    @Deprecated("Use the non-RxJava API instead", replaceWith = ReplaceWith("getImageUrl"))
    override fun fetchImageUrl(page: Page): Observable<String> {
        return client.newCall(imageUrlRequest(page))
@@ -109,8 +109,6 @@ class MergedSource : HttpSource() {
    suspend fun fetchChaptersForMergedManga(
        manga: Manga,
        downloadChapters: Boolean = true,
-        editScanlators: Boolean = false,
-        dedupe: Boolean = true,
    ) {
        fetchChaptersAndSync(manga, downloadChapters)
    }
@@ -27,6 +27,7 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.i18n.MR
 import uy.kohesive.injekt.Injekt
@@ -195,7 +196,9 @@ class ExtensionsScreenModel(
    }

    fun trustExtension(extension: Extension.Untrusted) {
-        extensionManager.trust(extension)
+        screenModelScope.launch {
+            extensionManager.trust(extension)
+        }
    }

    @Immutable
@@ -39,8 +39,10 @@ import eu.kanade.tachiyomi.source.ConfigurableSource
 import eu.kanade.tachiyomi.source.sourcePreferences
 import eu.kanade.tachiyomi.widget.TachiyomiTextInputEditText.Companion.setIncognito
 import exh.source.EnhancedHttpSource
+import exh.ui.ifSourcesLoaded
 import tachiyomi.domain.source.service.SourceManager
 import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.screens.LoadingScreen
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get

@@ -48,6 +50,11 @@ class SourcePreferencesScreen(val sourceId: Long) : Screen() {

    @Composable
    override fun Content() {
+        if (!ifSourcesLoaded()) {
+            LoadingScreen()
+            return
+        }
+
        val context = LocalContext.current
        val navigator = LocalNavigator.currentOrThrow

@@ -130,7 +137,7 @@ class SourcePreferencesFragment : PreferenceFragmentCompat() {
        // SY -->
        val source = Injekt.get<SourceManager>()
            .getOrStub(sourceId)
-            ?.let { source ->
+            .let { source ->
                if (source is EnhancedHttpSource) {
                    if (source.enhancedSource is ConfigurableSource) {
                        source.source()
@@ -141,7 +148,6 @@ class SourcePreferencesFragment : PreferenceFragmentCompat() {
                    source
                }
            }
-            ?: throw NullPointerException("source = null, SOURCE_ID = $SOURCE_ID")
        // SY <--
        val sourceScreen = preferenceManager.createPreferenceScreen(requireContext())

@@ -280,7 +280,7 @@ open class FeedScreenModel(
    }

    @Composable
-    fun getManga(initialManga: DomainManga, source: CatalogueSource?): State<DomainManga> {
+    fun getManga(initialManga: DomainManga): State<DomainManga> {
        return produceState(initialValue = initialManga) {
            getManga.subscribe(initialManga.url, initialManga.source)
                .collectLatest { manga ->
@@ -87,7 +87,7 @@ fun Screen.feedTab(): TabContent {
                    navigator.push(MangaScreen(manga.id, true))
                },
                onRefresh = screenModel::init,
-                getMangaState = { manga, source -> screenModel.getManga(initialManga = manga, source = source) },
+                getMangaState = { manga -> screenModel.getManga(initialManga = manga) },
            )

            state.dialog?.let { dialog ->
@@ -46,9 +46,15 @@ import tachiyomi.i18n.sy.SYMR
 import tachiyomi.presentation.core.components.material.ExtendedFloatingActionButton
 import tachiyomi.presentation.core.components.material.Scaffold
 import tachiyomi.presentation.core.i18n.stringResource
+import java.io.Serializable
 import kotlin.math.roundToInt

-class PreMigrationScreen(val mangaIds: List<Long>) : Screen() {
+sealed class MigrationType : Serializable {
+    data class MangaList(val mangaIds: List<Long>) : MigrationType()
+    data class MangaSingle(val fromMangaId: Long, val toManga: Long?) : MigrationType()
+}
+
+class PreMigrationScreen(val migration: MigrationType) : Screen() {
    @Composable
    override fun Content() {
        val screenModel = rememberScreenModel { PreMigrationScreenModel() }
@@ -173,7 +179,7 @@ class PreMigrationScreen(val mangaIds: List<Long>) : Screen() {
                    screenModel.onMigrationSheet(false)
                    screenModel.saveEnabledSources()

-                    navigator replace MigrationListScreen(MigrationProcedureConfig(mangaIds, extraParam))
+                    navigator replace MigrationListScreen(MigrationProcedureConfig(migration, extraParam))
                },
            )
        }
@@ -184,10 +190,22 @@ class PreMigrationScreen(val mangaIds: List<Long>) : Screen() {
            navigator.push(
                if (skipPre) {
                    MigrationListScreen(
-                        MigrationProcedureConfig(mangaIds, null),
+                        MigrationProcedureConfig(MigrationType.MangaList(mangaIds), null),
                    )
                } else {
-                    PreMigrationScreen(mangaIds)
+                    PreMigrationScreen(MigrationType.MangaList(mangaIds))
+                },
+            )
+        }
+
+        fun navigateToMigration(skipPre: Boolean, navigator: Navigator, fromMangaId: Long, toManga: Long?) {
+            navigator.push(
+                if (skipPre) {
+                    MigrationListScreen(
+                        MigrationProcedureConfig(MigrationType.MangaSingle(fromMangaId, toManga), null),
+                    )
+                } else {
+                    PreMigrationScreen(MigrationType.MangaSingle(fromMangaId, toManga))
                },
            )
        }
@@ -121,7 +121,7 @@ class MigrationListScreen(private val config: MigrationProcedureConfig) : Screen
        )

        val onDismissRequest = { screenModel.dialog.value = null }
-        when (val dialog = dialog) {
+        when (@Suppress("NAME_SHADOWING") val dialog = dialog) {
            is MigrationListScreenModel.Dialog.MigrateMangaDialog -> {
                MigrationMangaDialog(
                    onDismissRequest = onDismissRequest,
@@ -14,6 +14,7 @@ import eu.kanade.tachiyomi.source.CatalogueSource
 import eu.kanade.tachiyomi.source.getNameForMangaInfo
 import eu.kanade.tachiyomi.source.online.all.EHentai
 import eu.kanade.tachiyomi.ui.browse.migration.MigrationFlags
+import eu.kanade.tachiyomi.ui.browse.migration.advanced.design.MigrationType
 import eu.kanade.tachiyomi.ui.browse.migration.advanced.process.MigratingManga.SearchResult
 import eu.kanade.tachiyomi.util.system.toast
 import exh.eh.EHentaiThrottleManager
@@ -104,8 +105,14 @@ class MigrationListScreenModel(

    init {
        screenModelScope.launchIO {
+            val mangaIds = when (val migration = config.migration) {
+                is MigrationType.MangaList -> {
+                    migration.mangaIds
+                }
+                is MigrationType.MangaSingle -> listOf(migration.fromMangaId)
+            }
            runMigrations(
-                config.mangaIds
+                mangaIds
                    .map {
                        async {
                            val manga = getManga.await(it) ?: return@async null
@@ -161,9 +168,13 @@ class MigrationListScreenModel(
                break
            }
            // in case it was removed
-            if (manga.manga.id !in config.mangaIds) {
-                continue
+            when (val migration = config.migration) {
+                is MigrationType.MangaList -> if (manga.manga.id !in migration.mangaIds) {
+                    continue
+                }
+                else -> Unit
            }
+
            if (manga.searchResult.value == SearchResult.Searching && manga.migrationScope.isActive) {
                val mangaObj = manga.manga
                val mangaSource = sourceManager.getOrStub(mangaObj.source)
@@ -175,6 +186,28 @@ class MigrationListScreenModel(
                        } else {
                            sources.filter { it.id != mangaSource.id }
                        }
+                        when (val migration = config.migration) {
+                            is MigrationType.MangaSingle -> if (migration.toManga != null) {
+                                val localManga = getManga.await(migration.toManga)
+                                if (localManga != null) {
+                                    val source = sourceManager.get(localManga.source) as? CatalogueSource
+                                    if (source != null) {
+                                        val chapters = if (source is EHentai) {
+                                            source.getChapterList(localManga.toSManga(), throttleManager::throttle)
+                                        } else {
+                                            source.getChapterList(localManga.toSManga())
+                                        }
+                                        try {
+                                            syncChaptersWithSource.await(chapters, localManga, source)
+                                        } catch (_: Exception) {
+                                        }
+                                        manga.progress.value = validSources.size to validSources.size
+                                        return@async localManga
+                                    }
+                                }
+                            }
+                            else -> Unit
+                        }
                        if (useSourceWithMost) {
                            val sourceSemaphore = Semaphore(3)
                            val processedSources = AtomicInteger()
@@ -523,13 +556,18 @@ class MigrationListScreenModel(
    }

    fun removeManga(item: MigratingManga) {
-        val ids = config.mangaIds.toMutableList()
-        val index = ids.indexOf(item.manga.id)
-        if (index > -1) {
-            ids.removeAt(index)
-            config.mangaIds = ids
-            val index2 = migratingItems.value.orEmpty().indexOf(item)
-            if (index2 > -1) migratingItems.value = (migratingItems.value.orEmpty() - item).toImmutableList()
+        when (val migration = config.migration) {
+            is MigrationType.MangaList -> {
+                val ids = migration.mangaIds.toMutableList()
+                val index = ids.indexOf(item.manga.id)
+                if (index > -1) {
+                    ids.removeAt(index)
+                    config.migration = MigrationType.MangaList(ids)
+                    val index2 = migratingItems.value.orEmpty().indexOf(item)
+                    if (index2 > -1) migratingItems.value = (migratingItems.value.orEmpty() - item).toImmutableList()
+                }
+            }
+            is MigrationType.MangaSingle -> Unit
        }
    }

@@ -1,8 +1,9 @@
 package eu.kanade.tachiyomi.ui.browse.migration.advanced.process

+import eu.kanade.tachiyomi.ui.browse.migration.advanced.design.MigrationType
 import java.io.Serializable

 data class MigrationProcedureConfig(
-    var mangaIds: List<Long>,
+    var migration: MigrationType,
    val extraSearchParams: String?,
 ) : Serializable
@@ -22,10 +22,12 @@ import eu.kanade.tachiyomi.ui.browse.source.browse.BrowseSourceScreenModel
 import eu.kanade.tachiyomi.ui.browse.source.browse.SourceFilterDialog
 import eu.kanade.tachiyomi.ui.manga.MangaScreen
 import eu.kanade.tachiyomi.ui.webview.WebViewScreen
+import exh.ui.ifSourcesLoaded
 import kotlinx.collections.immutable.persistentListOf
 import tachiyomi.core.common.Constants
 import tachiyomi.domain.manga.model.Manga
 import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.screens.LoadingScreen
 import tachiyomi.source.local.LocalSource

 data class SourceSearchScreen(
@@ -36,6 +38,11 @@ data class SourceSearchScreen(

    @Composable
    override fun Content() {
+        if (!ifSourcesLoaded()) {
+            LoadingScreen()
+            return
+        }
+
        val uriHandler = LocalUriHandler.current
        val navigator = LocalNavigator.currentOrThrow

@@ -102,7 +109,7 @@ data class SourceSearchScreen(
        }

        val onDismissRequest = { screenModel.setDialog(null) }
-        when (val dialog = state.dialog) {
+        when (state.dialog) {
            is BrowseSourceScreenModel.Dialog.Filter -> {
                SourceFilterDialog(
                    onDismissRequest = onDismissRequest,
@@ -16,6 +16,7 @@ import eu.kanade.presentation.components.TabContent
 import eu.kanade.tachiyomi.ui.browse.migration.advanced.design.PreMigrationScreen
 import eu.kanade.tachiyomi.ui.browse.migration.manga.MigrateMangaScreen
 import kotlinx.collections.immutable.persistentListOf
+import kotlinx.coroutines.DelicateCoroutinesApi
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.core.common.util.lang.withUIContext
 import tachiyomi.domain.UnsortedPreferences
@@ -55,6 +56,7 @@ fun Screen.migrateSourceTab(): TabContent {
                // SY -->
                onClickAll = { source ->
                    // TODO: Jay wtf, need to clean this up sometime
+                    @OptIn(DelicateCoroutinesApi::class)
                    launchIO {
                        val manga = Injekt.get<GetFavorites>().await()
                        val sourceMangas =
@@ -49,6 +49,7 @@ import eu.kanade.presentation.util.Screen
 import eu.kanade.tachiyomi.source.CatalogueSource
 import eu.kanade.tachiyomi.source.online.HttpSource
 import eu.kanade.tachiyomi.ui.browse.extension.details.SourcePreferencesScreen
+import eu.kanade.tachiyomi.ui.browse.migration.advanced.design.PreMigrationScreen
 import eu.kanade.tachiyomi.ui.browse.source.SourcesScreen
 import eu.kanade.tachiyomi.ui.browse.source.browse.BrowseSourceScreenModel.Listing
 import eu.kanade.tachiyomi.ui.category.CategoryScreen
@@ -56,17 +57,22 @@ import eu.kanade.tachiyomi.ui.manga.MangaScreen
 import eu.kanade.tachiyomi.ui.webview.WebViewScreen
 import eu.kanade.tachiyomi.util.system.toast
 import exh.md.follows.MangaDexFollowsScreen
+import exh.ui.ifSourcesLoaded
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.receiveAsFlow
 import tachiyomi.core.common.Constants
 import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.domain.UnsortedPreferences
 import tachiyomi.domain.source.model.StubSource
 import tachiyomi.i18n.MR
 import tachiyomi.presentation.core.components.material.Scaffold
 import tachiyomi.presentation.core.components.material.padding
 import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.screens.LoadingScreen
 import tachiyomi.source.local.LocalSource
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get

 data class BrowseSourceScreen(
    private val sourceId: Long,
@@ -84,6 +90,11 @@ data class BrowseSourceScreen(

    @Composable
    override fun Content() {
+        if (!ifSourcesLoaded()) {
+            LoadingScreen()
+            return
+        }
+
        val screenModel = rememberScreenModel {
            BrowseSourceScreenModel(
                sourceId = sourceId,
@@ -312,6 +323,16 @@ data class BrowseSourceScreen(
                    onDismissRequest = onDismissRequest,
                    onConfirm = { screenModel.addFavorite(dialog.manga) },
                    onOpenManga = { navigator.push(MangaScreen(dialog.duplicate.id)) },
+                    onMigrate = {
+                        // SY -->
+                        PreMigrationScreen.navigateToMigration(
+                            Injekt.get<UnsortedPreferences>().skipPreMigration().get(),
+                            navigator,
+                            dialog.duplicate.id,
+                            dialog.manga.id,
+                        )
+                        // SY <--
+                    },
                )
            }
            is BrowseSourceScreenModel.Dialog.RemoveManga -> {
@@ -455,7 +455,7 @@ open class BrowseSourceScreenModel(
            val manga: Manga,
            val initialSelection: ImmutableList<CheckboxState.State<Category>>,
        ) : Dialog
-        data class Migrate(val newManga: Manga) : Dialog
+        data class Migrate(val newManga: Manga, val oldManga: Manga) : Dialog

        // SY -->
        data class DeleteSavedSearch(val idToDelete: Long, val name: String) : Dialog
@@ -19,15 +19,22 @@ import eu.kanade.tachiyomi.ui.browse.source.browse.SourceFilterDialog
 import eu.kanade.tachiyomi.ui.manga.MangaScreen
 import eu.kanade.tachiyomi.util.system.toast
 import exh.md.follows.MangaDexFollowsScreen
+import exh.ui.ifSourcesLoaded
 import exh.util.nullIfBlank
 import tachiyomi.domain.manga.model.Manga
 import tachiyomi.domain.source.interactor.GetRemoteManga
 import tachiyomi.domain.source.model.SavedSearch
+import tachiyomi.presentation.core.screens.LoadingScreen

 class SourceFeedScreen(val sourceId: Long) : Screen() {

    @Composable
    override fun Content() {
+        if (!ifSourcesLoaded()) {
+            LoadingScreen()
+            return
+        }
+
        val screenModel = rememberScreenModel { SourceFeedScreenModel(sourceId) }
        val state by screenModel.state.collectAsState()
        val navigator = LocalNavigator.currentOrThrow
@@ -14,6 +14,7 @@ import eu.kanade.presentation.browse.GlobalSearchScreen
 import eu.kanade.presentation.util.Screen
 import eu.kanade.tachiyomi.ui.browse.source.browse.BrowseSourceScreen
 import eu.kanade.tachiyomi.ui.manga.MangaScreen
+import exh.ui.ifSourcesLoaded
 import tachiyomi.presentation.core.screens.LoadingScreen

 class GlobalSearchScreen(
@@ -23,6 +24,11 @@ class GlobalSearchScreen(

    @Composable
    override fun Content() {
+        if (!ifSourcesLoaded()) {
+            LoadingScreen()
+            return
+        }
+
        val navigator = LocalNavigator.currentOrThrow

        val screenModel = rememberScreenModel {
--- a/Show More
+++ b/Show More