Release v1.9.3

(cherry picked from commit d94270ce32)

.editorconfig

@@ -0,0 +1,7 @@
+[*.{kt,kts}]
+indent_size=4
+insert_final_newline=true
+ij_kotlin_allow_trailing_comma=true
+ij_kotlin_allow_trailing_comma_on_call_site=true
+ij_kotlin_name_count_to_use_star_import = 2147483647
+ij_kotlin_name_count_to_use_star_import_for_members = 2147483647

.github/ISSUE_TEMPLATE.md

@@ -3,11 +3,11 @@
 I acknowledge that:
 
 - I have updated:
-  - To the latest version of the app (stable is v1.7.0)
+  - To the latest version of the app (stable is v1.9.3)
   - All extensions
 - I have tried the troubleshooting guide: https://tachiyomi.org/help/guides/troubleshooting-problems/
 - If this is an issue with an extension, that I should be opening an issue in https://github.com/tachiyomiorg/tachiyomi-extensions
-- I have searched the existing issues and this is new ticket **NOT** a duplicate or related to another open issue
+- I have searched the existing issues and this is new ticket **NOT** a duplicate or related to another open or closed issue
 - I will fill out the title and the information in this template
 
 Note that the issue will be automatically closed if you do not fill out the title or requested information.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,44 +0,0 @@
----
-name: "🐞 Bug report"
-about: Report a bug
-title: "[Bug] <Write short description here>"
-labels: "bug"
----
-
-**PLEASE READ THIS**
-
-I acknowledge that:
-
-- I have updated:
-  - To the latest version of the app (stable is v1.7.0)
-  - All extensions
-- I have tried the troubleshooting guide: https://tachiyomi.org/help/guides/troubleshooting-problems/
-- If this is an issue with an extension, that I should be opening an issue in https://github.com/tachiyomiorg/tachiyomi-extensions
-- I have searched the existing issues and this is new ticket **NOT** a duplicate or related to another open issue
-- I will fill out the title and the information in this template
-
-Note that the issue will be automatically closed if you do not fill out the title or requested information.
-
-**DELETE THIS SECTION IF YOU HAVE READ AND ACKNOWLEDGED IT**
-
----
-
-## Device information
-* Tachiyomi version: ?
-* Android version: ?
-* Device: ?
-
-## Steps to reproduce
-1. First step
-2. Second step
-
-### Expected behavior
-This should happen.
-
-### Actual behavior
-This happened instead.
-
-## Other details
-Additional details and attachments.
-
-If you're experiencing crashes, share the crash logs from More → Settings → Advanced → Dump crash logs.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,11 @@
 blank_issues_enabled: false
 contact_links:
-  - name: Tachiyomi help website
+  - name: ⚠️ Extension/source issue
+    url: https://github.com/tachiyomiorg/tachiyomi-extensions/issues/new/choose
+    about: Issues and requests for extensions and sources should be opened in the tachiyomi-extensions repository instead
+  - name: 📦 Tachiyomi extensions
+    url: https://tachiyomi.org/extensions
+    about: List of all available extensions with download links
+  - name: 🖥️ Tachiyomi website
     url: https://tachiyomi.org/help/
-    about: Common questions are answered here.
+    about: Guides, troubleshooting, and answers to common questions
-  - name: Tachiyomi extensions GitHub repository
-    url: https://github.com/tachiyomiorg/tachiyomi-extensions
-    about: Issues about an extension/source/catalogue should be opened here instead.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,29 +0,0 @@
----
-name: "🌟 Feature request"
-about: Suggest a feature to improve Tachiyomi
-title: "[Feature Request] <Write short description here>"
-labels: "feature"
----
-
-**PLEASE READ THIS**
-
-I acknowledge that:
-
-- I have updated:
-  - To the latest version of the app (stable is v1.7.0)
-  - All extensions
-- If this is an issue with an extension, that I should be opening an issue in https://github.com/tachiyomiorg/tachiyomi-extensions
-- I have searched the existing issues and this is new ticket **NOT** a duplicate or related to another open issue
-- I will fill out the title and the information in this template
-
-Note that the issue will be automatically closed if you do not fill out the title or requested information.
-
-**DELETE THIS SECTION IF YOU HAVE READ AND ACKNOWLEDGED IT**
-
----
-
-## Why/User Benefit/User Problem
-(explain why this feature should be added)
-
-## What/Requirements
-(explain how this feature would behave)

.github/ISSUE_TEMPLATE/report_issue.yml

@@ -0,0 +1,108 @@
+name: 🐞 Issue report
+description: Report an issue in Tachiyomi
+labels: [Bug]
+body:
+
+  - type: textarea
+    id: reproduce-steps
+    attributes:
+      label: Steps to reproduce
+      description: Provide an example of the issue.
+      placeholder: |
+        Example:
+          1. First step
+          2. Second step
+          3. Issue here
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected behavior
+      description: Explain what you should expect to happen.
+      placeholder: |
+        Example:
+          "This should happen..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual-behavior
+    attributes:
+      label: Actual behavior
+      description: Explain what actually happens.
+      placeholder: |
+        Example:
+          "This happened instead..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: crash-logs
+    attributes:
+      label: Crash logs
+      description: |
+        If you're experiencing crashes, share the crash logs from **More → Settings → Advanced** then press **Dump crash logs**.
+      placeholder: |
+        You can paste the crash logs in plain text or upload it as an attachment.
+
+  - type: input
+    id: tachiyomi-version
+    attributes:
+      label: Tachiyomi version
+      description: You can find your Tachiyomi version in **More → About**.
+      placeholder: |
+        Example: "1.9.3"
+    validations:
+      required: true
+
+  - type: input
+    id: android-version
+    attributes:
+      label: Android version
+      description: You can find this somewhere in your Android settings.
+      placeholder: |
+        Example: "Android 11"
+    validations:
+      required: true
+
+  - type: input
+    id: device
+    attributes:
+      label: Device
+      description: List your device and model.
+      placeholder: |
+        Example: "Google Pixel 5"
+    validations:
+      required: true
+
+  - type: textarea
+    id: other-details
+    attributes:
+      label: Other details
+      placeholder: |
+        Additional details and attachments.
+
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Read this carefully, we will close and ignore your issue if you skimmed through this.
+      options:
+        - label: This is a TachiyomiSY specific issue that does not happen in [Tachiyomi Preview](https://github.com/tachiyomiorg/tachiyomi/).
+          required: true
+        - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open or closed issue.
+          required: true
+        - label: I have written a short but informative title.
+          required: true
+        - label: If this is an issue with an extension, I should be opening an issue in the [extensions repository](https://github.com/tachiyomiorg/tachiyomi-extensions/issues/new/choose).
+          required: true
+        - label: I have tried the [troubleshooting guide](https://tachiyomi.org/help/guides/troubleshooting/).
+          required: true
+        - label: I have updated the app to version **[1.9.3](https://github.com/jobobby04/tachiyomisy/releases/latest)**.
+          required: true
+        - label: I have updated all installed extensions.
+          required: true
+        - label: I will fill out all of the requested information in this form.
+          required: true

.github/ISSUE_TEMPLATE/request_feature.yml

@@ -0,0 +1,39 @@
+name: ⭐ Feature request
+description: Suggest a feature to improve Tachiyomi
+labels: [Feature request]
+body:
+
+  - type: textarea
+    id: feature-description
+    attributes:
+      label: Describe your suggested feature
+      description: How can Tachiyomi be improved?
+      placeholder: |
+        Example:
+          "It should work like this..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: other-details
+    attributes:
+      label: Other details
+      placeholder: |
+        Additional details and attachments.
+
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Read this carefully, we will close and ignore your issue if you skimmed through this.
+      options:
+        - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open or closed issue.
+          required: true
+        - label: I have written a short but informative title.
+          required: true
+        - label: If this is an issue with an extension, I should be opening an issue in the [extensions repository](https://github.com/tachiyomiorg/tachiyomi-extensions/issues/new/choose).
+          required: true
+        - label: I have updated the app to version **[1.9.3](https://github.com/jobobby04/tachiyomisy/releases/latest)**.
+          required: true
+        - label: I will fill out all of the requested information in this form.
+          required: true

.github/ISSUE_TEMPLATE/source_issue.md

@@ -1,8 +0,0 @@
----
-name: "Extension/source/catalogue issue"
-about: "Do not open an issue here. See https://github.com/tachiyomiorg/tachiyomi-extensions"
-title: "THIS ISSUE IS IN THE WRONG REPO; SEE https://github.com/tachiyomiorg/tachiyomi-extensions"
-labels: "catalog, invalid"
----
-
-DO NOT OPEN AN ISSUE IN THIS REPO. SEE https://github.com/tachiyomiorg/tachiyomi-extensions

.github/pull_request_template.md

@@ -0,0 +1,12 @@
+<!--
+  Please include a summary of the change and which issue is fixed.
+  Also make sure you've tested your code and also done a self-review of it.
+  Don't forget to check all base themes and tablet mode for relevant changes.
+  
+  If your changes are visual, please provide images below:
+
+### Images
+| Image 1 | Image 2 |
+| ------- | ------- |
+| ![](https://github.githubassets.com/images/modules/logos_page/Octocat.png) | ![](https://github.githubassets.com/images/modules/logos_page/Octocat.png) |
+-->

.github/runner-files/ci-gradle.properties

@@ -1,6 +0,0 @@
-org.gradle.daemon=false
-org.gradle.jvmargs=-Xmx5120m
-org.gradle.workers.max=2
-
-kotlin.incremental=false
-kotlin.compiler.execution.strategy=in-process

.github/workflows/TachiyomiSY-Release-Builder.yml

@@ -1,91 +0,0 @@
-name: Release Builder
- 
-on:
-  push:
-   branches: 
-    - 'release'
- 
-jobs:
-  check_wrapper:
-    name: Validate Gradle Wrapper
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Clone repo
-        uses: actions/checkout@v2
-
-      - name: Validate Gradle Wrapper
-        uses: gradle/wrapper-validation-action@v1
-
-  build:
-    name: Build app
-    needs: check_wrapper
-    if: "!startsWith(github.event.head_commit.message, '[SKIP CI]')"
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Cancel previous runs
-        uses: styfle/cancel-workflow-action@0.5.0
-        with:
-          access_token: ${{ github.token }}
-
-      - name: Clone repo
-        uses: actions/checkout@v2
-
-      - name: Set up JDK 1.8
-        uses: actions/setup-java@v1
-        with:
-          java-version: 1.8
-
-      - name: Copy CI gradle.properties
-        run: |
-          mkdir -p ~/.gradle
-          cp .github/runner-files/ci-gradle.properties ~/.gradle/gradle.properties
-
-      - name: Write google-services.json
-        uses: DamianReeves/write-file-action@v1.0
-        with:
-          # The path to the file to write
-          path: app/google-services.json
-          # The contents of the file
-          contents: ${{ secrets.GOOGLE_SERVICES_TEXT }}
-          # The mode of writing to use: `overwrite`, `append`, or `preserve`.
-          write-mode: overwrite # optional, default is preserve
-
-      - name: Build app
-        uses: eskatos/gradle-command-action@v1
-        with:
-          arguments: assembleRelease --stacktrace
-          wrapper-cache-enabled: true
-          dependencies-cache-enabled: true
-          configuration-cache-enabled: true
-
-      - name: Sign APK
-        uses: r0adkll/sign-android-release@v1
-        with:
-          releaseDirectory: app/build/outputs/apk/standard/release
-          signingKeyBase64: ${{ secrets.SIGNING_KEY }}
-          alias: ${{ secrets.ALIAS }}
-          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
-          keyPassword: ${{ secrets.KEY_PASSWORD }}
-
-      - name: Create release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.run_number }}
-          release_name: TachiyomiSY
-          draft: true
-          prerelease: false
-
-      - name: Upload APK to release
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ${{ env.SIGNED_RELEASE_FILE }}
-          asset_name: TachiyomiSY.apk
-          asset_content_type: application/vnd.android.package-archive

.github/workflows/build_check.yml

@@ -1,6 +1,10 @@
 name: CI
 on: [pull_request]
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   check_wrapper:
     name: Validate Gradle Wrapper
@@ -8,7 +12,7 @@ jobs:
 
     steps:
       - name: Clone repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Validate Gradle Wrapper
         uses: gradle/wrapper-validation-action@v1
@@ -16,37 +20,25 @@ jobs:
   build:
     name: Build app
     needs: check_wrapper
-    if: "!startsWith(github.event.head_commit.message, '[SKIP CI]')"
     runs-on: ubuntu-latest
 
     steps:
-      - name: Cancel previous runs
-        uses: styfle/cancel-workflow-action@0.5.0
-        with:
-          access_token: ${{ github.token }}
-
       - name: Clone repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
-      - name: Set up JDK 1.8
+      - name: Set up JDK 11
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v3
         with:
-          java-version: 1.8
+          java-version: 11
-
+          distribution: adopt
-      - name: Copy CI gradle.properties
-        run: |
-          mkdir -p ~/.gradle
-          cp .github/runner-files/ci-gradle.properties ~/.gradle/gradle.properties
 
       - name: Build app
-        uses: eskatos/gradle-command-action@v1
+        uses: gradle/gradle-command-action@v2
         with:
-          arguments: assembleStandardDebug
+          arguments: assembleDevDebug
-          wrapper-cache-enabled: true
+
-          dependencies-cache-enabled: true
-          configuration-cache-enabled: true
       - name: Upload APK
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: TachiyomiSY-${{ github.sha }}.apk
           path: app/build/outputs/apk/dev/debug/app-dev-debug.apk

.github/workflows/build_push.yml

@@ -0,0 +1,102 @@
+name: Release Builder
+on:
+  push:
+   branches: 
+    - 'release'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+ 
+jobs:
+  build:
+    name: Build release app
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Clone repo
+        uses: actions/checkout@v3
+
+      - name: Validate Gradle Wrapper
+        uses: gradle/wrapper-validation-action@v1
+
+      - name: Set up JDK 11
+        uses: actions/setup-java@v3
+        with:
+          java-version: 11
+          distribution: adopt
+
+      # SY <--
+      - name: Write google-services.json
+        uses: DamianReeves/write-file-action@v1.2
+        with:
+          path: app/google-services.json
+          contents: ${{ secrets.GOOGLE_SERVICES_TEXT }}
+          write-mode: overwrite
+      # SY -->
+
+      - name: Build app and run unit tests
+        uses: gradle/gradle-command-action@v2
+        with:
+          arguments: lintKotlin assembleStandardRelease testStandardReleaseUnitTest --stacktrace
+
+      - name: Sign APK
+        uses: r0adkll/sign-android-release@v1
+        with:
+          releaseDirectory: app/build/outputs/apk/standard/release
+          signingKeyBase64: ${{ secrets.SIGNING_KEY }}
+          alias: ${{ secrets.ALIAS }}
+          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
+          keyPassword: ${{ secrets.KEY_PASSWORD }}
+
+      - name: Clean up build artifacts
+        run: |
+          set -e
+
+          mv app/build/outputs/apk/standard/release/app-standard-universal-release-unsigned-signed.apk TachiyomiSY.apk
+          sha=`sha256sum TachiyomiSY.apk | awk '{ print $1 }'`
+          echo "APK_UNIVERSAL_SHA=$sha" >> $GITHUB_ENV
+
+          cp app/build/outputs/apk/standard/release/app-standard-arm64-v8a-release-unsigned-signed.apk TachiyomiSY-arm64-v8a.apk
+          sha=`sha256sum TachiyomiSY-arm64-v8a.apk | awk '{ print $1 }'`
+          echo "APK_ARM64_V8A_SHA=$sha" >> $GITHUB_ENV
+
+          cp app/build/outputs/apk/standard/release/app-standard-armeabi-v7a-release-unsigned-signed.apk TachiyomiSY-armeabi-v7a.apk
+          sha=`sha256sum TachiyomiSY-armeabi-v7a.apk | awk '{ print $1 }'`
+          echo "APK_ARMEABI_V7A_SHA=$sha" >> $GITHUB_ENV
+
+          cp app/build/outputs/apk/standard/release/app-standard-x86-release-unsigned-signed.apk TachiyomiSY-x86.apk
+          sha=`sha256sum TachiyomiSY-x86.apk | awk '{ print $1 }'`
+          echo "APK_X86_SHA=$sha" >> $GITHUB_ENV
+          
+          cp app/build/outputs/apk/standard/release/app-standard-x86_64-release-unsigned-signed.apk TachiyomiSY-x86_64.apk
+          sha=`sha256sum TachiyomiSY-x86_64.apk | awk '{ print $1 }'`
+          echo "APK_X86_64_SHA=$sha" >> $GITHUB_ENV
+
+      - name: Create release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ github.run_number }}
+          name: TachiyomiSY
+          body: |
+            ---
+
+            ### Checksums
+
+            | Variant | SHA-256 |
+            | ------- | ------- |
+            | Universal | ${{ env.APK_UNIVERSAL_SHA }} |
+            | arm64-v8a | ${{ env.APK_ARM64_V8A_SHA }} |
+            | armeabi-v7a | ${{ env.APK_ARMEABI_V7A_SHA }} |
+            | x86 | ${{ env.APK_X86_SHA }} |
+            | x86_64 | ${{ env.APK_X86_64_SHA }} |
+          files: |
+            TachiyomiSY.apk
+            TachiyomiSY-arm64-v8a.apk
+            TachiyomiSY-armeabi-v7a.apk
+            TachiyomiSY-x86.apk
+            TachiyomiSY-x86_64.apk
+          draft: true
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build_push_preview.yml

@@ -6,29 +6,20 @@ on:
     - 'master'
  
 jobs:
-  check_wrapper:
+  trigger_preview_build:
-    name: Validate Gradle Wrapper
+    name: Trigger preview build
+    if: ${{ github.ref == 'refs/heads/master' }}
     runs-on: ubuntu-latest
 
     steps:
       - name: Clone repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Validate Gradle Wrapper
         uses: gradle/wrapper-validation-action@v1
 
-  preview:
-    name: Build app preview
-    needs: check_wrapper
-    if: "!startsWith(github.event.head_commit.message, '[SKIP CI]')"
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Clone repo
-        uses: actions/checkout@v2
-
       - name: TAG - Bump version and push tag
-        uses: anothrNick/github-tag-action@1.17.2
+        uses: anothrNick/github-tag-action@1.39.0
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           WITH_V: true

.github/workflows/issue_closer.yml

@@ -1,36 +0,0 @@
-name: Issue closer
-on:
-  issues:
-    types: [opened, edited, reopened]
-
-jobs:
-  autoclose:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Autoclose issues
-        uses: arkon/issue-closer-action@v3.4
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          rules: |
-            [
-              {
-                "type": "title",
-                "regex": ".*THIS ISSUE IS IN THE WRONG REPO.*",
-                "message": "It was not opened in the correct repo, as the template mentioned."
-              },
-              {
-                "type": "title",
-                "regex": ".*<Write short description here>*",
-                "message": "The description in the title was not filled out."
-              },
-              {
-                "type": "body",
-                "regex": ".*DELETE THIS SECTION IF YOU HAVE READ AND ACKNOWLEDGED IT.*",
-                "message": "The acknowledgment section was not removed."
-              },
-              {
-                "type": "body",
-                "regex": ".*\\* (Tachiyomi version|Android version|Device): \\?.*",
-                "message": "Requested information in the template was not filled out."
-              }
-            ]

.github/workflows/issue_moderator.yml

@@ -1,6 +1,8 @@
 name: Issue moderator
 
 on:
+  issues:
+    types: [opened, edited, reopened]
   issue_comment:
     types: [created]
 
@@ -9,6 +11,25 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Moderate issues
-        uses: tachiyomiorg/issue-moderator-action@v1.0
+        uses: tachiyomiorg/issue-moderator-action@v1
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
+          auto-close-rules: |
+            [
+              {
+                "type": "body",
+                "regex": ".*DELETE THIS SECTION IF YOU HAVE READ AND ACKNOWLEDGED IT.*",
+                "message": "The acknowledgment section was not removed."
+              },
+              {
+                "type": "body",
+                "regex": ".*\\* (Tachiyomi version|Android version|Device): \\?.*",
+                "message": "Requested information in the template was not filled out."
+              },
+              {
+                "type": "both",
+                "regex": "^(?!.*myanimelist.*).*(aniyomi|anime).*$",
+                "ignoreCase": true,
+                "message": "Tachiyomi does not support anime, and has no plans to support anime. In addition Tachiyomi is not affiliated with Aniyomi https://github.com/jmir1/aniyomi"
+              }
+            ]

.github/workflows/lock.yml

@@ -3,7 +3,7 @@ name: Lock threads
 on:
   # Daily
   schedule:
-    - cron: '0 * * * *'
+    - cron: '0 0 * * *'
   # Manual trigger
   workflow_dispatch:
     inputs:
@@ -12,8 +12,8 @@ jobs:
   lock:
     runs-on: ubuntu-latest
     steps:
-      - uses: dessant/lock-threads@v2
+      - uses: dessant/lock-threads@v4
         with:
           github-token: ${{ github.token }}
-          issue-lock-inactive-days: '2'
+          issue-inactive-days: '2'
-          pr-lock-inactive-days: '2'
+          pr-inactive-days: '2'

.gitignore

@@ -14,8 +14,8 @@
 *.apk
 app/**/output.json
 
-# Hebrew assets are copied on build
+# Unnecessary file
-app/src/main/res/values-iw/
+*.swp
 
 TODO.md
 CHANGELOG.md

CODE_OF_CONDUCT.md

@@ -1,76 +1,126 @@
-# Code of Conduct
+# Contributor Covenant Code of Conduct
 
 ## Our Pledge
 
-In the interest of fostering an open and welcoming environment, we as
+We as members, contributors, and leaders pledge to make participation in our
-contributors and maintainers pledge to making participation in our project and
+community a harassment-free experience for everyone, regardless of age, body
-our community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
-size, disability, ethnicity, sex characteristics, gender identity and expression,
+identity and expression, level of experience, education, socio-economic status,
-level of experience, education, socio-economic status, nationality, personal
+nationality, personal appearance, race, caste, color, religion, or sexual identity
-appearance, race, religion, or sexual identity and orientation.
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
 
 ## Our Standards
 
-Examples of behavior that contributes to creating a positive environment
+Examples of behavior that contributes to a positive environment for our
-include:
+community include:
 
-* Using welcoming and inclusive language
+* Demonstrating empathy and kindness toward other people
-* Being respectful of differing viewpoints and experiences
+* Being respectful of differing opinions, viewpoints, and experiences
-* Gracefully accepting constructive criticism
+* Giving and gracefully accepting constructive feedback
-* Focusing on what is best for the community
+* Accepting responsibility and apologizing to those affected by our mistakes,
-* Showing empathy towards other community members
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
 
-Examples of unacceptable behavior by participants include:
+Examples of unacceptable behavior include:
 
-* The use of sexualized language or imagery and unwelcome sexual attention or
+* The use of sexualized language or imagery, and sexual attention or
- advances
+  advances of any kind
-* Trolling, insulting/derogatory comments, and personal or political attacks
+* Trolling, insulting or derogatory comments, and personal or political attacks
 * Public or private harassment
-* Publishing others' private information, such as a physical or electronic
+* Publishing others' private information, such as a physical or email
- address, without explicit permission
+  address, without their explicit permission
 * Other conduct which could reasonably be considered inappropriate in a
- professional setting
+  professional setting
 
-## Our Responsibilities
+## Enforcement Responsibilities
 
-Project maintainers are responsible for clarifying the standards of acceptable
+Community moderators are responsible for clarifying and enforcing our standards of
-behavior and are expected to take appropriate and fair corrective action in
+acceptable behavior and will take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
 
-Project maintainers have the right and responsibility to remove, edit, or
+Community moderators have the right and responsibility to remove, edit, or reject
-reject comments, commits, code, wiki edits, issues, and other contributions
+comments, commits, code, wiki edits, issues, and other contributions that are
-that are not aligned to this Code of Conduct, or to ban temporarily or
+not aligned to this Code of Conduct, and will communicate reasons for moderation
-permanently any contributor for other behaviors that they deem inappropriate,
+decisions when appropriate.
-threatening, offensive, or harmful.
 
 ## Scope
 
-This Code of Conduct applies both within project spaces and in public spaces
+This Code of Conduct applies within all community spaces, and also applies when
-when an individual is representing the project or its community. Examples of
+an individual is officially representing the community in public spaces.
-representing a project or community include using an official project e-mail
+Examples of representing our community include using an official e-mail address,
-address, posting via an official social media account, or acting as an appointed
+posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
+representative at an online or offline event.
-further defined and clarified by project maintainers.
 
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at the Tachiyomi [Discord server](https://discord.gg/tachiyomi). All
+reported to the community moderators responsible for enforcement at
-complaints will be reviewed and investigated and will result in a response that
+the [Tachiyomi Discord server](https://discord.gg/tachiyomi).
-is deemed necessary and appropriate to the circumstances. The project team is
+All complaints will be reviewed and investigated promptly and fairly.
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
 
-Project maintainers who do not follow or enforce the Code of Conduct in good
+All community moderators are obligated to respect the privacy and security of the
-faith may face temporary or permanent repercussions as determined by other
+reporter of any incident.
-members of the project's leadership.
+
+## Enforcement Guidelines
+
+Community moderators will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community moderators, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
 
 ## Attribution
 
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/),
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+version 2.1, available at
+[v2.1](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html).
 
-[homepage]: https://www.contributor-covenant.org
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
 
-For answers to common questions about this code of conduct, see
+For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq
+[FAQ](https://www.contributor-covenant.org/faq). Translations are available
+at [translations](https://www.contributor-covenant.org/translations).

CONTRIBUTING.md

@@ -10,7 +10,23 @@ Thanks for your interest in contributing to Tachiyomi!
 Pull requests are welcome!
 
 If you're interested in taking on [an open issue](https://github.com/tachiyomiorg/tachiyomi/issues), please comment on it so others are aware.
+You do not need to ask for permission nor an assignment.
 
+## Prerequisites
+
+Before you start, please note that the ability to use following technologies is **required** and that existing contributors will not actively teach them to you.
+
+- Basic [Android development](https://developer.android.com/)
+- [Kotlin](https://kotlinlang.org/)
+
+### Tools
+
+- [Android Studio](https://developer.android.com/studio)
+- Emulator or phone with developer options enabled to test changes.
+
+## Getting help
+
+- Join [the Discord server](https://discord.gg/tachiyomi) for online help and to ask questions while developing.
 
 # Translations
 
@@ -26,7 +42,7 @@ When creating a fork, remember to:
 - To avoid confusion with the main app:
     - Change the app name
     - Change the app icon
-    - Change or disable the [app update checker](https://github.com/tachiyomiorg/tachiyomi/blob/master/app/src/main/java/eu/kanade/tachiyomi/data/updater/github/GithubUpdateChecker.kt)
+    - Change or disable the [app update checker](https://github.com/tachiyomiorg/tachiyomi/blob/master/app/src/main/java/eu/kanade/tachiyomi/data/updater/AppUpdateChecker.kt)
 - To avoid installation conflicts:
     - Change the `applicationId` in [`build.gradle.kts`](https://github.com/tachiyomiorg/tachiyomi/blob/master/app/build.gradle.kts)
 - To avoid having your data polluting the main app's analytics and crash report services:

README.md

@@ -11,10 +11,10 @@ Tachiyomi is a free and open source manga reader for Android 6.0 and above. This
 ## Features
 
 Features of Tachiyomi(original) include:
-* Online reading from [a variety of sources](https://github.com/tachiyomiorg/tachiyomi-extensions)
+* Online reading from a variety of sources
-* Local reading of downloaded manga
+* Local reading of downloaded content
 * A configurable reader with multiple viewers, reading directions and other settings.
-* [MyAnimeList](https://myanimelist.net/), [AniList](https://anilist.co/), [Kitsu](https://kitsu.io/), [Shikimori](https://shikimori.one), and [Bangumi](https://bgm.tv/) support
+* Tracker support: [MyAnimeList](https://myanimelist.net/), [AniList](https://anilist.co/), [Kitsu](https://kitsu.io/), [MangaUpdates](https://mangaupdates.com), [Shikimori](https://shikimori.one), and [Bangumi](https://bgm.tv/) support
 * Categories to organize your library
 * Light and dark themes
 * Schedule updating your library for new chapters
@@ -58,11 +58,8 @@ Custom sources:
 Additional features for some extensions, features include custom description, opening in app, batch add to library, and a bunch of other things based on the source:
 * 8Muses (EroMuse)
 * HBrowse
-* HentaiCafe (inside Foolside)
-* Hitomi.la
 * Mangadex
 * NHentai
-* PervEden (EN and IT)
 * Puruin
 * Tsumino
 
@@ -84,13 +81,12 @@ Please make sure to read the full guidelines. Your issue may be closed without w
 
 <details><summary>Bugs</summary>
 
-* Include version (More > About > Version)
+* Include version (More → About → Version)
- * If not latest, try updating, it may have already been solved
+* If not latest, try updating, it may have already been solved
- * Preview version is equal to the number of commits as seen in the main page
+* Preview version is equal to the number of commits as seen in the main page
 * Include steps to reproduce (if not obvious from description)
 * Include screenshot (if needed)
 * If it could be device-dependent, try reproducing on another device (if possible)
-* For large logs use http://pastebin.com/ (or similar)
 * Don't group unrelated requests into one issue
 
 DO: https://github.com/tachiyomiorg/tachiyomi/issues/24 https://github.com/tachiyomiorg/tachiyomi/issues/71

app/build.gradle.kts

@@ -1,8 +1,5 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import java.io.ByteArrayOutputStream
+import org.jmailen.gradle.kotlinter.tasks.LintTask
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.TimeZone
 
 plugins {
     id("com.android.application")
@@ -10,68 +7,82 @@ plugins {
     kotlin("android")
     kotlin("plugin.parcelize")
     kotlin("plugin.serialization")
-    id("com.github.zellius.shortcut-helper")
+    //id("com.github.zellius.shortcut-helper")
-    // Realm (EH)
+    id("com.github.ben-manes.versions")
-    kotlin("kapt")
-    id("realm-android")
 }
 
-if (!gradle.startParameter.taskRequests.toString().contains("Debug")) {
+if (gradle.startParameter.taskRequests.toString().contains("Standard")) {
-    apply(plugin = "com.google.gms.google-services")
+    apply<com.google.gms.googleservices.GoogleServicesPlugin>()
     // Firebase Crashlytics
     apply(plugin = "com.google.firebase.crashlytics")
 }
 
-shortcutHelper.setFilePath("./shortcuts.xml")
+//shortcutHelper.setFilePath("./shortcuts.xml")
+
+val SUPPORTED_ABIS = setOf("armeabi-v7a", "arm64-v8a", "x86", "x86_64")
 
 android {
-    compileSdkVersion(AndroidConfig.compileSdk)
+    namespace = "eu.kanade.tachiyomi"
-    buildToolsVersion(AndroidConfig.buildTools)
-    ndkVersion = AndroidConfig.ndk
 
     defaultConfig {
         applicationId = "eu.kanade.tachiyomi.sy"
-        minSdkVersion(AndroidConfig.minSdk)
+        versionCode = 50
-        targetSdkVersion(AndroidConfig.targetSdk)
+        versionName = "1.9.3"
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-        versionCode = 19
-        versionName = "1.7.0"
 
         buildConfigField("String", "COMMIT_COUNT", "\"${getCommitCount()}\"")
         buildConfigField("String", "COMMIT_SHA", "\"${getGitSha()}\"")
         buildConfigField("String", "BUILD_TIME", "\"${getBuildTime()}\"")
         buildConfigField("boolean", "INCLUDE_UPDATER", "false")
 
-        multiDexEnabled = true
-
         ndk {
-            abiFilters += setOf("armeabi-v7a", "arm64-v8a", "x86")
+            abiFilters += SUPPORTED_ABIS
         }
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
-    buildFeatures {
+    splits {
-        viewBinding = true
+        abi {
+            isEnable = true
+            reset()
+            include(*SUPPORTED_ABIS.toTypedArray())
+            isUniversalApk = true
+        }
     }
 
     buildTypes {
         named("debug") {
             versionNameSuffix = "-${getCommitCount()}"
             applicationIdSuffix = ".debug"
+            isPseudoLocalesEnabled = true
         }
         create("releaseTest") {
             applicationIdSuffix = ".rt"
             //isMinifyEnabled = true
             //isShrinkResources = true
             setProguardFiles(listOf(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"))
+            matchingFallbacks.add("release")
         }
         named("release") {
             isMinifyEnabled = true
             isShrinkResources = true
             setProguardFiles(listOf(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"))
         }
+        create("benchmark") {
+            initWith(getByName("release"))
+
+            signingConfig = signingConfigs.getByName("debug")
+            matchingFallbacks.add("release")
+            isDebuggable = false
+            versionNameSuffix = "-benchmark"
+            applicationIdSuffix = ".benchmark"
+        }
     }
 
-    flavorDimensions("default")
+    sourceSets {
+        getByName("benchmark").res.srcDirs("src/debug/res")
+    }
+
+    flavorDimensions.add("default")
 
     productFlavors {
         create("standard") {
@@ -82,286 +93,244 @@ android {
             dimension = "default"
         }
         create("dev") {
-            resConfigs("en", "xxhdpi")
+            // Include pseudolocales: https://developer.android.com/guide/topics/resources/pseudolocales
+            resourceConfigurations.addAll(listOf("en", "en_XA", "ar_XB", "xxhdpi"))
             dimension = "default"
         }
     }
 
     packagingOptions {
-        exclude("META-INF/DEPENDENCIES")
+        resources.excludes.addAll(listOf(
-        exclude("LICENSE.txt")
+            "META-INF/DEPENDENCIES",
-        exclude("META-INF/LICENSE")
+            "LICENSE.txt",
-        exclude("META-INF/LICENSE.txt")
+            "META-INF/LICENSE",
-        exclude("META-INF/NOTICE")
+            "META-INF/LICENSE.txt",
-        exclude("META-INF/*.kotlin_module")
+            "META-INF/README.md",
-
+            "META-INF/NOTICE",
-        // Compatibility for two RxJava versions (EXH)
+            "META-INF/*.kotlin_module",
-        exclude("META-INF/rxjava.properties")
+        ))
     }
 
     dependenciesInfo {
         includeInApk = false
     }
 
-    lintOptions {
+    buildFeatures {
-        disable("MissingTranslation", "ExtraTranslation")
+        viewBinding = true
-        isAbortOnError = false
+        compose = true
-        isCheckReleaseBuilds = false
+
+        // Disable some unused things
+        aidl = false
+        renderScript = false
+        shaders = false
     }
 
-    compileOptions {
+    lint {
-        sourceCompatibility = JavaVersion.VERSION_1_8
+        abortOnError = false
-        targetCompatibility = JavaVersion.VERSION_1_8
+        checkReleaseBuilds = false
     }
 
-    kotlinOptions {
+    composeOptions {
-        jvmTarget = JavaVersion.VERSION_1_8.toString()
+        kotlinCompilerExtensionVersion = compose.versions.compiler.get()
     }
 }
 
 dependencies {
+    implementation(project(":i18n"))
+    implementation(project(":core"))
+    implementation(project(":source-api"))
+    implementation(project(":data"))
+    implementation(project(":domain"))
+    implementation(project(":presentation-core"))
+    implementation(project(":presentation-widget"))
 
-    // Source models and interfaces from Tachiyomi 1.x
+    // Compose
-    implementation("org.tachiyomi:source-api:1.1")
+    implementation(platform(compose.bom))
+    implementation(compose.activity)
+    implementation(compose.foundation)
+    implementation(compose.material3.core)
+    implementation(compose.material.core)
+    implementation(compose.material.icons)
+    implementation(compose.animation)
+    implementation(compose.animation.graphics)
+    implementation(compose.ui.tooling)
+    implementation(compose.ui.util)
+    implementation(compose.accompanist.webview)
+    implementation(compose.accompanist.flowlayout)
+    implementation(compose.accompanist.permissions)
+    implementation(compose.accompanist.themeadapter)
+    implementation(compose.accompanist.systemuicontroller)
+
+    implementation(androidx.paging.runtime)
+    implementation(androidx.paging.compose)
+
+    implementation(libs.bundles.sqlite)
+
+    implementation(kotlinx.reflect)
+
+    implementation(platform(kotlinx.coroutines.bom))
+    implementation(kotlinx.bundles.coroutines)
 
     // AndroidX libraries
-    implementation("androidx.annotation:annotation:1.3.0-alpha01")
+    implementation(androidx.annotation)
-    implementation("androidx.appcompat:appcompat:1.4.0-alpha01")
+    implementation(androidx.appcompat)
-    implementation("androidx.biometric:biometric-ktx:1.2.0-alpha03")
+    implementation(androidx.biometricktx)
-    implementation("androidx.browser:browser:1.3.0")
+    implementation(androidx.constraintlayout)
-    implementation("androidx.cardview:cardview:1.0.0")
+    implementation(androidx.coordinatorlayout)
-    implementation("androidx.constraintlayout:constraintlayout:2.1.0-beta02")
+    implementation(androidx.corektx)
-    implementation("androidx.coordinatorlayout:coordinatorlayout:1.1.0")
+    implementation(androidx.splashscreen)
-    implementation("androidx.core:core-ktx:1.6.0-beta01")
+    implementation(androidx.recyclerview)
-    implementation("androidx.multidex:multidex:2.0.1")
+    implementation(androidx.viewpager)
-    implementation("androidx.preference:preference-ktx:1.1.1")
+    implementation(androidx.profileinstaller)
-    implementation("androidx.recyclerview:recyclerview:1.2.0")
-    implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.2.0-alpha01")
 
-    val lifecycleVersion = "2.4.0-alpha01"
+    implementation(androidx.bundles.lifecycle)
-    implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycleVersion")
-    implementation("androidx.lifecycle:lifecycle-process:$lifecycleVersion")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycleVersion")
 
     // Job scheduling
-    implementation("androidx.work:work-runtime-ktx:2.7.0-alpha03")
+    implementation(androidx.bundles.workmanager)
 
-    // UI library
+    // RX
-    implementation("com.google.android.material:material:1.4.0-beta01")
+    implementation(libs.bundles.reactivex)
-
+    implementation(libs.flowreactivenetwork)
-    "standardImplementation"("com.google.firebase:firebase-core:19.0.0")
-
-    // ReactiveX
-    implementation("io.reactivex:rxandroid:1.2.1")
-    implementation("io.reactivex:rxjava:1.3.8")
-    implementation("com.jakewharton.rxrelay:rxrelay:1.2.0")
-    implementation("com.github.pwittchen:reactivenetwork:0.13.0")
 
     // Network client
-    val okhttpVersion = "4.9.1"
+    implementation(libs.bundles.okhttp)
-    implementation("com.squareup.okhttp3:okhttp:$okhttpVersion")
+    implementation(libs.okio)
-    implementation("com.squareup.okhttp3:logging-interceptor:$okhttpVersion")
-    implementation("com.squareup.okhttp3:okhttp-dnsoverhttps:$okhttpVersion")
-    implementation("com.squareup.okio:okio:2.10.0")
 
     // TLS 1.3 support for Android < 10
-    implementation("org.conscrypt:conscrypt-android:2.5.1")
+    implementation(libs.conscrypt.android)
 
-    // JSON
+    // Data serialization (JSON, protobuf)
-    val kotlinSerializationVersion = "1.1.0"
+    implementation(kotlinx.bundles.serialization)
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlinSerializationVersion")
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$kotlinSerializationVersion")
-    implementation("com.google.code.gson:gson:2.8.6")
-    implementation("com.github.salomonbrys.kotson:kotson:2.5.0")
-
-    // JavaScript engine
-    implementation("com.squareup.duktape:duktape-android:1.3.0")
-
-    // Disk
-    implementation("com.jakewharton:disklrucache:2.0.2")
-    implementation("com.github.tachiyomiorg:unifile:17bec43")
-    implementation("com.github.junrar:junrar:7.4.0")
 
     // HTML parser
-    implementation("org.jsoup:jsoup:1.13.1")
+    implementation(libs.jsoup)
 
-    // Database
+    // Disk
-    implementation("androidx.sqlite:sqlite-ktx:2.1.0")
+    implementation(libs.disklrucache)
-    implementation("com.github.inorichi.storio:storio-common:8be19de@aar")
+    implementation(libs.unifile)
-    implementation("com.github.inorichi.storio:storio-sqlite:8be19de@aar")
+    implementation(libs.junrar)
-    implementation("com.github.requery:sqlite-android:3.35.5")
 
     // Preferences
-    implementation("com.github.tfcporciuncula.flow-preferences:flow-preferences:1.4.0")
+    implementation(libs.preferencektx)
-
-    // Model View Presenter
-    val nucleusVersion = "3.0.0"
-    implementation("info.android15.nucleus:nucleus:$nucleusVersion")
-    implementation("info.android15.nucleus:nucleus-support-v7:$nucleusVersion")
 
     // Dependency injection
-    implementation("com.github.inorichi.injekt:injekt-core:65b0440")
+    implementation(libs.injekt.core)
 
-    // Image library
+    // Image loading
-    val coilVersion = "1.2.0"
+    implementation(libs.bundles.coil)
-    implementation("io.coil-kt:coil:$coilVersion")
+    implementation(libs.subsamplingscaleimageview) {
-    implementation("io.coil-kt:coil-gif:$coilVersion")
-
-    implementation("com.github.tachiyomiorg:subsampling-scale-image-view:846abe0") {
         exclude(module = "image-decoder")
     }
-    implementation("com.github.tachiyomiorg:image-decoder:7a44c9b")
+    implementation(libs.image.decoder)
-
-    // Logging
-    implementation("com.jakewharton.timber:timber:4.7.1")
-
-    // Crash reports
-    //implementation("ch.acra:acra-http:5.7.0")
 
     // Sort
-    implementation("com.github.gpanther:java-nat-sort:natural-comparator-1.1")
+    implementation(libs.natural.comparator)
 
-    // UI
+    // UI libraries
-    implementation("com.github.dmytrodanylyk.android-process-button:library:1.0.4")
+    implementation(libs.material)
-    implementation("eu.davidea:flexible-adapter:5.1.0")
+    implementation(libs.flexible.adapter.core)
-    implementation("eu.davidea:flexible-adapter-ui:1.0.0")
+    implementation(libs.flexible.adapter.ui)
-    implementation("com.nightlynexus.viewstatepageradapter:viewstatepageradapter:1.1.0")
+    implementation(libs.photoview)
-    implementation("com.github.chrisbanes:PhotoView:2.3.0")
+    implementation(libs.directionalviewpager) {
-    implementation("com.github.tachiyomiorg:DirectionalViewPager:1.0.0")
+        exclude(group = "androidx.viewpager", module = "viewpager")
-    implementation("dev.chrisbanes.insetter:insetter:0.6.0")
-
-    // 3.2.0+ introduces weird UI blinking or cut off issues on some devices
-    val materialDialogsVersion = "3.1.1"
-    implementation("com.afollestad.material-dialogs:core:$materialDialogsVersion")
-    implementation("com.afollestad.material-dialogs:input:$materialDialogsVersion")
-    implementation("com.afollestad.material-dialogs:datetime:$materialDialogsVersion")
-
-    // Conductor
-    implementation("com.bluelinelabs:conductor:2.1.5")
-    implementation("com.bluelinelabs:conductor-support:2.1.5") {
-        exclude(group = "com.android.support")
     }
-    implementation("com.github.tachiyomiorg:conductor-support-preference:2.0.1")
+    implementation(libs.insetter)
+    implementation(libs.bundles.richtext)
+    implementation(libs.aboutLibraries.compose)
+    implementation(libs.cascade)
+    implementation(libs.bundles.voyager)
+    implementation(libs.wheelpicker)
+    implementation(libs.materialmotion.core)
 
-    // FlowBinding
+    // Logging
-    val flowbindingVersion = "1.0.0"
+    implementation(libs.logcat)
-    implementation("io.github.reactivecircus.flowbinding:flowbinding-android:$flowbindingVersion")
-    implementation("io.github.reactivecircus.flowbinding:flowbinding-appcompat:$flowbindingVersion")
-    implementation("io.github.reactivecircus.flowbinding:flowbinding-recyclerview:$flowbindingVersion")
-    implementation("io.github.reactivecircus.flowbinding:flowbinding-swiperefreshlayout:$flowbindingVersion")
-    implementation("io.github.reactivecircus.flowbinding:flowbinding-viewpager:$flowbindingVersion")
 
-    // Licenses
+    // Crash reports/analytics
-    implementation("com.mikepenz:aboutlibraries:${BuildPluginsVersion.ABOUTLIB_PLUGIN}")
+    // implementation(libs.acra.http)
+    // "standardImplementation"(libs.firebase.analytics)
+
+    // Shizuku
+    implementation(libs.bundles.shizuku)
 
     // Tests
-    testImplementation("junit:junit:4.13.2")
+    testImplementation(libs.junit)
-    testImplementation("org.assertj:assertj-core:3.16.1")
-    testImplementation("org.mockito:mockito-core:1.10.19")
-
-    val robolectricVersion = "3.1.4"
-    testImplementation("org.robolectric:robolectric:$robolectricVersion")
-    testImplementation("org.robolectric:shadows-multidex:$robolectricVersion")
-    testImplementation("org.robolectric:shadows-play-services:$robolectricVersion")
-
-    implementation(kotlin("reflect", version = BuildPluginsVersion.KOTLIN))
-
-    val coroutinesVersion = "1.5.0"
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutinesVersion")
 
     // For detecting memory leaks; see https://square.github.io/leakcanary/
-    // debugImplementation("com.squareup.leakcanary:leakcanary-android:2.7")
+    // debugImplementation(libs.leakcanary.android)
+    implementation(libs.leakcanary.plumber)
 
     // SY -->
-    // [EXH] Android 7 SSL Workaround
-    implementation("com.google.android.gms:play-services-safetynet:17.0.0")
-
-    // Changelog
-    implementation("com.github.gabrielemariotti.changeloglib:changelog:2.1.0")
-
     // Text distance (EH)
-    implementation ("info.debatty:java-string-similarity:2.0.0")
+    implementation (sylibs.simularity)
 
     // Firebase (EH)
-    implementation("com.google.firebase:firebase-analytics-ktx:19.0.0")
+    implementation(sylibs.firebase.analytics)
-    implementation("com.google.firebase:firebase-crashlytics-ktx:18.0.0")
+    implementation(sylibs.firebase.crashlytics.ktx)
 
     // Better logging (EH)
-    implementation("com.elvishew:xlog:1.9.0")
+    implementation(sylibs.xlog)
-
-    // Debug utils (EH)
-    val debugOverlayVersion = "1.1.3"
-    debugImplementation("com.ms-square:debugoverlay:$debugOverlayVersion")
-    "releaseTestImplementation"("com.ms-square:debugoverlay-no-op:$debugOverlayVersion")
-    releaseImplementation("com.ms-square:debugoverlay-no-op:$debugOverlayVersion")
-    testImplementation("com.ms-square:debugoverlay-no-op:$debugOverlayVersion")
 
     // RatingBar (SY)
-    implementation("me.zhanghai.android.materialratingbar:library:1.4.0")
+    implementation(sylibs.ratingbar)
+    implementation(sylibs.composeRatingbar)
+}
+
+androidComponents {
+    beforeVariants { variantBuilder ->
+        // Disables standardBenchmark
+        if (variantBuilder.buildType == "benchmark") {
+            variantBuilder.enable = variantBuilder.productFlavors.containsAll(listOf("default" to "dev"))
+        }
+    }
+    onVariants(selector().withFlavor("default" to "standard")) {
+        // Only excluding in standard flavor because this breaks
+        // Layout Inspector's Compose tree
+        it.packaging.resources.excludes.add("META-INF/*.version")
+    }
 }
 
 tasks {
+
+    withType<LintTask>().configureEach {
+        exclude { it.file.path.contains("generated[\\\\/]".toRegex()) }
+    }
+
     // See https://kotlinlang.org/docs/reference/experimental.html#experimental-status-of-experimental-api(-markers)
     withType<KotlinCompile> {
         kotlinOptions.freeCompilerArgs += listOf(
-            "-Xopt-in=kotlin.Experimental",
+            "-opt-in=coil.annotation.ExperimentalCoilApi",
-            "-Xopt-in=kotlin.RequiresOptIn",
+            "-opt-in=com.google.accompanist.permissions.ExperimentalPermissionsApi",
-            "-Xuse-experimental=kotlin.ExperimentalStdlibApi",
+            "-opt-in=androidx.compose.foundation.layout.ExperimentalLayoutApi",
-            "-Xuse-experimental=kotlinx.coroutines.FlowPreview",
+            "-opt-in=androidx.compose.material.ExperimentalMaterialApi",
-            "-Xuse-experimental=kotlinx.coroutines.ExperimentalCoroutinesApi",
+            "-opt-in=androidx.compose.material3.ExperimentalMaterial3Api",
-            "-Xuse-experimental=kotlinx.coroutines.InternalCoroutinesApi",
+            "-opt-in=androidx.compose.material.ExperimentalMaterialApi",
-            "-Xuse-experimental=kotlinx.serialization.ExperimentalSerializationApi",
+            "-opt-in=androidx.compose.ui.ExperimentalComposeUiApi",
-            "-Xuse-experimental=coil.annotation.ExperimentalCoilApi",
+            "-opt-in=androidx.compose.foundation.ExperimentalFoundationApi",
+            "-opt-in=androidx.compose.animation.ExperimentalAnimationApi",
+            "-opt-in=androidx.compose.animation.graphics.ExperimentalAnimationGraphicsApi",
+            "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+            "-opt-in=kotlinx.coroutines.FlowPreview",
+            "-opt-in=kotlinx.coroutines.InternalCoroutinesApi",
+            "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
         )
-    }
 
-    // Duplicating Hebrew string assets due to some locale code issues on different devices
+        if (project.findProperty("tachiyomi.enableComposeCompilerMetrics") == "true") {
-    val copyHebrewStrings = task("copyHebrewStrings", type = Copy::class) {
+            kotlinOptions.freeCompilerArgs += listOf(
-        from("./src/main/res/values-he")
+                "-P",
-        into("./src/main/res/values-iw")
+                "plugin:androidx.compose.compiler.plugins.kotlin:reportsDestination=" +
-        include("**/*")
+                    project.buildDir.absolutePath + "/compose_metrics"
-    }
+            )
-
+            kotlinOptions.freeCompilerArgs += listOf(
-    preBuild {
+                "-P",
-        dependsOn(formatKotlin, copyHebrewStrings)
+                "plugin:androidx.compose.compiler.plugins.kotlin:metricsDestination=" +
+                    project.buildDir.absolutePath + "/compose_metrics"
+            )
+        }
     }
 }
 
-
 buildscript {
-    repositories {
-        mavenCentral()
-    }
     dependencies {
-        classpath(kotlin("gradle-plugin", version = BuildPluginsVersion.KOTLIN))
+        classpath(kotlinx.gradle)
     }
 }
-
-
-// Git is needed in your system PATH for these commands to work.
-// If it's not installed, you can return a random value as a workaround
-fun getCommitCount(): String {
-    return runCommand("git rev-list --count HEAD")
-    // return "1"
-}
-
-fun getGitSha(): String {
-    return runCommand("git rev-parse --short HEAD")
-    // return "1"
-}
-
-fun getBuildTime(): String {
-    val df = SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'")
-    df.timeZone = TimeZone.getTimeZone("UTC")
-    return df.format(Date())
-}
-
-fun runCommand(command: String): String {
-    val byteOut = ByteArrayOutputStream()
-    project.exec {
-        commandLine = command.split(" ")
-        standardOutput = byteOut
-    }
-    return String(byteOut.toByteArray()).trim()
-}

app/proguard-rules.pro

@@ -1,36 +1,48 @@
 -dontobfuscate
 
-# Extensions may require methods unused in the core app
+# Keep common dependencies used in extensions
--dontwarn eu.kanade.tachiyomi.**
+-keep,allowoptimization class androidx.preference.** { public protected *; }
--keep class eu.kanade.tachiyomi.** { public protected private *; }
+-keep,allowoptimization class kotlin.** { public protected *; }
+-keep,allowoptimization class kotlinx.coroutines.** { public protected *; }
+-keep,allowoptimization class kotlinx.serialization.** { public protected *; }
+-keep,allowoptimization class okhttp3.** { public protected *; }
+-keep,allowoptimization class okio.** { public protected *; }
+-keep,allowoptimization class rx.** { public protected *; }
+-keep,allowoptimization class org.jsoup.** { public protected *; }
+-keep,allowoptimization class app.cash.quickjs.** { public protected *; }
+-keep,allowoptimization class uy.kohesive.injekt.** { public protected *; }
 
--keep class org.jsoup.** { *; }
+# From extensions-lib
--keep class kotlin.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.interceptor.RateLimitInterceptorKt { public protected *; }
--keep class okhttp3.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.interceptor.SpecificHostRateLimitInterceptorKt { public protected *; }
--keep class com.google.gson.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.NetworkHelper { public protected *; }
--keep class com.github.salomonbrys.kotson.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.OkHttpExtensionsKt { public protected *; }
--keep class com.squareup.duktape.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.RequestsKt { public protected *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.AppInfo { public protected *; }
 
-# === Keep EH classes
+# Debug functions
--keep class exh.** { *; }
+-keep,allowoptimization class exh.debug.DebugFunctions { public *; }
--keep class xyz.nulldev.** { *; }
 
-# === Keep RxAndroid, https://github.com/ReactiveX/RxAndroid/issues/350
+##---------------Begin: proguard configuration for RxJava 1.x  ----------
--keep class rx.android.** { *; }
+-dontwarn sun.misc.**
 
-# Design library
+-keepclassmembers class rx.internal.util.unsafe.*ArrayQueue*Field* {
--dontwarn com.google.android.material.**
+   long producerIndex;
--keep class com.google.android.material.** { *; }
+   long consumerIndex;
--keep interface com.google.android.material.** { *; }
--keep public class com.google.android.material.R$* { *; }
-
--keep class com.hippo.image.** { *; }
--keep interface com.hippo.image.** { *; }
--keepclassmembers class * extends nucleus.presenter.Presenter {
-    <init>();
 }
 
-# Kotlin Serialization
+-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueProducerNodeRef {
+    rx.internal.util.atomic.LinkedQueueNode producerNode;
+}
+
+-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueConsumerNodeRef {
+    rx.internal.util.atomic.LinkedQueueNode consumerNode;
+}
+
+-dontnote rx.internal.util.PlatformDependent
+##---------------End: proguard configuration for RxJava 1.x  ----------
+
+##---------------Begin: proguard configuration for kotlinx.serialization  ----------
 -keepattributes *Annotation*, InnerClasses
 -dontnote kotlinx.serialization.AnnotationsKt # core serialization annotations
 
@@ -42,11 +54,19 @@
     kotlinx.serialization.KSerializer serializer(...);
 }
 
--keep,includedescriptorclasses class eu.kanade.tachiyomi.**$$serializer { *; }
+-keep,includedescriptorclasses class eu.kanade.**$$serializer { *; }
--keepclassmembers class eu.kanade.tachiyomi.** {
+-keepclassmembers class eu.kanade.** {
     *** Companion;
 }
--keepclasseswithmembers class eu.kanade.tachiyomi.** {
+-keepclasseswithmembers class eu.kanade.** {
+    kotlinx.serialization.KSerializer serializer(...);
+}
+
+-keep,includedescriptorclasses class tachiyomi.**$$serializer { *; }
+-keepclassmembers class tachiyomi.** {
+    *** Companion;
+}
+-keepclasseswithmembers class tachiyomi.** {
     kotlinx.serialization.KSerializer serializer(...);
 }
 
@@ -67,23 +87,11 @@
     kotlinx.serialization.KSerializer serializer(...);
 }
 
-# Keep extension's common dependencies
+-keep class kotlinx.serialization.**
--keep,allowoptimization class eu.kanade.tachiyomi.** { public protected *; }
+-keepclassmembers class kotlinx.serialization.** {
--keep,allowoptimization class kotlin.** { public protected *; }
+    <methods>;
--keep,allowoptimization class okhttp3.** { public protected *; }
+}
--keep,allowoptimization class rx.** { public protected *; }
+##---------------End: proguard configuration for kotlinx.serialization  ----------
--keep,allowoptimization class org.jsoup.** { public protected *; }
--keep,allowoptimization class com.google.gson.** { public protected *; }
--keep,allowoptimization class com.github.salomonbrys.kotson.** { public protected *; }
--keep,allowoptimization class com.squareup.duktape.** { public protected *; }
--keep,allowoptimization class androidx.preference.** { *; }
--keep,allowoptimization class okio.** { *; }
--keep,allowoptimization class kotlinx.serialization.** { *; }
-
-# RxJava 1.1.0
--dontwarn sun.misc.**
-
--dontnote rx.internal.util.PlatformDependent
 
 # === Reactive network: https://github.com/pwittchen/ReactiveNetwork/tree/v0.12.4#proguard-configuration
 -dontwarn com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
@@ -104,32 +112,20 @@
 # === Okio: https://github.com/square/okio/tree/9b8545e7fa267c9d89753283990f24a35cd69cd6#proguard
 -dontwarn okio.**
 
-# === GSON: https://raw.githubusercontent.com/google/gson/master/examples/android-proguard-example/proguard.cfg
+# === Keep RxAndroid, https://github.com/ReactiveX/RxAndroid/issues/350
-# Gson uses generic type information stored in a class file when working with fields. Proguard
+-keep class rx.android.** { *; }
-# removes such information by default, so configure it to keep all of it.
--keepattributes Signature
 
-# For using GSON @Expose annotation
+# XmlUtil
--keepattributes *Annotation*
+-keep public enum nl.adaptivity.xmlutil.EventType { *; }
 
-# Gson specific classes
+# Design library
--dontwarn sun.misc.**
+-dontwarn com.google.android.material.**
-#-keep class com.google.gson.stream.** { *; }
+-keep class com.google.android.material.** { *; }
+-keep interface com.google.android.material.** { *; }
+-keep public class com.google.android.material.R$* { *; }
 
-# Application classes that will be serialized/deserialized over Gson
+-keep class com.hippo.image.** { *; }
--keep class com.google.gson.examples.android.model.** { <fields>; }
+-keep interface com.hippo.image.** { *; }
-
-# Prevent proguard from stripping interface information from TypeAdapterFactory, TypeAdapter,
-# JsonSerializer, JsonDeserializer instances (so they can be used in @JsonAdapter)
--keep class * extends com.google.gson.TypeAdapter
--keep class * implements com.google.gson.TypeAdapterFactory
--keep class * implements com.google.gson.JsonSerializer
--keep class * implements com.google.gson.JsonDeserializer
-
-# Prevent R8 from leaving Data object members always null
--keepclassmembers,allowobfuscation class * {
-  @com.google.gson.annotations.SerializedName <fields>;
-}
 
 # == Nucleus
 -keepclassmembers class * extends nucleus.presenter.Presenter {
@@ -142,12 +138,6 @@
 ## From original config: "Attempt to fix: java.lang.NoClassDefFoundError: uy.kohesive.injekt.registry.default.DefaultRegistrar$NOKEY$1"
 -keep class uy.kohesive.injekt.** { *; }
 
-# === Conductor
-# This isn't in the consumer proguard rules yet: https://github.com/bluelinelabs/Conductor/pull/550/files
--keepclassmembers public class * extends com.bluelinelabs.conductor.ControllerChangeHandler {
-   public <init>();
-}
-
 # === RxBinding
 -dontwarn com.google.auto.value.AutoValue
 

app/src/debug/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -2,4 +2,5 @@
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
     <background android:drawable="@color/ic_launcher_background"/>
     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+    <monochrome android:drawable="@drawable/ic_tachi_monochrome_launcher" />
 </adaptive-icon>

app/src/debug/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -2,4 +2,5 @@
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
     <background android:drawable="@color/ic_launcher_background"/>
     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+    <monochrome android:drawable="@drawable/ic_tachi_monochrome_launcher" />
 </adaptive-icon>

app/src/main/AndroidManifest.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="eu.kanade.tachiyomi">
+    xmlns:tools="http://schemas.android.com/tools">
 
     <!-- Internet -->
     <uses-permission android:name="android.permission.INTERNET" />
@@ -19,26 +19,41 @@
     <!-- For managing extensions -->
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
     <uses-permission android:name="android.permission.REQUEST_DELETE_PACKAGES" />
+    <uses-permission android:name="android.permission.UPDATE_PACKAGES_WITHOUT_USER_ACTION" />
     <!-- To view extension packages in API 30+ -->
     <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" />
 
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.READ_APP_SPECIFIC_LOCALES" />
+
+    <!-- Remove permission from Firebase dependency -->
+    <uses-permission android:name="com.google.android.gms.permission.AD_ID"
+        tools:node="remove" />
+
     <application
         android:name=".App"
-        android:allowBackup="true"
+        android:allowBackup="false"
-        android:fullBackupContent="@xml/backup_rules"
         android:hardwareAccelerated="true"
-        android:hasFragileUserData="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:largeHeap="true"
+        android:localeConfig="@xml/locales_config"
         android:requestLegacyExternalStorage="true"
         android:roundIcon="@mipmap/ic_launcher_round"
-        android:theme="@style/Theme.Base"
+        android:theme="@style/Theme.Tachiyomi"
+        android:supportsRtl="true"
         android:networkSecurityConfig="@xml/network_security_config">
+
+        <!-- enable profiling by macrobenchmark -->
+        <profileable
+            android:shell="true"
+            tools:targetApi="q" />
+
         <activity
             android:name=".ui.main.MainActivity"
             android:launchMode="singleTop"
-            android:theme="@style/Theme.Splash">
+            android:theme="@style/Theme.Tachiyomi.SplashScreen"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
@@ -48,11 +63,18 @@
                 android:name="android.app.shortcuts"
                 android:resource="@xml/shortcuts" />
         </activity>
+
+        <activity
+            android:process=":error_handler"
+            android:name=".crash.CrashActivity"
+            android:exported="false" />
+
         <activity
             android:name=".ui.main.DeepLinkActivity"
             android:launchMode="singleTask"
             android:theme="@android:style/Theme.NoDisplay"
-            android:label="@string/action_global_search">
+            android:label="@string/action_global_search"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.SEARCH" />
                 <action android:name="com.google.android.gms.actions.SEARCH_ACTION" />
@@ -73,9 +95,11 @@
                 android:name="android.app.searchable"
                 android:resource="@xml/searchable" />
         </activity>
+
         <activity
             android:name=".ui.reader.ReaderActivity"
-            android:launchMode="singleTask">
+            android:launchMode="singleTask"
+            android:exported="false">
             <intent-filter>
                 <action android:name="com.samsung.android.support.REMOTE_ACTION" />
             </intent-filter>
@@ -83,15 +107,26 @@
             <meta-data android:name="com.samsung.android.support.REMOTE_ACTION"
                 android:resource="@xml/s_pen_actions"/>
         </activity>
+
         <activity
             android:name=".ui.security.UnlockActivity"
-            android:theme="@style/Theme.Base" />
+            android:theme="@style/Theme.Tachiyomi"
+            android:exported="false" />
+
         <activity
             android:name=".ui.webview.WebViewActivity"
-            android:configChanges="uiMode|orientation|screenSize" />
+            android:configChanges="uiMode|orientation|screenSize"
+            android:exported="false" />
+
+        <activity
+            android:name=".extension.util.ExtensionInstallActivity"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar"
+            android:exported="false" />
+
         <activity
             android:name=".ui.setting.track.AnilistLoginActivity"
-            android:label="Anilist">
+            android:label="Anilist"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
 
@@ -105,7 +140,8 @@
         </activity>
         <activity
             android:name=".ui.setting.track.MyAnimeListLoginActivity"
-            android:label="MyAnimeList">
+            android:label="MyAnimeList"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
 
@@ -119,7 +155,8 @@
         </activity>
         <activity
             android:name=".ui.setting.track.ShikimoriLoginActivity"
-            android:label="Shikimori">
+            android:label="Shikimori"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
 
@@ -133,7 +170,8 @@
         </activity>
         <activity
             android:name=".ui.setting.track.BangumiLoginActivity"
-            android:label="Bangumi">
+            android:label="Bangumi"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
 
@@ -146,13 +184,56 @@
             </intent-filter>
         </activity>
 
-        <activity
-            android:name=".extension.util.ExtensionInstallActivity"
-            android:theme="@android:style/Theme.Translucent.NoTitleBar" />
-
         <activity
             android:name="exh.ui.login.EhLoginActivity"
-            android:label="EHentaiLogin" />
+            android:label="EHentaiLogin"
+            android:exported="false"/>
+
+        <receiver
+            android:name=".data.notification.NotificationReceiver"
+            android:exported="false" />
+
+        <receiver
+            android:name="tachiyomi.presentation.widget.UpdatesGridGlanceReceiver"
+            android:enabled="@bool/glance_appwidget_available"
+            android:exported="false"
+            android:label="@string/label_recent_updates">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/updates_grid_glance_widget_info" />
+        </receiver>
+
+        <service
+            android:name=".data.library.LibraryUpdateService"
+            android:exported="false" />
+
+        <service
+            android:name=".data.download.DownloadService"
+            android:exported="false" />
+
+        <service
+            android:name=".data.updater.AppUpdateService"
+            android:exported="false" />
+
+        <service
+            android:name=".data.backup.BackupRestoreService"
+            android:exported="false" />
+
+        <service android:name=".extension.util.ExtensionInstallService"
+            android:exported="false" />
+
+        <service
+            android:name="androidx.appcompat.app.AppLocalesMetadataHolderService"
+            android:enabled="false"
+            android:exported="false">
+            <meta-data
+                android:name="autoStoreLocales"
+                android:value="true" />
+        </service>
 
         <provider
             android:name="androidx.core.content.FileProvider"
@@ -164,213 +245,158 @@
                 android:resource="@xml/provider_paths" />
         </provider>
 
-        <receiver
+        <provider
-            android:name=".data.notification.NotificationReceiver"
+            android:name="rikka.shizuku.ShizukuProvider"
-            android:exported="false" />
+            android:authorities="${applicationId}.shizuku"
+            android:multiprocess="false"
+            android:enabled="true"
+            android:exported="true"
+            android:permission="android.permission.INTERACT_ACROSS_USERS_FULL" />
 
-        <service
+        <meta-data
-            android:name=".data.library.LibraryUpdateService"
+            android:name="android.webkit.WebView.EnableSafeBrowsing"
-            android:exported="false" />
+            android:value="false" />
+        <meta-data
+            android:name="android.webkit.WebView.MetricsOptOut"
+            android:value="true" />
 
-        <service
+        <!-- Disable advertising ID collection for Firebase -->
-            android:name=".data.download.DownloadService"
+        <meta-data
-            android:exported="false" />
+            android:name="google_analytics_adid_collection_enabled"
-
+            android:value="false" />
-        <service
-            android:name=".data.updater.UpdaterService"
-            android:exported="false" />
-
-        <service
-            android:name=".data.backup.BackupCreateService"
-            android:exported="false" />
-
-        <service
-            android:name=".data.backup.BackupRestoreService"
-            android:exported="false" />
 
         <!-- EH -->
-        <service
-            android:name="exh.eh.EHentaiUpdateWorker"
-            android:permission="android.permission.BIND_JOB_SERVICE"
-            android:exported="true" />
         <activity
             android:name="exh.ui.intercept.InterceptActivity"
             android:label="@string/app_name"
-            android:theme="@style/Theme.Base">
+            android:theme="@style/Theme.Tachiyomi"
+            android:exported="true">
+            <!-- E-Hentai -->
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
 
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
 
-                <!-- EH -->
+                <data android:scheme="https" />
-                <data
+                <data android:scheme="http" />
-                    android:host="g.e-hentai.org"
-                    android:pathPrefix="/g/"
-                    android:scheme="http" />
-                <data
-                    android:host="g.e-hentai.org"
-                    android:pathPrefix="/g/"
-                    android:scheme="https" />
-                <data
-                    android:host="e-hentai.org"
-                    android:pathPrefix="/g/"
-                    android:scheme="http" />
-                <data
-                    android:host="e-hentai.org"
-                    android:pathPrefix="/g/"
-                    android:scheme="https" />
 
-                <!-- EXH -->
+                <data android:host="e-hentai.org" />
-                <data
+                <data android:host="www.e-hentai.org" />
-                    android:host="exhentai.org"
+                <data android:host="g.e-hentai.org" />
-                    android:pathPrefix="/g/"
-                    android:scheme="http" />
-                <data
-                    android:host="exhentai.org"
-                    android:pathPrefix="/g/"
-                    android:scheme="https" />
 
-                <!-- nhentai -->
+                <data android:pathPattern="/g/..*" />
-                <data
+            </intent-filter>
-                    android:host="nhentai.net"
+            <!-- ExHentai -->
-                    android:pathPrefix="/g/"
+            <intent-filter>
-                    android:scheme="http" />
+                <action android:name="android.intent.action.VIEW" />
-                <data
-                    android:host="nhentai.net"
-                    android:pathPrefix="/g/"
-                    android:scheme="https" />
 
-                <!-- Perv Eden -->
+                <category android:name="android.intent.category.DEFAULT" />
-                <data
+                <category android:name="android.intent.category.BROWSABLE" />
-                    android:host="www.perveden.com"
-                    android:pathPattern="/.*/.*-manga/.*"
-                    android:scheme="http" />
-                <data
-                    android:host="www.perveden.com"
-                    android:pathPattern="/.*/.*-manga/.*"
-                    android:scheme="https" />
 
-                <!-- Hentai Cafe -->
+                <data android:scheme="https" />
-                <data
+                <data android:scheme="http" />
-                    android:host="hentai.cafe"
-                    android:pathPrefix="/hc.fyi/"
-                    android:scheme="http" />
-                <data
-                    android:host="hentai.cafe"
-                    android:pathPrefix="/hc.fyi/"
-                    android:scheme="https" />
 
-                <!-- Tsumino -->
+                <data android:host="exhentai.org" />
-                <data
+                <data android:host="www.exhentai.org" />
-                    android:host="www.tsumino.com"
-                    android:pathPrefix="/Book/Info/"
-                    android:scheme="http" />
-                <data
-                    android:host="www.tsumino.com"
-                    android:pathPrefix="/Book/Info/"
-                    android:scheme="https" />
-                <data
-                    android:host="www.tsumino.com"
-                    android:pathPrefix="/Read/View/"
-                    android:scheme="http" />
-                <data
-                    android:host="www.tsumino.com"
-                    android:pathPrefix="/Read/View/"
-                    android:scheme="https" />
 
-                 <!-- Hitomi.la -->
+                <data android:pathPattern="/g/..*" />
-                <data
+            </intent-filter>
-                    android:host="hitomi.la"
+            <!-- NHentai -->
-                    android:pathPrefix="/galleries/"
+            <intent-filter>
-                    android:scheme="http" />
+                <action android:name="android.intent.action.VIEW" />
-                <data
-                    android:host="hitomi.la"
-                    android:pathPrefix="/reader/"
-                    android:scheme="http" />
-                <data
-                    android:host="hitomi.la"
-                    android:pathPrefix="/galleries/"
-                    android:scheme="https" />
-                <data
-                    android:host="hitomi.la"
-                    android:pathPrefix="/reader/"
-                    android:scheme="https" />
 
-                <!-- Pururin.io -->
+                <category android:name="android.intent.category.DEFAULT" />
-                <data
+                <category android:name="android.intent.category.BROWSABLE" />
-                    android:host="pururin.io"
-                    android:pathPrefix="/gallery/"
-                    android:scheme="http" />
-                <data
-                    android:host="pururin.io"
-                    android:pathPrefix="/gallery/"
-                    android:scheme="https" />
 
-                <!-- HBrowse -->
+                <data android:scheme="https" />
-                <data
+                <data android:scheme="http" />
-                    android:host="www.hbrowse.com"
-                    android:scheme="http" />
-                <data
-                    android:host="www.hbrowse.com"
-                    android:scheme="https" />
 
-                <!-- MangaDex -->
+                <data android:host="nhentai.net" />
-                <!--<data
+                <data android:host="www.nhentai.net" />
-                    android:scheme="https"
-                    android:host="www.mangadex.org"
-                    android:pathPrefix="/manga/" />
-                <data
-                    android:scheme="https"
-                    android:host="mangadex.org"
-                    android:pathPrefix="/manga/" />
-                <data
-                    android:scheme="https"
-                    android:host="www.mangadex.cc"
-                    android:pathPrefix="/manga/" />
-                <data
-                    android:scheme="https"
-                    android:host="www.mangadex.cc"
-                    android:pathPrefix="/manga/" />
 
-                <data
+                <data android:pathPattern="/g/..*" />
-                    android:scheme="https"
+            </intent-filter>
-                    android:host="www.mangadex.org"
+            <!-- Tsumino -->
-                    android:pathPrefix="/title/" />
+            <intent-filter>
-                <data
+                <action android:name="android.intent.action.VIEW" />
-                    android:scheme="https"
-                    android:host="mangadex.org"
-                    android:pathPrefix="/title/" />
-                <data
-                    android:scheme="https"
-                    android:host="www.mangadex.cc"
-                    android:pathPrefix="/title/" />
-                <data
-                    android:scheme="https"
-                    android:host="www.mangadex.cc"
-                    android:pathPrefix="/title/" />
 
-                <data
+                <category android:name="android.intent.category.DEFAULT" />
-                    android:scheme="https"
+                <category android:name="android.intent.category.BROWSABLE" />
-                    android:host="www.mangadex.org"
+
-                    android:pathPrefix="/chapter/" />
+                <data android:scheme="https" />
-                <data
+                <data android:scheme="http" />
-                    android:scheme="https"
+
-                    android:host="mangadex.org"
+                <data android:host="tsumino.com" />
-                    android:pathPrefix="/chapter/" />
+                <data android:host="www.tsumino.com" />
-                <data
+
-                    android:scheme="https"
+                <data android:pathPattern="/Read/View/..*" />
-                    android:host="www.mangadex.cc"
+                <data android:pathPattern="/Book/Info/..*" />
-                    android:pathPrefix="/chapter/" />
+            </intent-filter>
-                <data
+            <!-- Pururin -->
-                    android:scheme="https"
+            <intent-filter>
-                    android:host="www.mangadex.cc"
+                <action android:name="android.intent.action.VIEW" />
-                    android:pathPrefix="/chapter/" />-->
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:scheme="https" />
+                <data android:scheme="http" />
+
+                <data android:host="pururin.io" />
+
+                <data android:pathPattern="/gallery/..*" />
+            </intent-filter>
+            <!-- HBrowse -->
+            <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="https" />
+                <data android:scheme="http" />
+
+                <data android:host="hbrowse.com" />
+                <data android:host="www.hbrowse.com" />
+
+                <!--<data android:pathPattern="/gallery/..*" />-->
+            </intent-filter>
+            <!-- Mangadex -->
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:scheme="https" />
+
+                <data android:host="mangadex.org" />
+                <data android:host="mangadex.cc" />
+                <data android:host="www.mangadex.org" />
+                <data android:host="www.mangadex.cc" />
+
+                <data android:pathPattern="/manga/..*" />
+                <data android:pathPattern="/title/..*" />
+                <data android:pathPattern="/chapter/..*" />
             </intent-filter>
         </activity>
+
         <activity
-            android:name="exh.ui.captcha.BrowserActionActivity"
+            android:name="exh.md.MangaDexLoginActivity"
-            android:theme="@style/Theme.Base" />
+            android:label="MangaDexLogin"
+            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:host="mangadex-auth"
+                    android:scheme="tachiyomisy" />
+            </intent-filter>
+        </activity>
     </application>
 
 </manifest>

app/src/main/java/eu/kanade/core/prefs/CheckboxState.kt

@@ -0,0 +1,55 @@
+package eu.kanade.core.prefs
+
+import androidx.compose.ui.state.ToggleableState
+
+sealed class CheckboxState<T>(open val value: T) {
+    abstract fun next(): CheckboxState<T>
+
+    sealed class State<T>(override val value: T) : CheckboxState<T>(value) {
+        data class Checked<T>(override val value: T) : State<T>(value)
+        data class None<T>(override val value: T) : State<T>(value)
+
+        val isChecked: Boolean
+            get() = this is Checked
+
+        override fun next(): CheckboxState<T> {
+            return when (this) {
+                is Checked -> None(value)
+                is None -> Checked(value)
+            }
+        }
+    }
+    sealed class TriState<T>(override val value: T) : CheckboxState<T>(value) {
+        data class Include<T>(override val value: T) : TriState<T>(value)
+        data class Exclude<T>(override val value: T) : TriState<T>(value)
+        data class None<T>(override val value: T) : TriState<T>(value)
+
+        override fun next(): CheckboxState<T> {
+            return when (this) {
+                is Exclude -> None(value)
+                is Include -> Exclude(value)
+                is None -> Include(value)
+            }
+        }
+
+        fun asState(): ToggleableState {
+            return when (this) {
+                is Exclude -> ToggleableState.Indeterminate
+                is Include -> ToggleableState.On
+                is None -> ToggleableState.Off
+            }
+        }
+    }
+}
+
+inline fun <T> T.asCheckboxState(condition: (T) -> Boolean): CheckboxState.State<T> {
+    return if (condition(this)) {
+        CheckboxState.State.Checked(this)
+    } else {
+        CheckboxState.State.None(this)
+    }
+}
+
+inline fun <T> List<T>.mapAsCheckboxState(condition: (T) -> Boolean): List<CheckboxState.State<T>> {
+    return this.map { it.asCheckboxState(condition) }
+}

app/src/main/java/eu/kanade/core/prefs/PreferenceMutableState.kt

@@ -0,0 +1,38 @@
+package eu.kanade.core.prefs
+
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import tachiyomi.core.preference.Preference
+
+class PreferenceMutableState<T>(
+    private val preference: Preference<T>,
+    scope: CoroutineScope,
+) : MutableState<T> {
+
+    private val state = mutableStateOf(preference.get())
+
+    init {
+        preference.changes()
+            .onEach { state.value = it }
+            .launchIn(scope)
+    }
+
+    override var value: T
+        get() = state.value
+        set(value) {
+            preference.set(value)
+        }
+
+    override fun component1(): T {
+        return state.value
+    }
+
+    override fun component2(): (T) -> Unit {
+        return { preference.set(it) }
+    }
+}
+
+fun <T> Preference<T>.asState(scope: CoroutineScope) = PreferenceMutableState(this, scope)

app/src/main/java/eu/kanade/core/util/CollectionUtils.kt

@@ -0,0 +1,148 @@
+package eu.kanade.core.util
+
+import androidx.compose.ui.util.fastForEach
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
+
+fun <T : R, R : Any> List<T>.insertSeparators(
+    generator: (T?, T?) -> R?,
+): List<R> {
+    if (isEmpty()) return emptyList()
+    val newList = mutableListOf<R>()
+    for (i in -1..lastIndex) {
+        val before = getOrNull(i)
+        before?.let { newList.add(it) }
+        val after = getOrNull(i + 1)
+        val separator = generator.invoke(before, after)
+        separator?.let { newList.add(it) }
+    }
+    return newList
+}
+
+/**
+ * Returns a new map containing only the key entries of [transform] that are not null.
+ */
+inline fun <K, V, R> Map<out K, V>.mapNotNullKeys(transform: (Map.Entry<K?, V>) -> R?): ConcurrentHashMap<R, V> {
+    val mutableMap = ConcurrentHashMap<R, V>()
+    forEach { element -> transform(element)?.let { mutableMap[it] = element.value } }
+    return mutableMap
+}
+
+fun <E> HashSet<E>.addOrRemove(value: E, shouldAdd: Boolean) {
+    if (shouldAdd) {
+        add(value)
+    } else {
+        remove(value)
+    }
+}
+
+/**
+ * Returns a list containing only elements matching the given [predicate].
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T> List<T>.fastFilter(predicate: (T) -> Boolean): List<T> {
+    contract { callsInPlace(predicate) }
+    val destination = ArrayList<T>()
+    fastForEach { if (predicate(it)) destination.add(it) }
+    return destination
+}
+
+/**
+ * Returns a list containing all elements not matching the given [predicate].
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T> List<T>.fastFilterNot(predicate: (T) -> Boolean): List<T> {
+    contract { callsInPlace(predicate) }
+    val destination = ArrayList<T>()
+    fastForEach { if (!predicate(it)) destination.add(it) }
+    return destination
+}
+
+/**
+ * Returns a list containing only the non-null results of applying the
+ * given [transform] function to each element in the original collection.
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T, R> List<T>.fastMapNotNull(transform: (T) -> R?): List<R> {
+    contract { callsInPlace(transform) }
+    val destination = ArrayList<R>()
+    fastForEach { element ->
+        transform(element)?.let { destination.add(it) }
+    }
+    return destination
+}
+
+/**
+ * Splits the original collection into pair of lists,
+ * where *first* list contains elements for which [predicate] yielded `true`,
+ * while *second* list contains elements for which [predicate] yielded `false`.
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T> List<T>.fastPartition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
+    contract { callsInPlace(predicate) }
+    val first = ArrayList<T>()
+    val second = ArrayList<T>()
+    fastForEach {
+        if (predicate(it)) {
+            first.add(it)
+        } else {
+            second.add(it)
+        }
+    }
+    return Pair(first, second)
+}
+
+/**
+ * Returns the number of entries not matching the given [predicate].
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T> List<T>.fastCountNot(predicate: (T) -> Boolean): Int {
+    contract { callsInPlace(predicate) }
+    var count = size
+    fastForEach { if (predicate(it)) --count }
+    return count
+}
+
+/**
+ * Returns a list containing only elements from the given collection
+ * having distinct keys returned by the given [selector] function.
+ *
+ * Among elements of the given collection with equal keys, only the first one will be present in the resulting list.
+ * The elements in the resulting list are in the same order as they were in the source collection.
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T, K> List<T>.fastDistinctBy(selector: (T) -> K): List<T> {
+    contract { callsInPlace(selector) }
+    val set = HashSet<K>()
+    val list = ArrayList<T>()
+    fastForEach {
+        val key = selector(it)
+        if (set.add(key)) list.add(it)
+    }
+    return list
+}

app/src/main/java/eu/kanade/core/util/DurationUtils.kt

@@ -0,0 +1,16 @@
+package eu.kanade.core.util
+
+import android.content.Context
+import eu.kanade.tachiyomi.R
+import kotlin.time.Duration
+
+fun Duration.toDurationString(context: Context, fallback: String): String {
+    return toComponents { days, hours, minutes, seconds, _ ->
+        buildList(4) {
+            if (days != 0L) add(context.getString(R.string.day_short, days))
+            if (hours != 0) add(context.getString(R.string.hour_short, hours))
+            if (minutes != 0 && (days == 0L || hours == 0)) add(context.getString(R.string.minute_short, minutes))
+            if (seconds != 0 && days == 0L && hours == 0) add(context.getString(R.string.seconds_short, seconds))
+        }.joinToString(" ").ifBlank { fallback }
+    }
+}

app/src/main/java/eu/kanade/core/util/RxJavaExtensions.kt

@@ -0,0 +1,61 @@
+package eu.kanade.core.util
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.launch
+import rx.Emitter
+import rx.Observable
+import rx.Observer
+import kotlin.coroutines.CoroutineContext
+
+fun <T : Any> Observable<T>.asFlow(): Flow<T> = callbackFlow {
+    val observer = object : Observer<T> {
+        override fun onNext(t: T) {
+            trySend(t)
+        }
+
+        override fun onError(e: Throwable) {
+            close(e)
+        }
+
+        override fun onCompleted() {
+            close()
+        }
+    }
+    val subscription = subscribe(observer)
+    awaitClose { subscription.unsubscribe() }
+}
+
+fun <T : Any> Flow<T>.asObservable(
+    context: CoroutineContext = Dispatchers.Unconfined,
+    backpressureMode: Emitter.BackpressureMode = Emitter.BackpressureMode.NONE,
+): Observable<T> {
+    return Observable.create(
+        { emitter ->
+            /*
+             * ATOMIC is used here to provide stable behaviour of subscribe+dispose pair even if
+             * asObservable is already invoked from unconfined
+             */
+            val job = GlobalScope.launch(context = context, start = CoroutineStart.ATOMIC) {
+                try {
+                    collect { emitter.onNext(it) }
+                    emitter.onCompleted()
+                } catch (e: Throwable) {
+                    // Ignore `CancellationException` as error, since it indicates "normal cancellation"
+                    if (e !is CancellationException) {
+                        emitter.onError(e)
+                    } else {
+                        emitter.onCompleted()
+                    }
+                }
+            }
+            emitter.setCancellation { job.cancel() }
+        },
+        backpressureMode,
+    )
+}

app/src/main/java/eu/kanade/data/source/EHentaiPagingSource.kt

@@ -0,0 +1,45 @@
+package eu.kanade.data.source
+
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.MangasPage
+import eu.kanade.tachiyomi.source.model.MetadataMangasPage
+import eu.kanade.tachiyomi.source.model.SManga
+import eu.kanade.tachiyomi.source.online.all.EHentai
+import exh.metadata.metadata.base.RaisedSearchMetadata
+import tachiyomi.core.util.lang.awaitSingle
+
+abstract class EHentaiPagingSource(override val source: EHentai) : SourcePagingSource(source) {
+
+    override fun getPageLoadResult(
+        params: LoadParams<Long>,
+        mangasPage: MangasPage,
+    ): LoadResult.Page<Long, Pair<SManga, RaisedSearchMetadata?>> {
+        mangasPage as MetadataMangasPage
+        val metadata = mangasPage.mangasMetadata
+
+        return LoadResult.Page(
+            data = mangasPage.mangas
+                .mapIndexed { index, sManga -> sManga to metadata.getOrNull(index) },
+            prevKey = null,
+            nextKey = mangasPage.nextKey,
+        )
+    }
+}
+
+class EHentaiSearchPagingSource(source: EHentai, val query: String, val filters: FilterList) : EHentaiPagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchSearchManga(currentPage, query, filters).awaitSingle()
+    }
+}
+
+class EHentaiPopularPagingSource(source: EHentai) : EHentaiPagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchPopularManga(currentPage).awaitSingle()
+    }
+}
+
+class EHentaiLatestPagingSource(source: EHentai) : EHentaiPagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchLatestUpdates(currentPage).awaitSingle()
+    }
+}

app/src/main/java/eu/kanade/data/source/SourceMapper.kt

@@ -0,0 +1,19 @@
+package eu.kanade.data.source
+
+import eu.kanade.tachiyomi.source.CatalogueSource
+import eu.kanade.tachiyomi.source.SourceManager
+import tachiyomi.domain.source.model.Source
+
+val sourceMapper: (eu.kanade.tachiyomi.source.Source) -> Source = { source ->
+    Source(
+        source.id,
+        source.lang,
+        source.name,
+        supportsLatest = false,
+        isStub = source is SourceManager.StubSource,
+    )
+}
+
+val catalogueSourceMapper: (CatalogueSource) -> Source = { source ->
+    sourceMapper(source).copy(supportsLatest = source.supportsLatest)
+}

app/src/main/java/eu/kanade/data/source/SourcePagingSource.kt

@@ -0,0 +1,87 @@
+package eu.kanade.data.source
+
+import androidx.paging.PagingState
+import eu.kanade.domain.source.model.SourcePagingSourceType
+import eu.kanade.tachiyomi.source.CatalogueSource
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.MangasPage
+import eu.kanade.tachiyomi.source.model.MetadataMangasPage
+import eu.kanade.tachiyomi.source.model.SManga
+import exh.metadata.metadata.base.RaisedSearchMetadata
+import tachiyomi.core.util.lang.awaitSingle
+import tachiyomi.core.util.lang.withIOContext
+
+abstract class SourcePagingSource(
+    protected open val source: CatalogueSource,
+) : SourcePagingSourceType() {
+
+    abstract suspend fun requestNextPage(currentPage: Int): MangasPage
+
+    override suspend fun load(params: LoadParams<Long>): LoadResult<Long, /*SY --> */ Pair<SManga, RaisedSearchMetadata?>/*SY <-- */> {
+        val page = params.key ?: 1
+
+        val mangasPage = try {
+            withIOContext {
+                requestNextPage(page.toInt())
+                    .takeIf { it.mangas.isNotEmpty() }
+                    ?: throw NoResultsException()
+            }
+        } catch (e: Exception) {
+            return LoadResult.Error(e)
+        }
+
+        // SY -->
+        return getPageLoadResult(params, mangasPage)
+        // SY <--
+    }
+
+    // SY -->
+    open fun getPageLoadResult(params: LoadParams<Long>, mangasPage: MangasPage): LoadResult.Page<Long, /*SY --> */ Pair<SManga, RaisedSearchMetadata?>/*SY <-- */> {
+        val page = params.key ?: 1
+
+        // SY -->
+        val metadata = if (mangasPage is MetadataMangasPage) {
+            mangasPage.mangasMetadata
+        } else {
+            emptyList()
+        }
+        // SY <--
+
+        return LoadResult.Page(
+            data = mangasPage.mangas
+                // SY -->
+                .mapIndexed { index, sManga -> sManga to metadata.getOrNull(index) },
+            // SY <--
+            prevKey = null,
+            nextKey = if (mangasPage.hasNextPage) page + 1 else null,
+        )
+    }
+    // SY <--
+
+    override fun getRefreshKey(state: PagingState<Long, /*SY --> */ Pair<SManga, RaisedSearchMetadata?>/*SY <-- */>): Long? {
+        return state.anchorPosition?.let { anchorPosition ->
+            val anchorPage = state.closestPageToPosition(anchorPosition)
+            anchorPage?.prevKey ?: anchorPage?.nextKey
+        }
+    }
+}
+
+class SourceSearchPagingSource(source: CatalogueSource, val query: String, val filters: FilterList) : SourcePagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchSearchManga(currentPage, query, filters).awaitSingle()
+    }
+}
+
+class SourcePopularPagingSource(source: CatalogueSource) : SourcePagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchPopularManga(currentPage).awaitSingle()
+    }
+}
+
+class SourceLatestPagingSource(source: CatalogueSource) : SourcePagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchLatestUpdates(currentPage).awaitSingle()
+    }
+}
+
+class NoResultsException : Exception()

app/src/main/java/eu/kanade/data/source/SourceRepositoryImpl.kt

@@ -0,0 +1,91 @@
+package eu.kanade.data.source
+
+import eu.kanade.domain.source.model.SourcePagingSourceType
+import eu.kanade.domain.source.repository.SourceRepository
+import eu.kanade.tachiyomi.source.CatalogueSource
+import eu.kanade.tachiyomi.source.LocalSource
+import eu.kanade.tachiyomi.source.SourceManager
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.online.all.EHentai
+import exh.source.MERGED_SOURCE_ID
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.source.model.Source
+import tachiyomi.domain.source.model.SourceWithCount
+
+class SourceRepositoryImpl(
+    private val sourceManager: SourceManager,
+    private val handler: DatabaseHandler,
+) : SourceRepository {
+
+    override fun getSources(): Flow<List<Source>> {
+        return sourceManager.catalogueSources.map { sources ->
+            sources.map(catalogueSourceMapper)
+        }
+    }
+
+    override fun getOnlineSources(): Flow<List<Source>> {
+        return sourceManager.onlineSources.map { sources ->
+            sources.map(sourceMapper)
+        }
+    }
+
+    override fun getSourcesWithFavoriteCount(): Flow<List<Pair<Source, Long>>> {
+        val sourceIdWithFavoriteCount = handler.subscribeToList { mangasQueries.getSourceIdWithFavoriteCount() }
+        return sourceIdWithFavoriteCount.map { sourceIdsWithCount ->
+            sourceIdsWithCount
+                .filterNot { it.source == LocalSource.ID /* SY --> */ || it.source == MERGED_SOURCE_ID /* SY <-- */ }
+                .map { (sourceId, count) ->
+                    val source = sourceManager.getOrStub(sourceId).run {
+                        sourceMapper(this)
+                    }
+                    source to count
+                }
+        }
+    }
+
+    override fun getSourcesWithNonLibraryManga(): Flow<List<SourceWithCount>> {
+        val sourceIdWithNonLibraryManga = handler.subscribeToList { mangasQueries.getSourceIdsWithNonLibraryManga() }
+        return sourceIdWithNonLibraryManga.map { sourceId ->
+            sourceId.map { (sourceId, count) ->
+                val source = sourceManager.getOrStub(sourceId)
+                SourceWithCount(sourceMapper(source), count)
+            }
+        }
+    }
+
+    override fun search(
+        sourceId: Long,
+        query: String,
+        filterList: FilterList,
+    ): SourcePagingSourceType {
+        val source = sourceManager.get(sourceId) as CatalogueSource
+        // SY -->
+        if (source is EHentai) {
+            return EHentaiSearchPagingSource(source, query, filterList)
+        }
+        // SY <--
+        return SourceSearchPagingSource(source, query, filterList)
+    }
+
+    override fun getPopular(sourceId: Long): SourcePagingSourceType {
+        val source = sourceManager.get(sourceId) as CatalogueSource
+        // SY -->
+        if (source is EHentai) {
+            return EHentaiPopularPagingSource(source)
+        }
+        // SY <--
+        return SourcePopularPagingSource(source)
+    }
+
+    override fun getLatest(sourceId: Long): SourcePagingSourceType {
+        val source = sourceManager.get(sourceId) as CatalogueSource
+        // SY -->
+        if (source is EHentai) {
+            return EHentaiLatestPagingSource(source)
+        }
+        // SY <--
+        return SourceLatestPagingSource(source)
+    }
+}

app/src/main/java/eu/kanade/domain/DomainModule.kt

@@ -0,0 +1,147 @@
+package eu.kanade.domain
+
+import eu.kanade.data.source.SourceRepositoryImpl
+import eu.kanade.domain.category.interactor.CreateCategoryWithName
+import eu.kanade.domain.category.interactor.DeleteCategory
+import eu.kanade.domain.category.interactor.RenameCategory
+import eu.kanade.domain.category.interactor.ReorderCategory
+import eu.kanade.domain.category.interactor.ResetCategoryFlags
+import eu.kanade.domain.category.interactor.SetDisplayModeForCategory
+import eu.kanade.domain.category.interactor.SetMangaCategories
+import eu.kanade.domain.category.interactor.SetSortModeForCategory
+import eu.kanade.domain.category.interactor.UpdateCategory
+import eu.kanade.domain.chapter.interactor.GetChapter
+import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
+import eu.kanade.domain.chapter.interactor.SetMangaDefaultChapterFlags
+import eu.kanade.domain.chapter.interactor.SetReadStatus
+import eu.kanade.domain.chapter.interactor.SyncChaptersWithSource
+import eu.kanade.domain.chapter.interactor.SyncChaptersWithTrackServiceTwoWay
+import eu.kanade.domain.chapter.interactor.UpdateChapter
+import eu.kanade.domain.download.interactor.DeleteDownload
+import eu.kanade.domain.extension.interactor.GetExtensionLanguages
+import eu.kanade.domain.extension.interactor.GetExtensionSources
+import eu.kanade.domain.extension.interactor.GetExtensionsByType
+import eu.kanade.domain.history.interactor.GetNextChapters
+import eu.kanade.domain.manga.interactor.GetDuplicateLibraryManga
+import eu.kanade.domain.manga.interactor.GetFavorites
+import eu.kanade.domain.manga.interactor.GetLibraryManga
+import eu.kanade.domain.manga.interactor.GetManga
+import eu.kanade.domain.manga.interactor.GetMangaWithChapters
+import eu.kanade.domain.manga.interactor.NetworkToLocalManga
+import eu.kanade.domain.manga.interactor.ResetViewerFlags
+import eu.kanade.domain.manga.interactor.SetMangaChapterFlags
+import eu.kanade.domain.manga.interactor.SetMangaViewerFlags
+import eu.kanade.domain.manga.interactor.UpdateManga
+import eu.kanade.domain.source.interactor.GetEnabledSources
+import eu.kanade.domain.source.interactor.GetLanguagesWithSources
+import eu.kanade.domain.source.interactor.GetRemoteManga
+import eu.kanade.domain.source.interactor.GetSourcesWithFavoriteCount
+import eu.kanade.domain.source.interactor.GetSourcesWithNonLibraryManga
+import eu.kanade.domain.source.interactor.SetMigrateSorting
+import eu.kanade.domain.source.interactor.ToggleLanguage
+import eu.kanade.domain.source.interactor.ToggleSource
+import eu.kanade.domain.source.interactor.ToggleSourcePin
+import eu.kanade.domain.source.repository.SourceRepository
+import eu.kanade.domain.track.interactor.DeleteTrack
+import eu.kanade.domain.track.interactor.GetTracks
+import eu.kanade.domain.track.interactor.GetTracksPerManga
+import eu.kanade.domain.track.interactor.InsertTrack
+import tachiyomi.data.category.CategoryRepositoryImpl
+import tachiyomi.data.chapter.ChapterRepositoryImpl
+import tachiyomi.data.history.HistoryRepositoryImpl
+import tachiyomi.data.manga.MangaRepositoryImpl
+import tachiyomi.data.source.SourceDataRepositoryImpl
+import tachiyomi.data.track.TrackRepositoryImpl
+import tachiyomi.data.updates.UpdatesRepositoryImpl
+import tachiyomi.domain.category.interactor.GetCategories
+import tachiyomi.domain.category.repository.CategoryRepository
+import tachiyomi.domain.chapter.interactor.ShouldUpdateDbChapter
+import tachiyomi.domain.chapter.repository.ChapterRepository
+import tachiyomi.domain.history.interactor.GetHistory
+import tachiyomi.domain.history.interactor.GetTotalReadDuration
+import tachiyomi.domain.history.interactor.RemoveHistory
+import tachiyomi.domain.history.interactor.UpsertHistory
+import tachiyomi.domain.history.repository.HistoryRepository
+import tachiyomi.domain.manga.repository.MangaRepository
+import tachiyomi.domain.source.repository.SourceDataRepository
+import tachiyomi.domain.track.repository.TrackRepository
+import tachiyomi.domain.updates.interactor.GetUpdates
+import tachiyomi.domain.updates.repository.UpdatesRepository
+import uy.kohesive.injekt.api.InjektModule
+import uy.kohesive.injekt.api.InjektRegistrar
+import uy.kohesive.injekt.api.addFactory
+import uy.kohesive.injekt.api.addSingletonFactory
+import uy.kohesive.injekt.api.get
+
+class DomainModule : InjektModule {
+
+    override fun InjektRegistrar.registerInjectables() {
+        addSingletonFactory<CategoryRepository> { CategoryRepositoryImpl(get()) }
+        addFactory { GetCategories(get()) }
+        addFactory { ResetCategoryFlags(get(), get()) }
+        addFactory { SetDisplayModeForCategory(get(), get()) }
+        addFactory { SetSortModeForCategory(get(), get()) }
+        addFactory { CreateCategoryWithName(get(), get()) }
+        addFactory { RenameCategory(get()) }
+        addFactory { ReorderCategory(get()) }
+        addFactory { UpdateCategory(get()) }
+        addFactory { DeleteCategory(get()) }
+
+        addSingletonFactory<MangaRepository> { MangaRepositoryImpl(get()) }
+        addFactory { GetDuplicateLibraryManga(get()) }
+        addFactory { GetFavorites(get()) }
+        addFactory { GetLibraryManga(get()) }
+        addFactory { GetMangaWithChapters(get(), get()) }
+        addFactory { GetManga(get()) }
+        addFactory { GetNextChapters(get(), get(), get(), get()) }
+        addFactory { ResetViewerFlags(get()) }
+        addFactory { SetMangaChapterFlags(get()) }
+        addFactory { SetMangaDefaultChapterFlags(get(), get(), get()) }
+        addFactory { SetMangaViewerFlags(get()) }
+        addFactory { NetworkToLocalManga(get()) }
+        addFactory { UpdateManga(get()) }
+        addFactory { SetMangaCategories(get()) }
+
+        addSingletonFactory<TrackRepository> { TrackRepositoryImpl(get()) }
+        addFactory { DeleteTrack(get()) }
+        addFactory { GetTracksPerManga(get()) }
+        addFactory { GetTracks(get()) }
+        addFactory { InsertTrack(get()) }
+
+        addSingletonFactory<ChapterRepository> { ChapterRepositoryImpl(get()) }
+        addFactory { GetChapter(get()) }
+        addFactory { GetChapterByMangaId(get()) }
+        addFactory { UpdateChapter(get()) }
+        addFactory { SetReadStatus(get(), get(), get(), get(), get()) }
+        addFactory { ShouldUpdateDbChapter() }
+        addFactory { SyncChaptersWithSource(get(), get(), get(), get()) }
+        addFactory { SyncChaptersWithTrackServiceTwoWay(get(), get()) }
+
+        addSingletonFactory<HistoryRepository> { HistoryRepositoryImpl(get()) }
+        addFactory { GetHistory(get()) }
+        addFactory { UpsertHistory(get()) }
+        addFactory { RemoveHistory(get()) }
+        addFactory { GetTotalReadDuration(get()) }
+
+        addFactory { DeleteDownload(get(), get()) }
+
+        addFactory { GetExtensionsByType(get(), get()) }
+        addFactory { GetExtensionSources(get()) }
+        addFactory { GetExtensionLanguages(get(), get()) }
+
+        addSingletonFactory<UpdatesRepository> { UpdatesRepositoryImpl(get()) }
+        addFactory { GetUpdates(get()) }
+
+        addSingletonFactory<SourceRepository> { SourceRepositoryImpl(get(), get()) }
+        addSingletonFactory<SourceDataRepository> { SourceDataRepositoryImpl(get()) }
+        addFactory { GetEnabledSources(get(), get()) }
+        addFactory { GetLanguagesWithSources(get(), get()) }
+        addFactory { GetRemoteManga(get()) }
+        addFactory { GetSourcesWithFavoriteCount(get(), get()) }
+        addFactory { GetSourcesWithNonLibraryManga(get()) }
+        addFactory { SetMigrateSorting(get()) }
+        addFactory { ToggleLanguage(get()) }
+        addFactory { ToggleSource(get()) }
+        addFactory { ToggleSourcePin(get()) }
+    }
+}

app/src/main/java/eu/kanade/domain/SYDomainModule.kt

@@ -0,0 +1,161 @@
+package eu.kanade.domain
+
+import android.app.Application
+import eu.kanade.domain.chapter.interactor.DeleteChapters
+import eu.kanade.domain.chapter.interactor.GetChapterByUrl
+import eu.kanade.domain.chapter.interactor.GetMergedChapterByMangaId
+import eu.kanade.domain.history.interactor.GetHistoryByMangaId
+import eu.kanade.domain.manga.interactor.CreateSortTag
+import eu.kanade.domain.manga.interactor.DeleteByMergeId
+import eu.kanade.domain.manga.interactor.DeleteFavoriteEntries
+import eu.kanade.domain.manga.interactor.DeleteMangaById
+import eu.kanade.domain.manga.interactor.DeleteMergeById
+import eu.kanade.domain.manga.interactor.DeleteSortTag
+import eu.kanade.domain.manga.interactor.GetAllManga
+import eu.kanade.domain.manga.interactor.GetExhFavoriteMangaWithMetadata
+import eu.kanade.domain.manga.interactor.GetFavoriteEntries
+import eu.kanade.domain.manga.interactor.GetFlatMetadataById
+import eu.kanade.domain.manga.interactor.GetIdsOfFavoriteMangaWithMetadata
+import eu.kanade.domain.manga.interactor.GetManga
+import eu.kanade.domain.manga.interactor.GetMangaBySource
+import eu.kanade.domain.manga.interactor.GetMergedManga
+import eu.kanade.domain.manga.interactor.GetMergedMangaById
+import eu.kanade.domain.manga.interactor.GetMergedMangaForDownloading
+import eu.kanade.domain.manga.interactor.GetMergedReferencesById
+import eu.kanade.domain.manga.interactor.GetPagePreviews
+import eu.kanade.domain.manga.interactor.GetSearchMetadata
+import eu.kanade.domain.manga.interactor.GetSearchTags
+import eu.kanade.domain.manga.interactor.GetSearchTitles
+import eu.kanade.domain.manga.interactor.GetSortTag
+import eu.kanade.domain.manga.interactor.InsertFavoriteEntries
+import eu.kanade.domain.manga.interactor.InsertFlatMetadata
+import eu.kanade.domain.manga.interactor.InsertMergedReference
+import eu.kanade.domain.manga.interactor.ReorderSortTag
+import eu.kanade.domain.manga.interactor.SetMangaFilteredScanlators
+import eu.kanade.domain.manga.interactor.UpdateMergedSettings
+import eu.kanade.domain.source.interactor.CountFeedSavedSearchBySourceId
+import eu.kanade.domain.source.interactor.CountFeedSavedSearchGlobal
+import eu.kanade.domain.source.interactor.CreateSourceCategory
+import eu.kanade.domain.source.interactor.CreateSourceRepo
+import eu.kanade.domain.source.interactor.DeleteFeedSavedSearchById
+import eu.kanade.domain.source.interactor.DeleteSavedSearchById
+import eu.kanade.domain.source.interactor.DeleteSourceCategory
+import eu.kanade.domain.source.interactor.DeleteSourceRepos
+import eu.kanade.domain.source.interactor.GetExhSavedSearch
+import eu.kanade.domain.source.interactor.GetFeedSavedSearchBySourceId
+import eu.kanade.domain.source.interactor.GetFeedSavedSearchGlobal
+import eu.kanade.domain.source.interactor.GetSavedSearchById
+import eu.kanade.domain.source.interactor.GetSavedSearchBySourceId
+import eu.kanade.domain.source.interactor.GetSavedSearchBySourceIdFeed
+import eu.kanade.domain.source.interactor.GetSavedSearchGlobalFeed
+import eu.kanade.domain.source.interactor.GetShowLatest
+import eu.kanade.domain.source.interactor.GetSourceCategories
+import eu.kanade.domain.source.interactor.GetSourceRepos
+import eu.kanade.domain.source.interactor.InsertFeedSavedSearch
+import eu.kanade.domain.source.interactor.InsertSavedSearch
+import eu.kanade.domain.source.interactor.RenameSourceCategory
+import eu.kanade.domain.source.interactor.SetSourceCategories
+import eu.kanade.domain.source.interactor.ToggleExcludeFromDataSaver
+import eu.kanade.tachiyomi.source.online.MetadataSource
+import exh.search.SearchEngine
+import tachiyomi.data.manga.CustomMangaRepositoryImpl
+import tachiyomi.data.manga.FavoritesEntryRepositoryImpl
+import tachiyomi.data.manga.MangaMergeRepositoryImpl
+import tachiyomi.data.manga.MangaMetadataRepositoryImpl
+import tachiyomi.data.source.FeedSavedSearchRepositoryImpl
+import tachiyomi.data.source.SavedSearchRepositoryImpl
+import tachiyomi.domain.manga.interactor.GetCustomMangaInfo
+import tachiyomi.domain.manga.interactor.SetCustomMangaInfo
+import tachiyomi.domain.manga.repository.CustomMangaRepository
+import tachiyomi.domain.manga.repository.FavoritesEntryRepository
+import tachiyomi.domain.manga.repository.MangaMergeRepository
+import tachiyomi.domain.manga.repository.MangaMetadataRepository
+import tachiyomi.domain.source.repository.FeedSavedSearchRepository
+import tachiyomi.domain.source.repository.SavedSearchRepository
+import uy.kohesive.injekt.api.InjektModule
+import uy.kohesive.injekt.api.InjektRegistrar
+import uy.kohesive.injekt.api.addFactory
+import uy.kohesive.injekt.api.addSingletonFactory
+import uy.kohesive.injekt.api.get
+import xyz.nulldev.ts.api.http.serializer.FilterSerializer
+
+class SYDomainModule : InjektModule {
+
+    override fun InjektRegistrar.registerInjectables() {
+        addFactory { GetShowLatest(get()) }
+        addFactory { ToggleExcludeFromDataSaver(get()) }
+        addFactory { SetSourceCategories(get()) }
+        addFactory { SetMangaFilteredScanlators(get()) }
+        addFactory { GetAllManga(get()) }
+        addFactory { GetMangaBySource(get()) }
+        addFactory { DeleteChapters(get()) }
+        addFactory { DeleteMangaById(get()) }
+        addFactory { FilterSerializer() }
+        addFactory { GetHistoryByMangaId(get()) }
+        addFactory { GetChapterByUrl(get()) }
+        addFactory { CreateSourceRepo(get()) }
+        addFactory { DeleteSourceRepos(get()) }
+        addFactory { GetSourceRepos(get()) }
+        addFactory { GetSourceCategories(get()) }
+        addFactory { CreateSourceCategory(get()) }
+        addFactory { RenameSourceCategory(get(), get()) }
+        addFactory { DeleteSourceCategory(get()) }
+        addFactory { GetSortTag(get()) }
+        addFactory { CreateSortTag(get(), get()) }
+        addFactory { DeleteSortTag(get(), get()) }
+        addFactory { ReorderSortTag(get(), get()) }
+        addFactory { GetPagePreviews(get(), get()) }
+        addFactory { SearchEngine() }
+
+        // Required for [MetadataSource]
+        addFactory<MetadataSource.GetMangaId> { GetManga(get()) }
+        addFactory<MetadataSource.GetFlatMetadataById> { GetFlatMetadataById(get()) }
+        addFactory<MetadataSource.InsertFlatMetadata> { InsertFlatMetadata(get()) }
+
+        addSingletonFactory<MangaMetadataRepository> { MangaMetadataRepositoryImpl(get()) }
+        addFactory { GetFlatMetadataById(get()) }
+        addFactory { InsertFlatMetadata(get()) }
+        addFactory { GetExhFavoriteMangaWithMetadata(get()) }
+        addFactory { GetSearchMetadata(get()) }
+        addFactory { GetSearchTags(get()) }
+        addFactory { GetSearchTitles(get()) }
+        addFactory { GetIdsOfFavoriteMangaWithMetadata(get()) }
+
+        addSingletonFactory<MangaMergeRepository> { MangaMergeRepositoryImpl(get()) }
+        addFactory { GetMergedManga(get()) }
+        addFactory { GetMergedMangaById(get()) }
+        addFactory { GetMergedReferencesById(get()) }
+        addFactory { GetMergedChapterByMangaId(get(), get()) }
+        addFactory { InsertMergedReference(get()) }
+        addFactory { UpdateMergedSettings(get()) }
+        addFactory { DeleteByMergeId(get()) }
+        addFactory { DeleteMergeById(get()) }
+        addFactory { GetMergedMangaForDownloading(get()) }
+
+        addSingletonFactory<FavoritesEntryRepository> { FavoritesEntryRepositoryImpl(get()) }
+        addFactory { GetFavoriteEntries(get()) }
+        addFactory { InsertFavoriteEntries(get()) }
+        addFactory { DeleteFavoriteEntries(get()) }
+
+        addSingletonFactory<SavedSearchRepository> { SavedSearchRepositoryImpl(get()) }
+        addFactory { GetSavedSearchById(get()) }
+        addFactory { GetSavedSearchBySourceId(get()) }
+        addFactory { DeleteSavedSearchById(get()) }
+        addFactory { InsertSavedSearch(get()) }
+        addFactory { GetExhSavedSearch(get(), get(), get()) }
+
+        addSingletonFactory<FeedSavedSearchRepository> { FeedSavedSearchRepositoryImpl(get()) }
+        addFactory { InsertFeedSavedSearch(get()) }
+        addFactory { DeleteFeedSavedSearchById(get()) }
+        addFactory { GetFeedSavedSearchGlobal(get()) }
+        addFactory { GetFeedSavedSearchBySourceId(get()) }
+        addFactory { CountFeedSavedSearchGlobal(get()) }
+        addFactory { CountFeedSavedSearchBySourceId(get()) }
+        addFactory { GetSavedSearchGlobalFeed(get()) }
+        addFactory { GetSavedSearchBySourceIdFeed(get()) }
+
+        addSingletonFactory<CustomMangaRepository> { CustomMangaRepositoryImpl(get<Application>()) }
+        addFactory { GetCustomMangaInfo(get()) }
+        addFactory { SetCustomMangaInfo(get()) }
+    }
+}

app/src/main/java/eu/kanade/domain/UnsortedPreferences.kt

@@ -0,0 +1,89 @@
+package eu.kanade.domain
+
+import tachiyomi.core.preference.PreferenceStore
+
+class UnsortedPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+
+    // SY -->
+
+    fun migrateFlags() = preferenceStore.getInt("migrate_flags", Int.MAX_VALUE)
+
+    fun defaultMangaOrder() = preferenceStore.getString("default_manga_order", "")
+
+    fun migrationSources() = preferenceStore.getString("migrate_sources", "")
+
+    fun smartMigration() = preferenceStore.getBoolean("smart_migrate", false)
+
+    fun useSourceWithMost() = preferenceStore.getBoolean("use_source_with_most", false)
+
+    fun skipPreMigration() = preferenceStore.getBoolean("skip_pre_migration", false)
+
+    fun hideNotFoundMigration() = preferenceStore.getBoolean("hide_not_found_migration", false)
+
+    fun isHentaiEnabled() = preferenceStore.getBoolean("eh_is_hentai_enabled", true)
+
+    fun enableExhentai() = preferenceStore.getBoolean("enable_exhentai", false)
+
+    fun imageQuality() = preferenceStore.getString("ehentai_quality", "auto")
+
+    fun useHentaiAtHome() = preferenceStore.getInt("eh_enable_hah", 0)
+
+    fun useJapaneseTitle() = preferenceStore.getBoolean("use_jp_title", false)
+
+    fun exhUseOriginalImages() = preferenceStore.getBoolean("eh_useOrigImages", false)
+
+    fun ehTagFilterValue() = preferenceStore.getInt("eh_tag_filtering_value", 0)
+
+    fun ehTagWatchingValue() = preferenceStore.getInt("eh_tag_watching_value", 0)
+
+    // EH Cookies
+    fun memberIdVal() = preferenceStore.getString("eh_ipb_member_id", "")
+
+    fun passHashVal() = preferenceStore.getString("eh_ipb_pass_hash", "")
+    fun igneousVal() = preferenceStore.getString("eh_igneous", "")
+    fun ehSettingsProfile() = preferenceStore.getInt("eh_ehSettingsProfile", -1)
+    fun exhSettingsProfile() = preferenceStore.getInt("eh_exhSettingsProfile", -1)
+    fun exhSettingsKey() = preferenceStore.getString("eh_settingsKey", "")
+    fun exhSessionCookie() = preferenceStore.getString("eh_sessionCookie", "")
+    fun exhHathPerksCookies() = preferenceStore.getString("eh_hathPerksCookie", "")
+
+    fun exhShowSyncIntro() = preferenceStore.getBoolean("eh_show_sync_intro", true)
+
+    fun exhReadOnlySync() = preferenceStore.getBoolean("eh_sync_read_only", false)
+
+    fun exhLenientSync() = preferenceStore.getBoolean("eh_lenient_sync", false)
+
+    fun exhShowSettingsUploadWarning() = preferenceStore.getBoolean("eh_showSettingsUploadWarning2", true)
+
+    fun logLevel() = preferenceStore.getInt("eh_log_level", 0)
+
+    fun exhAutoUpdateFrequency() = preferenceStore.getInt("eh_auto_update_frequency", 1)
+
+    fun exhAutoUpdateRequirements() = preferenceStore.getStringSet("eh_auto_update_restrictions", emptySet())
+
+    fun exhAutoUpdateStats() = preferenceStore.getString("eh_auto_update_stats", "")
+
+    fun exhWatchedListDefaultState() = preferenceStore.getBoolean("eh_watched_list_default_state", false)
+
+    fun exhSettingsLanguages() = preferenceStore.getString(
+        "eh_settings_languages",
+        "false*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false",
+    )
+
+    fun exhEnabledCategories() = preferenceStore.getString(
+        "eh_enabled_categories",
+        "false,false,false,false,false,false,false,false,false,false",
+    )
+
+    fun enhancedEHentaiView() = preferenceStore.getBoolean("enhanced_e_hentai_view", true)
+
+    fun preferredMangaDexId() = preferenceStore.getString("preferred_mangaDex_id", "0")
+
+    fun mangadexSyncToLibraryIndexes() = preferenceStore.getStringSet("pref_mangadex_sync_to_library_indexes", emptySet())
+
+    fun allowLocalSourceHiddenFolders() = preferenceStore.getBoolean("allow_local_source_hidden_folders", false)
+
+    fun extensionRepos() = preferenceStore.getStringSet("extension_repos", emptySet())
+}

app/src/main/java/eu/kanade/domain/backup/service/BackupPreferences.kt

@@ -0,0 +1,16 @@
+package eu.kanade.domain.backup.service
+
+import tachiyomi.core.preference.PreferenceStore
+import tachiyomi.core.provider.FolderProvider
+
+class BackupPreferences(
+    private val folderProvider: FolderProvider,
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun backupsDirectory() = preferenceStore.getString("backup_directory", folderProvider.path())
+
+    fun numberOfBackups() = preferenceStore.getInt("backup_slots", 2)
+
+    fun backupInterval() = preferenceStore.getInt("backup_interval", 12)
+}

app/src/main/java/eu/kanade/domain/base/BasePreferences.kt

@@ -0,0 +1,24 @@
+package eu.kanade.domain.base
+
+import android.content.Context
+import eu.kanade.tachiyomi.util.system.isPreviewBuildType
+import eu.kanade.tachiyomi.util.system.isReleaseBuildType
+import tachiyomi.core.preference.PreferenceStore
+
+class BasePreferences(
+    val context: Context,
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun confirmExit() = preferenceStore.getBoolean("pref_confirm_exit", false)
+
+    fun downloadedOnly() = preferenceStore.getBoolean("pref_downloaded_only", false)
+
+    fun incognitoMode() = preferenceStore.getBoolean("incognito_mode", false)
+
+    fun automaticExtUpdates() = preferenceStore.getBoolean("automatic_ext_updates", true)
+
+    fun extensionInstaller() = ExtensionInstallerPreference(context, preferenceStore)
+
+    fun acraEnabled() = preferenceStore.getBoolean("acra.enable", isPreviewBuildType || isReleaseBuildType)
+}

app/src/main/java/eu/kanade/domain/base/ExtensionInstallerPreference.kt

@@ -0,0 +1,68 @@
+package eu.kanade.domain.base
+
+import android.content.Context
+import eu.kanade.tachiyomi.data.preference.PreferenceValues.ExtensionInstaller
+import eu.kanade.tachiyomi.util.system.hasMiuiPackageInstaller
+import eu.kanade.tachiyomi.util.system.isShizukuInstalled
+import kotlinx.coroutines.CoroutineScope
+import tachiyomi.core.preference.Preference
+import tachiyomi.core.preference.PreferenceStore
+import tachiyomi.core.preference.getEnum
+
+class ExtensionInstallerPreference(
+    private val context: Context,
+    preferenceStore: PreferenceStore,
+) : Preference<ExtensionInstaller> {
+
+    private val basePref = preferenceStore.getEnum(key(), defaultValue())
+
+    override fun key() = "extension_installer"
+
+    val entries get() = ExtensionInstaller.values().run {
+        if (context.hasMiuiPackageInstaller) {
+            filter { it != ExtensionInstaller.PACKAGEINSTALLER }
+        } else {
+            toList()
+        }
+    }
+
+    override fun defaultValue() = if (context.hasMiuiPackageInstaller) {
+        ExtensionInstaller.LEGACY
+    } else {
+        ExtensionInstaller.PACKAGEINSTALLER
+    }
+
+    private fun check(value: ExtensionInstaller): ExtensionInstaller {
+        when (value) {
+            ExtensionInstaller.PACKAGEINSTALLER -> {
+                if (context.hasMiuiPackageInstaller) return ExtensionInstaller.LEGACY
+            }
+            ExtensionInstaller.SHIZUKU -> {
+                if (!context.isShizukuInstalled) return defaultValue()
+            }
+            else -> {}
+        }
+        return value
+    }
+
+    override fun get(): ExtensionInstaller {
+        val value = basePref.get()
+        val checkedValue = check(value)
+        if (value != checkedValue) {
+            basePref.set(checkedValue)
+        }
+        return checkedValue
+    }
+
+    override fun set(value: ExtensionInstaller) {
+        basePref.set(check(value))
+    }
+
+    override fun isSet() = basePref.isSet()
+
+    override fun delete() = basePref.delete()
+
+    override fun changes() = basePref.changes()
+
+    override fun stateIn(scope: CoroutineScope) = basePref.stateIn(scope)
+}

app/src/main/java/eu/kanade/domain/category/interactor/CreateCategoryWithName.kt

@@ -0,0 +1,49 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.library.service.LibraryPreferences
+import logcat.LogPriority
+import tachiyomi.core.util.lang.withNonCancellableContext
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.category.model.Category
+import tachiyomi.domain.category.repository.CategoryRepository
+
+class CreateCategoryWithName(
+    private val categoryRepository: CategoryRepository,
+    private val preferences: LibraryPreferences,
+) {
+
+    private val initialFlags: Long
+        get() {
+            val sort = preferences.librarySortingMode().get()
+            return preferences.libraryDisplayMode().get().flag or
+                sort.type.flag or
+                sort.direction.flag
+        }
+
+    suspend fun await(name: String): Result = withNonCancellableContext {
+        val categories = categoryRepository.getAll()
+        val nextOrder = categories.maxOfOrNull { it.order }?.plus(1) ?: 0
+        val newCategory = Category(
+            id = 0,
+            name = name,
+            order = nextOrder,
+            flags = initialFlags,
+        )
+
+        try {
+            categoryRepository.insert(newCategory)
+            Result.Success(/* SY --> */newCategory/* SY <-- */)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            Result.InternalError(e)
+        }
+    }
+
+    sealed class Result {
+        // SY -->
+        data class Success(val category: Category) : Result()
+
+        // SY <--
+        data class InternalError(val error: Throwable) : Result()
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/DeleteCategory.kt

@@ -0,0 +1,42 @@
+package eu.kanade.domain.category.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.util.lang.withNonCancellableContext
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.category.model.CategoryUpdate
+import tachiyomi.domain.category.repository.CategoryRepository
+
+class DeleteCategory(
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await(categoryId: Long) = withNonCancellableContext {
+        try {
+            categoryRepository.delete(categoryId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            return@withNonCancellableContext Result.InternalError(e)
+        }
+
+        val categories = categoryRepository.getAll()
+        val updates = categories.mapIndexed { index, category ->
+            CategoryUpdate(
+                id = category.id,
+                order = index.toLong(),
+            )
+        }
+
+        try {
+            categoryRepository.updatePartial(updates)
+            Result.Success
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            Result.InternalError(e)
+        }
+    }
+
+    sealed class Result {
+        object Success : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/RenameCategory.kt

@@ -0,0 +1,35 @@
+package eu.kanade.domain.category.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.util.lang.withNonCancellableContext
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.category.model.Category
+import tachiyomi.domain.category.model.CategoryUpdate
+import tachiyomi.domain.category.repository.CategoryRepository
+
+class RenameCategory(
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await(categoryId: Long, name: String) = withNonCancellableContext {
+        val update = CategoryUpdate(
+            id = categoryId,
+            name = name,
+        )
+
+        try {
+            categoryRepository.updatePartial(update)
+            Result.Success
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            Result.InternalError(e)
+        }
+    }
+
+    suspend fun await(category: Category, name: String) = await(category.id, name)
+
+    sealed class Result {
+        object Success : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/ReorderCategory.kt

@@ -0,0 +1,70 @@
+package eu.kanade.domain.category.interactor
+
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import logcat.LogPriority
+import tachiyomi.core.util.lang.withNonCancellableContext
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.category.model.Category
+import tachiyomi.domain.category.model.CategoryUpdate
+import tachiyomi.domain.category.repository.CategoryRepository
+import java.util.Collections
+
+class ReorderCategory(
+    private val categoryRepository: CategoryRepository,
+) {
+
+    private val mutex = Mutex()
+
+    suspend fun moveUp(category: Category): Result =
+        await(category, MoveTo.UP)
+
+    suspend fun moveDown(category: Category): Result =
+        await(category, MoveTo.DOWN)
+
+    private suspend fun await(category: Category, moveTo: MoveTo) = withNonCancellableContext {
+        mutex.withLock {
+            val categories = categoryRepository.getAll()
+                .filterNot(Category::isSystemCategory)
+                .toMutableList()
+
+            val currentIndex = categories.indexOfFirst { it.id == category.id }
+            if (currentIndex == -1) {
+                return@withNonCancellableContext Result.Unchanged
+            }
+
+            val newPosition = when (moveTo) {
+                MoveTo.UP -> currentIndex - 1
+                MoveTo.DOWN -> currentIndex + 1
+            }.toInt()
+
+            try {
+                Collections.swap(categories, currentIndex, newPosition)
+
+                val updates = categories.mapIndexed { index, category ->
+                    CategoryUpdate(
+                        id = category.id,
+                        order = index.toLong(),
+                    )
+                }
+
+                categoryRepository.updatePartial(updates)
+                Result.Success
+            } catch (e: Exception) {
+                logcat(LogPriority.ERROR, e)
+                Result.InternalError(e)
+            }
+        }
+    }
+
+    sealed class Result {
+        object Success : Result()
+        object Unchanged : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+
+    private enum class MoveTo {
+        UP,
+        DOWN,
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/ResetCategoryFlags.kt

@@ -0,0 +1,17 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.library.service.LibraryPreferences
+import tachiyomi.domain.category.repository.CategoryRepository
+import tachiyomi.domain.library.model.plus
+
+class ResetCategoryFlags(
+    private val preferences: LibraryPreferences,
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await() {
+        val display = preferences.libraryDisplayMode().get()
+        val sort = preferences.librarySortingMode().get()
+        categoryRepository.updateAllFlags(display + sort.type + sort.direction)
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/SetDisplayModeForCategory.kt

@@ -0,0 +1,41 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.library.model.LibraryGroup
+import eu.kanade.domain.library.service.LibraryPreferences
+import tachiyomi.domain.category.model.Category
+import tachiyomi.domain.category.model.CategoryUpdate
+import tachiyomi.domain.category.repository.CategoryRepository
+import tachiyomi.domain.library.model.LibraryDisplayMode
+import tachiyomi.domain.library.model.plus
+
+class SetDisplayModeForCategory(
+    private val preferences: LibraryPreferences,
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await(categoryId: Long, display: LibraryDisplayMode) {
+        // SY -->
+        if (preferences.groupLibraryBy().get() != LibraryGroup.BY_DEFAULT) {
+            preferences.libraryDisplayMode().set(display)
+            return
+        }
+        // SY <--
+        val category = categoryRepository.get(categoryId) ?: return
+        val flags = category.flags + display
+        if (preferences.categorizedDisplaySettings().get()) {
+            categoryRepository.updatePartial(
+                CategoryUpdate(
+                    id = category.id,
+                    flags = flags,
+                ),
+            )
+        } else {
+            preferences.libraryDisplayMode().set(display)
+            categoryRepository.updateAllFlags(flags)
+        }
+    }
+
+    suspend fun await(category: Category, display: LibraryDisplayMode) {
+        await(category.id, display)
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/SetMangaCategories.kt

@@ -0,0 +1,18 @@
+package eu.kanade.domain.category.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class SetMangaCategories(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(mangaId: Long, categoryIds: List<Long>) {
+        try {
+            mangaRepository.setMangaCategories(mangaId, categoryIds)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/SetSortModeForCategory.kt

@@ -0,0 +1,41 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.library.model.LibraryGroup
+import eu.kanade.domain.library.service.LibraryPreferences
+import tachiyomi.domain.category.model.Category
+import tachiyomi.domain.category.model.CategoryUpdate
+import tachiyomi.domain.category.repository.CategoryRepository
+import tachiyomi.domain.library.model.LibrarySort
+import tachiyomi.domain.library.model.plus
+
+class SetSortModeForCategory(
+    private val preferences: LibraryPreferences,
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await(categoryId: Long, type: LibrarySort.Type, direction: LibrarySort.Direction) {
+        // SY -->
+        if (preferences.groupLibraryBy().get() != LibraryGroup.BY_DEFAULT) {
+            preferences.librarySortingMode().set(LibrarySort(type, direction))
+            return
+        }
+        // SY <--
+        val category = categoryRepository.get(categoryId) ?: return
+        val flags = category.flags + type + direction
+        if (preferences.categorizedDisplaySettings().get()) {
+            categoryRepository.updatePartial(
+                CategoryUpdate(
+                    id = category.id,
+                    flags = flags,
+                ),
+            )
+        } else {
+            preferences.librarySortingMode().set(LibrarySort(type, direction))
+            categoryRepository.updateAllFlags(flags)
+        }
+    }
+
+    suspend fun await(category: Category, type: LibrarySort.Type, direction: LibrarySort.Direction) {
+        await(category.id, type, direction)
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/UpdateCategory.kt

@@ -0,0 +1,24 @@
+package eu.kanade.domain.category.interactor
+
+import tachiyomi.core.util.lang.withNonCancellableContext
+import tachiyomi.domain.category.model.CategoryUpdate
+import tachiyomi.domain.category.repository.CategoryRepository
+
+class UpdateCategory(
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await(payload: CategoryUpdate): Result = withNonCancellableContext {
+        try {
+            categoryRepository.updatePartial(payload)
+            Result.Success
+        } catch (e: Exception) {
+            Result.Error(e)
+        }
+    }
+
+    sealed class Result {
+        object Success : Result()
+        data class Error(val error: Exception) : Result()
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/DeleteChapters.kt

@@ -0,0 +1,12 @@
+package eu.kanade.domain.chapter.interactor
+
+import tachiyomi.domain.chapter.repository.ChapterRepository
+
+class DeleteChapters(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(chapters: List<Long>) {
+        chapterRepository.removeChaptersWithIds(chapters)
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/GetChapter.kt

@@ -0,0 +1,29 @@
+package eu.kanade.domain.chapter.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.chapter.repository.ChapterRepository
+
+class GetChapter(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(id: Long): Chapter? {
+        return try {
+            chapterRepository.getChapterById(id)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+
+    suspend fun await(url: String, mangaId: Long): Chapter? {
+        return try {
+            chapterRepository.getChapterByUrlAndMangaId(url, mangaId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/GetChapterByMangaId.kt

@@ -0,0 +1,20 @@
+package eu.kanade.domain.chapter.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.chapter.repository.ChapterRepository
+
+class GetChapterByMangaId(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(mangaId: Long): List<Chapter> {
+        return try {
+            chapterRepository.getChapterByMangaId(mangaId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/GetChapterByUrl.kt

@@ -0,0 +1,20 @@
+package eu.kanade.domain.chapter.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.chapter.repository.ChapterRepository
+
+class GetChapterByUrl(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(url: String): List<Chapter> {
+        return try {
+            chapterRepository.getChapterByUrl(url)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/GetMergedChapterByMangaId.kt

@@ -0,0 +1,107 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.manga.interactor.GetMergedReferencesById
+import exh.source.MERGED_SOURCE_ID
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flowOf
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.chapter.repository.ChapterRepository
+import tachiyomi.domain.manga.model.MergedMangaReference
+
+class GetMergedChapterByMangaId(
+    private val chapterRepository: ChapterRepository,
+    private val getMergedReferencesById: GetMergedReferencesById,
+) {
+
+    suspend fun await(mangaId: Long, dedupe: Boolean = true): List<Chapter> {
+        return transformMergedChapters(getMergedReferencesById.await(mangaId), getFromDatabase(mangaId), dedupe)
+    }
+
+    suspend fun subscribe(mangaId: Long, dedupe: Boolean = true): Flow<List<Chapter>> {
+        return try {
+            chapterRepository.getMergedChapterByMangaIdAsFlow(mangaId)
+                .combine(getMergedReferencesById.subscribe(mangaId)) { chapters, references ->
+                    transformMergedChapters(references, chapters, dedupe)
+                }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            flowOf(emptyList())
+        }
+    }
+
+    private suspend fun getFromDatabase(mangaId: Long): List<Chapter> {
+        return try {
+            chapterRepository.getMergedChapterByMangaId(mangaId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+
+    fun transformMergedChapters(mangaReferences: List<MergedMangaReference>, chapterList: List<Chapter>, dedupe: Boolean): List<Chapter> {
+        return if (dedupe) dedupeChapterList(mangaReferences, chapterList) else chapterList
+    }
+
+    private fun dedupeChapterList(mangaReferences: List<MergedMangaReference>, chapterList: List<Chapter>): List<Chapter> {
+        return when (mangaReferences.firstOrNull { it.mangaSourceId == MERGED_SOURCE_ID }?.chapterSortMode) {
+            MergedMangaReference.CHAPTER_SORT_NO_DEDUPE, MergedMangaReference.CHAPTER_SORT_NONE -> chapterList
+            MergedMangaReference.CHAPTER_SORT_PRIORITY -> dedupeByPriority(mangaReferences, chapterList)
+            MergedMangaReference.CHAPTER_SORT_MOST_CHAPTERS -> {
+                findSourceWithMostChapters(chapterList)?.let { mangaId ->
+                    chapterList.filter { it.mangaId == mangaId }
+                } ?: chapterList
+            }
+            MergedMangaReference.CHAPTER_SORT_HIGHEST_CHAPTER_NUMBER -> {
+                findSourceWithHighestChapterNumber(chapterList)?.let { mangaId ->
+                    chapterList.filter { it.mangaId == mangaId }
+                } ?: chapterList
+            }
+            else -> chapterList
+        }
+    }
+
+    private fun findSourceWithMostChapters(chapterList: List<Chapter>): Long? {
+        return chapterList.groupBy { it.mangaId }.maxByOrNull { it.value.size }?.key
+    }
+
+    private fun findSourceWithHighestChapterNumber(chapterList: List<Chapter>): Long? {
+        return chapterList.maxByOrNull { it.chapterNumber }?.mangaId
+    }
+
+    private fun dedupeByPriority(mangaReferences: List<MergedMangaReference>, chapterList: List<Chapter>): List<Chapter> {
+        val sortedChapterList = mutableListOf<Chapter>()
+
+        var existingChapterIndex: Int
+        chapterList.groupBy { it.mangaId }
+            .entries
+            .sortedBy { (mangaId) ->
+                mangaReferences.find { it.mangaId == mangaId }?.chapterPriority ?: Int.MAX_VALUE
+            }
+            .forEach { (_, chapters) ->
+                existingChapterIndex = -1
+                chapters.forEach { chapter ->
+                    val oldChapterIndex = existingChapterIndex
+                    if (chapter.isRecognizedNumber) {
+                        existingChapterIndex = sortedChapterList.indexOfFirst {
+                            it.isRecognizedNumber && it.chapterNumber == chapter.chapterNumber && // check if the chapter is not already there
+                                it.mangaId != chapter.mangaId // allow multiple chapters of the same number from the same source
+                        }
+                        if (existingChapterIndex == -1) {
+                            sortedChapterList.add(oldChapterIndex + 1, chapter)
+                            existingChapterIndex = oldChapterIndex + 1
+                        }
+                    } else {
+                        sortedChapterList.add(oldChapterIndex + 1, chapter)
+                        existingChapterIndex = oldChapterIndex + 1
+                    }
+                }
+            }
+
+        return sortedChapterList.mapIndexed { index, chapter ->
+            chapter.copy(sourceOrder = index.toLong())
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/SetDefaultChapterSettings.kt

@@ -0,0 +1,36 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.library.service.LibraryPreferences
+import eu.kanade.domain.manga.interactor.GetFavorites
+import eu.kanade.domain.manga.interactor.SetMangaChapterFlags
+import tachiyomi.core.util.lang.withNonCancellableContext
+import tachiyomi.domain.manga.model.Manga
+
+class SetMangaDefaultChapterFlags(
+    private val libraryPreferences: LibraryPreferences,
+    private val setMangaChapterFlags: SetMangaChapterFlags,
+    private val getFavorites: GetFavorites,
+) {
+
+    suspend fun await(manga: Manga) {
+        withNonCancellableContext {
+            with(libraryPreferences) {
+                setMangaChapterFlags.awaitSetAllFlags(
+                    mangaId = manga.id,
+                    unreadFilter = filterChapterByRead().get(),
+                    downloadedFilter = filterChapterByDownloaded().get(),
+                    bookmarkedFilter = filterChapterByBookmarked().get(),
+                    sortingMode = sortChapterBySourceOrNumber().get(),
+                    sortingDirection = sortChapterByAscendingOrDescending().get(),
+                    displayMode = displayChapterByNameOrNumber().get(),
+                )
+            }
+        }
+    }
+
+    suspend fun awaitAll() {
+        withNonCancellableContext {
+            getFavorites.await().forEach { await(it) }
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/SetReadStatus.kt

@@ -0,0 +1,98 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.download.interactor.DeleteDownload
+import eu.kanade.domain.download.service.DownloadPreferences
+import exh.source.MERGED_SOURCE_ID
+import logcat.LogPriority
+import tachiyomi.core.util.lang.withNonCancellableContext
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.chapter.model.ChapterUpdate
+import tachiyomi.domain.chapter.repository.ChapterRepository
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class SetReadStatus(
+    private val downloadPreferences: DownloadPreferences,
+    private val deleteDownload: DeleteDownload,
+    private val mangaRepository: MangaRepository,
+    private val chapterRepository: ChapterRepository,
+    // SY -->
+    private val getMergedChapterByMangaId: GetMergedChapterByMangaId,
+    // SY <--
+) {
+
+    private val mapper = { chapter: Chapter, read: Boolean ->
+        ChapterUpdate(
+            read = read,
+            lastPageRead = if (!read) 0 else null,
+            id = chapter.id,
+        )
+    }
+
+    suspend fun await(read: Boolean, vararg chapters: Chapter): Result = withNonCancellableContext {
+        val chaptersToUpdate = chapters.filter {
+            when (read) {
+                true -> !it.read
+                false -> it.read || it.lastPageRead > 0
+            }
+        }
+        if (chaptersToUpdate.isEmpty()) {
+            return@withNonCancellableContext Result.NoChapters
+        }
+
+        try {
+            chapterRepository.updateAll(
+                chaptersToUpdate.map { mapper(it, read) },
+            )
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            return@withNonCancellableContext Result.InternalError(e)
+        }
+
+        if (read && downloadPreferences.removeAfterMarkedAsRead().get()) {
+            chaptersToUpdate
+                .groupBy { it.mangaId }
+                .forEach { (mangaId, chapters) ->
+                    deleteDownload.awaitAll(
+                        manga = mangaRepository.getMangaById(mangaId),
+                        chapters = chapters.toTypedArray(),
+                    )
+                }
+        }
+
+        Result.Success
+    }
+
+    suspend fun await(mangaId: Long, read: Boolean): Result = withNonCancellableContext {
+        await(
+            read = read,
+            chapters = chapterRepository
+                .getChapterByMangaId(mangaId)
+                .toTypedArray(),
+        )
+    }
+
+    // SY -->
+    private suspend fun awaitMerged(mangaId: Long, read: Boolean) = withNonCancellableContext f@{
+        return@f await(
+            read = read,
+            chapters = getMergedChapterByMangaId
+                .await(mangaId, dedupe = false)
+                .toTypedArray(),
+        )
+    }
+
+    suspend fun await(manga: Manga, read: Boolean) = if (manga.source == MERGED_SOURCE_ID) {
+        awaitMerged(manga.id, read)
+    } else {
+        await(manga.id, read)
+    }
+    // SY <--
+
+    sealed class Result {
+        object Success : Result()
+        object NoChapters : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithSource.kt

@@ -0,0 +1,217 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.chapter.model.copyFromSChapter
+import eu.kanade.domain.chapter.model.toSChapter
+import eu.kanade.domain.manga.interactor.UpdateManga
+import eu.kanade.domain.manga.model.toSManga
+import eu.kanade.tachiyomi.data.download.DownloadManager
+import eu.kanade.tachiyomi.data.download.DownloadProvider
+import eu.kanade.tachiyomi.source.Source
+import eu.kanade.tachiyomi.source.isLocal
+import eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.source.online.HttpSource
+import eu.kanade.tachiyomi.util.chapter.ChapterRecognition
+import exh.source.isEhBasedManga
+import tachiyomi.data.chapter.ChapterSanitizer
+import tachiyomi.domain.chapter.interactor.ShouldUpdateDbChapter
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.chapter.model.NoChaptersException
+import tachiyomi.domain.chapter.model.toChapterUpdate
+import tachiyomi.domain.chapter.repository.ChapterRepository
+import tachiyomi.domain.manga.model.Manga
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.lang.Long.max
+import java.util.Date
+import java.util.TreeSet
+
+class SyncChaptersWithSource(
+    private val downloadManager: DownloadManager = Injekt.get(),
+    private val downloadProvider: DownloadProvider = Injekt.get(),
+    private val chapterRepository: ChapterRepository = Injekt.get(),
+    private val shouldUpdateDbChapter: ShouldUpdateDbChapter = Injekt.get(),
+    private val updateManga: UpdateManga = Injekt.get(),
+    private val updateChapter: UpdateChapter = Injekt.get(),
+    private val getChapterByMangaId: GetChapterByMangaId = Injekt.get(),
+) {
+
+    /**
+     * Method to synchronize db chapters with source ones
+     *
+     * @param rawSourceChapters the chapters from the source.
+     * @param manga the manga the chapters belong to.
+     * @param source the source the manga belongs to.
+     * @return Newly added chapters
+     */
+    suspend fun await(
+        rawSourceChapters: List<SChapter>,
+        manga: Manga,
+        source: Source,
+    ): List<Chapter> {
+        if (rawSourceChapters.isEmpty() && !source.isLocal()) {
+            throw NoChaptersException()
+        }
+
+        val sourceChapters = rawSourceChapters
+            .distinctBy { it.url }
+            .mapIndexed { i, sChapter ->
+                Chapter.create()
+                    .copyFromSChapter(sChapter)
+                    .copy(name = with(ChapterSanitizer) { sChapter.name.sanitize(manga.title) })
+                    .copy(mangaId = manga.id, sourceOrder = i.toLong())
+            }
+
+        // Chapters from db.
+        val dbChapters = getChapterByMangaId.await(manga.id)
+
+        // Chapters from the source not in db.
+        val toAdd = mutableListOf<Chapter>()
+
+        // Chapters whose metadata have changed.
+        val toChange = mutableListOf<Chapter>()
+
+        // Chapters from the db not in source.
+        val toDelete = dbChapters.filterNot { dbChapter ->
+            sourceChapters.any { sourceChapter ->
+                dbChapter.url == sourceChapter.url
+            }
+        }
+
+        val rightNow = Date().time
+
+        // Used to not set upload date of older chapters
+        // to a higher value than newer chapters
+        var maxSeenUploadDate = 0L
+
+        val sManga = manga.toSManga()
+        for (sourceChapter in sourceChapters) {
+            var chapter = sourceChapter
+
+            // Update metadata from source if necessary.
+            if (source is HttpSource) {
+                val sChapter = chapter.toSChapter()
+                source.prepareNewChapter(sChapter, sManga)
+                chapter = chapter.copyFromSChapter(sChapter)
+            }
+
+            // Recognize chapter number for the chapter.
+            val chapterNumber = ChapterRecognition.parseChapterNumber(manga.title, chapter.name, chapter.chapterNumber)
+            chapter = chapter.copy(chapterNumber = chapterNumber)
+
+            val dbChapter = dbChapters.find { it.url == chapter.url }
+
+            if (dbChapter == null) {
+                val toAddChapter = if (chapter.dateUpload == 0L) {
+                    val altDateUpload = if (maxSeenUploadDate == 0L) rightNow else maxSeenUploadDate
+                    chapter.copy(dateUpload = altDateUpload)
+                } else {
+                    maxSeenUploadDate = max(maxSeenUploadDate, sourceChapter.dateUpload)
+                    chapter
+                }
+                toAdd.add(toAddChapter)
+            } else {
+                if (shouldUpdateDbChapter.await(dbChapter, chapter)) {
+                    val shouldRenameChapter = downloadProvider.isChapterDirNameChanged(dbChapter, chapter) &&
+                        downloadManager.isChapterDownloaded(dbChapter.name, dbChapter.scanlator, /* SY --> */ manga.ogTitle /* SY <-- */, manga.source)
+
+                    if (shouldRenameChapter) {
+                        downloadManager.renameChapter(source, manga, dbChapter, chapter)
+                    }
+                    var toChangeChapter = dbChapter.copy(
+                        name = chapter.name,
+                        chapterNumber = chapter.chapterNumber,
+                        scanlator = chapter.scanlator,
+                        sourceOrder = chapter.sourceOrder,
+                    )
+                    if (chapter.dateUpload != 0L) {
+                        toChangeChapter = toChangeChapter.copy(dateUpload = chapter.dateUpload)
+                    }
+                    toChange.add(toChangeChapter)
+                }
+            }
+        }
+
+        // Return if there's nothing to add, delete or change, avoiding unnecessary db transactions.
+        if (toAdd.isEmpty() && toDelete.isEmpty() && toChange.isEmpty()) {
+            return emptyList()
+        }
+
+        val reAdded = mutableListOf<Chapter>()
+
+        val deletedChapterNumbers = TreeSet<Float>()
+        val deletedReadChapterNumbers = TreeSet<Float>()
+        val deletedBookmarkedChapterNumbers = TreeSet<Float>()
+
+        toDelete.forEach { chapter ->
+            if (chapter.read) deletedReadChapterNumbers.add(chapter.chapterNumber)
+            if (chapter.bookmark) deletedBookmarkedChapterNumbers.add(chapter.chapterNumber)
+            deletedChapterNumbers.add(chapter.chapterNumber)
+        }
+
+        val deletedChapterNumberDateFetchMap = toDelete.sortedByDescending { it.dateFetch }
+            .associate { it.chapterNumber to it.dateFetch }
+
+        // Date fetch is set in such a way that the upper ones will have bigger value than the lower ones
+        // Sources MUST return the chapters from most to less recent, which is common.
+        var itemCount = toAdd.size
+        var updatedToAdd = toAdd.map { toAddItem ->
+            var chapter = toAddItem.copy(dateFetch = rightNow + itemCount--)
+
+            if (chapter.isRecognizedNumber.not() || chapter.chapterNumber !in deletedChapterNumbers) return@map chapter
+
+            chapter = chapter.copy(
+                read = chapter.chapterNumber in deletedReadChapterNumbers,
+                bookmark = chapter.chapterNumber in deletedBookmarkedChapterNumbers,
+            )
+
+            // Try to to use the fetch date of the original entry to not pollute 'Updates' tab
+            deletedChapterNumberDateFetchMap[chapter.chapterNumber]?.let {
+                chapter = chapter.copy(dateFetch = it)
+            }
+
+            reAdded.add(chapter)
+
+            chapter
+        }
+
+        // --> EXH (carry over reading progress)
+        if (manga.isEhBasedManga()) {
+            val finalAdded = updatedToAdd.subtract(reAdded)
+            if (finalAdded.isNotEmpty()) {
+                val max = dbChapters.maxOfOrNull { it.lastPageRead }
+                if (max != null && max > 0) {
+                    updatedToAdd = updatedToAdd.map {
+                        if (it !in reAdded) {
+                            it.copy(lastPageRead = max)
+                        } else {
+                            it
+                        }
+                    }
+                }
+            }
+        }
+        // <-- EXH
+
+        if (toDelete.isNotEmpty()) {
+            val toDeleteIds = toDelete.map { it.id }
+            chapterRepository.removeChaptersWithIds(toDeleteIds)
+        }
+
+        if (updatedToAdd.isNotEmpty()) {
+            updatedToAdd = chapterRepository.addAll(updatedToAdd)
+        }
+
+        if (toChange.isNotEmpty()) {
+            val chapterUpdates = toChange.map { it.toChapterUpdate() }
+            updateChapter.awaitAll(chapterUpdates)
+        }
+
+        // Set this manga as updated since chapters were changed
+        // Note that last_update actually represents last time the chapter list changed at all
+        updateManga.awaitUpdateLastUpdate(manga.id)
+
+        val reAddedUrls = reAdded.map { it.url }.toHashSet()
+
+        return updatedToAdd.filterNot { it.url in reAddedUrls }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithTrackServiceTwoWay.kt

@@ -0,0 +1,41 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.track.interactor.InsertTrack
+import eu.kanade.domain.track.model.toDbTrack
+import eu.kanade.tachiyomi.data.track.TrackService
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.chapter.model.toChapterUpdate
+import tachiyomi.domain.track.model.Track
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class SyncChaptersWithTrackServiceTwoWay(
+    private val updateChapter: UpdateChapter = Injekt.get(),
+    private val insertTrack: InsertTrack = Injekt.get(),
+) {
+
+    suspend fun await(
+        chapters: List<Chapter>,
+        remoteTrack: Track,
+        service: TrackService,
+    ) {
+        val sortedChapters = chapters.sortedBy { it.chapterNumber }
+        val chapterUpdates = sortedChapters
+            .filter { chapter -> chapter.chapterNumber <= remoteTrack.lastChapterRead && !chapter.read }
+            .map { it.copy(read = true).toChapterUpdate() }
+
+        // only take into account continuous reading
+        val localLastRead = sortedChapters.takeWhile { it.read }.lastOrNull()?.chapterNumber ?: 0F
+        val updatedTrack = remoteTrack.copy(lastChapterRead = localLastRead.toDouble())
+
+        try {
+            service.update(updatedTrack.toDbTrack())
+            updateChapter.awaitAll(chapterUpdates)
+            insertTrack.await(updatedTrack)
+        } catch (e: Throwable) {
+            logcat(LogPriority.WARN, e)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/UpdateChapter.kt

@@ -0,0 +1,27 @@
+package eu.kanade.domain.chapter.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.chapter.model.ChapterUpdate
+import tachiyomi.domain.chapter.repository.ChapterRepository
+
+class UpdateChapter(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(chapterUpdate: ChapterUpdate) {
+        try {
+            chapterRepository.update(chapterUpdate)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+
+    suspend fun awaitAll(chapterUpdates: List<ChapterUpdate>) {
+        try {
+            chapterRepository.updateAll(chapterUpdates)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/model/Chapter.kt

@@ -0,0 +1,42 @@
+package eu.kanade.domain.chapter.model
+
+import eu.kanade.tachiyomi.data.database.models.ChapterImpl
+import eu.kanade.tachiyomi.source.model.SChapter
+import tachiyomi.domain.chapter.model.Chapter
+import eu.kanade.tachiyomi.data.database.models.Chapter as DbChapter
+
+// TODO: Remove when all deps are migrated
+fun Chapter.toSChapter(): SChapter {
+    return SChapter.create().also {
+        it.url = url
+        it.name = name
+        it.date_upload = dateUpload
+        it.chapter_number = chapterNumber
+        it.scanlator = scanlator
+    }
+}
+
+fun Chapter.copyFromSChapter(sChapter: SChapter): Chapter {
+    return this.copy(
+        name = sChapter.name,
+        url = sChapter.url,
+        dateUpload = sChapter.date_upload,
+        chapterNumber = sChapter.chapter_number,
+        scanlator = sChapter.scanlator?.ifBlank { null },
+    )
+}
+
+fun Chapter.toDbChapter(): DbChapter = ChapterImpl().also {
+    it.id = id
+    it.manga_id = mangaId
+    it.url = url
+    it.name = name
+    it.scanlator = scanlator
+    it.read = read
+    it.bookmark = bookmark
+    it.last_page_read = lastPageRead.toInt()
+    it.date_fetch = dateFetch
+    it.date_upload = dateUpload
+    it.chapter_number = chapterNumber
+    it.source_order = sourceOrder.toInt()
+}

app/src/main/java/eu/kanade/domain/chapter/model/ChapterFilter.kt

@@ -0,0 +1,95 @@
+package eu.kanade.domain.chapter.model
+
+import eu.kanade.domain.manga.model.downloadedFilter
+import eu.kanade.domain.manga.model.isLocal
+import eu.kanade.tachiyomi.data.download.DownloadManager
+import eu.kanade.tachiyomi.data.download.model.Download
+import eu.kanade.tachiyomi.ui.manga.ChapterItem
+import eu.kanade.tachiyomi.util.chapter.getChapterSort
+import exh.md.utils.MdUtil
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.model.TriStateFilter
+
+/**
+ * Applies the view filters to the list of chapters obtained from the database.
+ * @return an observable of the list of chapters filtered and sorted.
+ */
+fun List<Chapter>.applyFilters(manga: Manga, downloadManager: DownloadManager): List<Chapter> {
+    val isLocalManga = manga.isLocal()
+    val unreadFilter = manga.unreadFilter
+    val downloadedFilter = manga.downloadedFilter
+    val bookmarkedFilter = manga.bookmarkedFilter
+
+    return filter { chapter ->
+        when (unreadFilter) {
+            TriStateFilter.DISABLED -> true
+            TriStateFilter.ENABLED_IS -> !chapter.read
+            TriStateFilter.ENABLED_NOT -> chapter.read
+        }
+    }
+        .filter { chapter ->
+            when (bookmarkedFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> chapter.bookmark
+                TriStateFilter.ENABLED_NOT -> !chapter.bookmark
+            }
+        }
+        .filter { chapter ->
+            val downloaded = downloadManager.isChapterDownloaded(chapter.name, chapter.scanlator, /* SY --> */ manga.ogTitle /* SY <-- */, manga.source)
+            val downloadState = when {
+                downloaded -> Download.State.DOWNLOADED
+                else -> Download.State.NOT_DOWNLOADED
+            }
+            when (downloadedFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> downloadState == Download.State.DOWNLOADED || isLocalManga
+                TriStateFilter.ENABLED_NOT -> downloadState != Download.State.DOWNLOADED && !isLocalManga
+            }
+        }
+        // SY -->
+        .filter { chapter ->
+            manga.filteredScanlators.isNullOrEmpty() || MdUtil.getScanlators(chapter.scanlator).any { group -> manga.filteredScanlators!!.contains(group) }
+        }
+        // SY <--
+        .sortedWith(getChapterSort(manga))
+}
+
+/**
+ * Applies the view filters to the list of chapters obtained from the database.
+ * @return an observable of the list of chapters filtered and sorted.
+ */
+fun List<ChapterItem>.applyFilters(manga: Manga): Sequence<ChapterItem> {
+    val isLocalManga = manga.isLocal()
+    val unreadFilter = manga.unreadFilter
+    val downloadedFilter = manga.downloadedFilter
+    val bookmarkedFilter = manga.bookmarkedFilter
+    return asSequence()
+        .filter { (chapter) ->
+            when (unreadFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> !chapter.read
+                TriStateFilter.ENABLED_NOT -> chapter.read
+            }
+        }
+        .filter { (chapter) ->
+            when (bookmarkedFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> chapter.bookmark
+                TriStateFilter.ENABLED_NOT -> !chapter.bookmark
+            }
+        }
+        .filter {
+            when (downloadedFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> it.isDownloaded || isLocalManga
+                TriStateFilter.ENABLED_NOT -> !it.isDownloaded && !isLocalManga
+            }
+        }
+        // SY -->
+        .filter { chapter ->
+            manga.filteredScanlators.isNullOrEmpty() || MdUtil.getScanlators(chapter.chapter.scanlator).any { group -> manga.filteredScanlators!!.contains(group) }
+        }
+        // SY <--
+        .sortedWith { (chapter1), (chapter2) -> getChapterSort(manga).invoke(chapter1, chapter2) }
+}

app/src/main/java/eu/kanade/domain/download/interactor/DeleteDownload.kt

@@ -0,0 +1,19 @@
+package eu.kanade.domain.download.interactor
+
+import eu.kanade.tachiyomi.data.download.DownloadManager
+import eu.kanade.tachiyomi.source.SourceManager
+import tachiyomi.core.util.lang.withNonCancellableContext
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.manga.model.Manga
+
+class DeleteDownload(
+    private val sourceManager: SourceManager,
+    private val downloadManager: DownloadManager,
+) {
+
+    suspend fun awaitAll(manga: Manga, vararg chapters: Chapter) = withNonCancellableContext {
+        sourceManager.get(manga.source)?.let { source ->
+            downloadManager.deleteChapters(chapters.toList(), manga, source)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/download/service/DownloadPreferences.kt

@@ -0,0 +1,34 @@
+package eu.kanade.domain.download.service
+
+import tachiyomi.core.preference.PreferenceStore
+import tachiyomi.core.provider.FolderProvider
+
+class DownloadPreferences(
+    private val folderProvider: FolderProvider,
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun downloadsDirectory() = preferenceStore.getString("download_directory", folderProvider.path())
+
+    fun downloadOnlyOverWifi() = preferenceStore.getBoolean("pref_download_only_over_wifi_key", true)
+
+    fun saveChaptersAsCBZ() = preferenceStore.getBoolean("save_chapter_as_cbz", true)
+
+    fun splitTallImages() = preferenceStore.getBoolean("split_tall_images", false)
+
+    fun autoDownloadWhileReading() = preferenceStore.getInt("auto_download_while_reading", 0)
+
+    fun removeAfterReadSlots() = preferenceStore.getInt("remove_after_read_slots", -1)
+
+    fun removeAfterMarkedAsRead() = preferenceStore.getBoolean("pref_remove_after_marked_as_read_key", false)
+
+    fun removeBookmarkedChapters() = preferenceStore.getBoolean("pref_remove_bookmarked", false)
+
+    fun removeExcludeCategories() = preferenceStore.getStringSet("remove_exclude_categories", emptySet())
+
+    fun downloadNewChapters() = preferenceStore.getBoolean("download_new", false)
+
+    fun downloadNewChapterCategories() = preferenceStore.getStringSet("download_new_categories", emptySet())
+
+    fun downloadNewChapterCategoriesExclude() = preferenceStore.getStringSet("download_new_categories_exclude", emptySet())
+}

app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionLanguages.kt

@@ -0,0 +1,32 @@
+package eu.kanade.domain.extension.interactor
+
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.extension.ExtensionManager
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+
+class GetExtensionLanguages(
+    private val preferences: SourcePreferences,
+    private val extensionManager: ExtensionManager,
+) {
+    fun subscribe(): Flow<List<String>> {
+        return combine(
+            preferences.enabledLanguages().changes(),
+            extensionManager.availableExtensionsFlow,
+        ) { enabledLanguage, availableExtensions ->
+            availableExtensions
+                .flatMap { ext ->
+                    if (ext.sources.isEmpty()) {
+                        listOf(ext.lang)
+                    } else {
+                        ext.sources.map { it.lang }
+                    }
+                }
+                .distinct()
+                .sortedWith(
+                    compareBy<String> { it !in enabledLanguage }.then(LocaleHelper.comparator),
+                )
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionSources.kt

@@ -0,0 +1,37 @@
+package eu.kanade.domain.extension.interactor
+
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.extension.model.Extension
+import eu.kanade.tachiyomi.source.Source
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+class GetExtensionSources(
+    private val preferences: SourcePreferences,
+) {
+
+    fun subscribe(extension: Extension.Installed): Flow<List<ExtensionSourceItem>> {
+        val isMultiSource = extension.sources.size > 1
+        val isMultiLangSingleSource =
+            isMultiSource && extension.sources.map { it.name }.distinct().size == 1
+
+        return preferences.disabledSources().changes().map { disabledSources ->
+            fun Source.isEnabled() = id.toString() !in disabledSources
+
+            extension.sources
+                .map { source ->
+                    ExtensionSourceItem(
+                        source = source,
+                        enabled = source.isEnabled(),
+                        labelAsName = isMultiSource && isMultiLangSingleSource.not(),
+                    )
+                }
+        }
+    }
+}
+
+data class ExtensionSourceItem(
+    val source: Source,
+    val enabled: Boolean,
+    val labelAsName: Boolean,
+)

app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionsByType.kt

@@ -0,0 +1,60 @@
+package eu.kanade.domain.extension.interactor
+
+import eu.kanade.domain.extension.model.Extensions
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.extension.ExtensionManager
+import eu.kanade.tachiyomi.extension.model.Extension
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+
+class GetExtensionsByType(
+    private val preferences: SourcePreferences,
+    private val extensionManager: ExtensionManager,
+) {
+
+    fun subscribe(): Flow<Extensions> {
+        val showNsfwSources = preferences.showNsfwSource().get()
+
+        return combine(
+            preferences.enabledLanguages().changes(),
+            extensionManager.installedExtensionsFlow,
+            extensionManager.untrustedExtensionsFlow,
+            extensionManager.availableExtensionsFlow,
+        ) { _activeLanguages, _installed, _untrusted, _available ->
+            val (updates, installed) = _installed
+                .filter { (showNsfwSources || it.isNsfw.not()) }
+                .sortedWith(
+                    compareBy<Extension.Installed> { it.isObsolete.not() /* SY --> */ && it.isRedundant.not() /* SY <-- */ }
+                        .thenBy(String.CASE_INSENSITIVE_ORDER) { it.name },
+                )
+                .partition { it.hasUpdate }
+
+            val untrusted = _untrusted
+                .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name })
+
+            val available = _available
+                .filter { extension ->
+                    _installed.none { it.pkgName == extension.pkgName } &&
+                        _untrusted.none { it.pkgName == extension.pkgName } &&
+                        (showNsfwSources || extension.isNsfw.not())
+                }
+                .flatMap { ext ->
+                    if (ext.sources.isEmpty()) {
+                        return@flatMap if (ext.lang in _activeLanguages) listOf(ext) else emptyList()
+                    }
+                    ext.sources.filter { it.lang in _activeLanguages }
+                        .map {
+                            ext.copy(
+                                name = it.name,
+                                lang = it.lang,
+                                pkgName = "${ext.pkgName}-${it.id}",
+                                sources = listOf(it),
+                            )
+                        }
+                }
+                .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name })
+
+            Extensions(updates, installed, available, untrusted)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/extension/model/Extensions.kt

@@ -0,0 +1,10 @@
+package eu.kanade.domain.extension.model
+
+import eu.kanade.tachiyomi.extension.model.Extension
+
+data class Extensions(
+    val updates: List<Extension.Installed>,
+    val installed: List<Extension.Installed>,
+    val available: List<Extension.Available>,
+    val untrusted: List<Extension.Untrusted>,
+)

app/src/main/java/eu/kanade/domain/history/interactor/GetHistoryByMangaId.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.history.interactor
+
+import tachiyomi.domain.history.model.History
+import tachiyomi.domain.history.repository.HistoryRepository
+
+class GetHistoryByMangaId(
+    private val repository: HistoryRepository,
+) {
+
+    suspend fun await(mangaId: Long): List<History> {
+        return repository.getByMangaId(mangaId)
+    }
+}

app/src/main/java/eu/kanade/domain/history/interactor/GetNextChapters.kt

@@ -0,0 +1,82 @@
+package eu.kanade.domain.history.interactor
+
+import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
+import eu.kanade.domain.chapter.interactor.GetMergedChapterByMangaId
+import eu.kanade.domain.manga.interactor.GetManga
+import eu.kanade.tachiyomi.util.chapter.getChapterSort
+import exh.source.MERGED_SOURCE_ID
+import exh.source.isEhBasedManga
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.history.repository.HistoryRepository
+import kotlin.math.max
+
+class GetNextChapters(
+    private val getChapterByMangaId: GetChapterByMangaId,
+    // SY -->
+    private val getMergedChapterByMangaId: GetMergedChapterByMangaId,
+    // SY <--
+    private val getManga: GetManga,
+    private val historyRepository: HistoryRepository,
+) {
+
+    suspend fun await(onlyUnread: Boolean = true): List<Chapter> {
+        val history = historyRepository.getLastHistory() ?: return emptyList()
+        return await(history.mangaId, history.chapterId, onlyUnread)
+    }
+
+    suspend fun await(mangaId: Long, onlyUnread: Boolean = true): List<Chapter> {
+        val manga = getManga.await(mangaId) ?: return emptyList()
+
+        // SY -->
+        if (manga.source == MERGED_SOURCE_ID) {
+            val chapters = getMergedChapterByMangaId.await(mangaId)
+                .sortedWith(getChapterSort(manga, sortDescending = false))
+
+            return if (onlyUnread) {
+                chapters.filterNot { it.read }
+            } else {
+                chapters
+            }
+        }
+        if (manga.isEhBasedManga()) {
+            val chapters = getChapterByMangaId.await(mangaId)
+                .sortedWith(getChapterSort(manga, sortDescending = false))
+
+            return if (onlyUnread) {
+                chapters.takeLast(1).takeUnless { it.firstOrNull()?.read == true }.orEmpty()
+            } else {
+                chapters
+            }
+        }
+        // SY <--
+
+        val chapters = getChapterByMangaId.await(mangaId)
+            .sortedWith(getChapterSort(manga, sortDescending = false))
+
+        return if (onlyUnread) {
+            chapters.filterNot { it.read }
+        } else {
+            chapters
+        }
+    }
+
+    suspend fun await(mangaId: Long, fromChapterId: Long, onlyUnread: Boolean = true): List<Chapter> {
+        val chapters = await(mangaId, onlyUnread)
+        val currChapterIndex = chapters.indexOfFirst { it.id == fromChapterId }
+        val nextChapters = chapters.subList(max(0, currChapterIndex), chapters.size)
+
+        if (onlyUnread) {
+            return nextChapters
+        }
+
+        // The "next chapter" is either:
+        // - The current chapter if it isn't completely read
+        // - The chapters after the current chapter if the current one is completely read
+        val fromChapter = chapters.getOrNull(currChapterIndex)
+        return if (fromChapter != null && !fromChapter.read) {
+            nextChapters
+        } else {
+            nextChapters.drop(1)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/library/model/GroupLibraryMode.kt

@@ -0,0 +1,7 @@
+package eu.kanade.domain.library.model
+
+enum class GroupLibraryMode {
+    GLOBAL,
+    ALL_BUT_UNGROUPED,
+    ALL,
+}

app/src/main/java/eu/kanade/domain/library/model/LibraryGroup.kt

@@ -1,4 +1,4 @@
-package eu.kanade.tachiyomi.ui.library
+package eu.kanade.domain.library.model
 
 import eu.kanade.tachiyomi.R
 

app/src/main/java/eu/kanade/domain/library/service/LibraryPreferences.kt

@@ -0,0 +1,128 @@
+package eu.kanade.domain.library.service
+
+import eu.kanade.domain.library.model.GroupLibraryMode
+import eu.kanade.domain.library.model.LibraryGroup
+import eu.kanade.tachiyomi.data.preference.DEVICE_ONLY_ON_WIFI
+import eu.kanade.tachiyomi.data.preference.MANGA_HAS_UNREAD
+import eu.kanade.tachiyomi.data.preference.MANGA_NON_COMPLETED
+import eu.kanade.tachiyomi.data.preference.MANGA_NON_READ
+import eu.kanade.tachiyomi.widget.ExtendedNavigationView
+import tachiyomi.core.preference.PreferenceStore
+import tachiyomi.core.preference.getEnum
+import tachiyomi.domain.library.model.LibraryDisplayMode
+import tachiyomi.domain.library.model.LibrarySort
+import tachiyomi.domain.manga.model.Manga
+
+class LibraryPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun libraryDisplayMode() = preferenceStore.getObject("pref_display_mode_library", LibraryDisplayMode.default, LibraryDisplayMode.Serializer::serialize, LibraryDisplayMode.Serializer::deserialize)
+
+    fun librarySortingMode() = preferenceStore.getObject("library_sorting_mode", LibrarySort.default, LibrarySort.Serializer::serialize, LibrarySort.Serializer::deserialize)
+
+    fun portraitColumns() = preferenceStore.getInt("pref_library_columns_portrait_key", 0)
+
+    fun landscapeColumns() = preferenceStore.getInt("pref_library_columns_landscape_key", 0)
+
+    fun libraryUpdateInterval() = preferenceStore.getInt("pref_library_update_interval_key", 0)
+    fun libraryUpdateLastTimestamp() = preferenceStore.getLong("library_update_last_timestamp", 0L)
+
+    fun libraryUpdateDeviceRestriction() = preferenceStore.getStringSet("library_update_restriction", setOf(DEVICE_ONLY_ON_WIFI))
+    fun libraryUpdateMangaRestriction() = preferenceStore.getStringSet("library_update_manga_restriction", setOf(MANGA_HAS_UNREAD, MANGA_NON_COMPLETED, MANGA_NON_READ))
+
+    fun autoUpdateMetadata() = preferenceStore.getBoolean("auto_update_metadata", false)
+
+    fun autoUpdateTrackers() = preferenceStore.getBoolean("auto_update_trackers", false)
+
+    fun showContinueReadingButton() = preferenceStore.getBoolean("display_continue_reading_button", false)
+
+    // region Filter
+
+    fun filterDownloaded() = preferenceStore.getInt("pref_filter_library_downloaded", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    fun filterUnread() = preferenceStore.getInt("pref_filter_library_unread", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    fun filterStarted() = preferenceStore.getInt("pref_filter_library_started", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    fun filterBookmarked() = preferenceStore.getInt("pref_filter_library_bookmarked", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    fun filterCompleted() = preferenceStore.getInt("pref_filter_library_completed", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    // SY -->
+    fun filterLewd() = preferenceStore.getInt("pref_filter_library_lewd", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+    // SY <--
+
+    fun filterTracking(name: Int) = preferenceStore.getInt("pref_filter_library_tracked_$name", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    // endregion
+
+    // region Badges
+
+    fun downloadBadge() = preferenceStore.getBoolean("display_download_badge", false)
+
+    fun localBadge() = preferenceStore.getBoolean("display_local_badge", true)
+
+    fun languageBadge() = preferenceStore.getBoolean("display_language_badge", false)
+
+    fun newShowUpdatesCount() = preferenceStore.getBoolean("library_show_updates_count", true)
+    fun newUpdatesCount() = preferenceStore.getInt("library_unseen_updates_count", 0)
+
+    // endregion
+
+    // region Category
+
+    fun defaultCategory() = preferenceStore.getInt("default_category", -1)
+
+    fun lastUsedCategory() = preferenceStore.getInt("last_used_category", 0)
+
+    fun categoryTabs() = preferenceStore.getBoolean("display_category_tabs", true)
+
+    fun categoryNumberOfItems() = preferenceStore.getBoolean("display_number_of_items", false)
+
+    fun categorizedDisplaySettings() = preferenceStore.getBoolean("categorized_display", false)
+
+    fun libraryUpdateCategories() = preferenceStore.getStringSet("library_update_categories", emptySet())
+
+    fun libraryUpdateCategoriesExclude() = preferenceStore.getStringSet("library_update_categories_exclude", emptySet())
+
+    // endregion
+
+    // region Chapter
+
+    fun filterChapterByRead() = preferenceStore.getLong("default_chapter_filter_by_read", Manga.SHOW_ALL)
+
+    fun filterChapterByDownloaded() = preferenceStore.getLong("default_chapter_filter_by_downloaded", Manga.SHOW_ALL)
+
+    fun filterChapterByBookmarked() = preferenceStore.getLong("default_chapter_filter_by_bookmarked", Manga.SHOW_ALL)
+
+    // and upload date
+    fun sortChapterBySourceOrNumber() = preferenceStore.getLong("default_chapter_sort_by_source_or_number", Manga.CHAPTER_SORTING_SOURCE)
+
+    fun displayChapterByNameOrNumber() = preferenceStore.getLong("default_chapter_display_by_name_or_number", Manga.CHAPTER_DISPLAY_NAME)
+
+    fun sortChapterByAscendingOrDescending() = preferenceStore.getLong("default_chapter_sort_by_ascending_or_descending", Manga.CHAPTER_SORT_DESC)
+
+    fun setChapterSettingsDefault(manga: Manga) {
+        filterChapterByRead().set(manga.unreadFilterRaw)
+        filterChapterByDownloaded().set(manga.downloadedFilterRaw)
+        filterChapterByBookmarked().set(manga.bookmarkedFilterRaw)
+        sortChapterBySourceOrNumber().set(manga.sorting)
+        displayChapterByNameOrNumber().set(manga.displayMode)
+        sortChapterByAscendingOrDescending().set(if (manga.sortDescending()) Manga.CHAPTER_SORT_DESC else Manga.CHAPTER_SORT_ASC)
+    }
+
+    fun autoClearChapterCache() = preferenceStore.getBoolean("auto_clear_chapter_cache", false)
+
+    // endregion
+
+    // SY -->
+
+    fun sortTagsForLibrary() = preferenceStore.getStringSet("sort_tags_for_library", mutableSetOf())
+
+    fun groupLibraryUpdateType() = preferenceStore.getEnum("group_library_update_type", GroupLibraryMode.GLOBAL)
+
+    fun groupLibraryBy() = preferenceStore.getInt("group_library_by", LibraryGroup.BY_DEFAULT)
+
+    // SY <--
+}

app/src/main/java/eu/kanade/domain/manga/interactor/CreateSortTag.kt

@@ -0,0 +1,40 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.domain.library.service.LibraryPreferences
+import eu.kanade.tachiyomi.util.preference.plusAssign
+
+class CreateSortTag(
+    private val preferences: LibraryPreferences,
+    private val getSortTag: GetSortTag,
+) {
+
+    fun await(tag: String): Result {
+        // Do not allow duplicate categories.
+        // Do not allow duplicate categories.
+        if (tagExists(tag.trim())) {
+            return Result.TagExists
+        }
+
+        val size = preferences.sortTagsForLibrary().get().size
+
+        preferences.sortTagsForLibrary() += encodeTag(size, tag)
+
+        return Result.Success
+    }
+
+    sealed class Result {
+        object TagExists : Result()
+        object Success : Result()
+    }
+
+    /**
+     * Returns true if a tag with the given name already exists.
+     */
+    private fun tagExists(name: String): Boolean {
+        return getSortTag.await().any { it.equals(name) }
+    }
+
+    companion object {
+        fun encodeTag(index: Int, tag: String) = "$index|${tag.trim()}"
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/DeleteByMergeId.kt

@@ -0,0 +1,12 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.repository.MangaMergeRepository
+
+class DeleteByMergeId(
+    private val mangaMergeRepository: MangaMergeRepository,
+) {
+
+    suspend fun await(id: Long) {
+        return mangaMergeRepository.deleteByMergeId(id)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/DeleteFavoriteEntries.kt

@@ -0,0 +1,12 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.repository.FavoritesEntryRepository
+
+class DeleteFavoriteEntries(
+    private val favoriteEntryRepository: FavoritesEntryRepository,
+) {
+
+    suspend fun await() {
+        return favoriteEntryRepository.deleteAll()
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/DeleteMangaById.kt

@@ -0,0 +1,12 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class DeleteMangaById(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(id: Long) {
+        return mangaRepository.deleteManga(id)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/DeleteMergeById.kt

@@ -0,0 +1,12 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.repository.MangaMergeRepository
+
+class DeleteMergeById(
+    private val mangaMergeRepository: MangaMergeRepository,
+) {
+
+    suspend fun await(id: Long) {
+        return mangaMergeRepository.deleteById(id)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/DeleteSortTag.kt

@@ -0,0 +1,17 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.domain.library.service.LibraryPreferences
+
+class DeleteSortTag(
+    private val preferences: LibraryPreferences,
+    private val getSortTag: GetSortTag,
+) {
+
+    fun await(tag: String) {
+        preferences.sortTagsForLibrary().set(
+            (getSortTag.await() - tag).mapIndexed { index, s ->
+                CreateSortTag.encodeTag(index, s)
+            }.toSet(),
+        )
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetAllManga.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class GetAllManga(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(): List<Manga> {
+        return mangaRepository.getAll()
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetDuplicateLibraryManga.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class GetDuplicateLibraryManga(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(title: String): Manga? {
+        return mangaRepository.getDuplicateLibraryManga(title.lowercase())
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetExhFavoriteMangaWithMetadata.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaMetadataRepository
+
+class GetExhFavoriteMangaWithMetadata(
+    private val mangaMetadataRepository: MangaMetadataRepository,
+) {
+
+    suspend fun await(): List<Manga> {
+        return mangaMetadataRepository.getExhFavoriteMangaWithMetadata()
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetFavoriteEntries.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.model.FavoriteEntry
+import tachiyomi.domain.manga.repository.FavoritesEntryRepository
+
+class GetFavoriteEntries(
+    private val favoriteEntryRepository: FavoritesEntryRepository,
+) {
+
+    suspend fun await(): List<FavoriteEntry> {
+        return favoriteEntryRepository.selectAll()
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetFavorites.kt

@@ -0,0 +1,18 @@
+package eu.kanade.domain.manga.interactor
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class GetFavorites(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(): List<Manga> {
+        return mangaRepository.getFavorites()
+    }
+
+    fun subscribe(sourceId: Long): Flow<List<Manga>> {
+        return mangaRepository.getFavoritesBySourceId(sourceId)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetFlatMetadataById.kt

@@ -0,0 +1,45 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.tachiyomi.source.online.MetadataSource
+import exh.metadata.metadata.base.FlatMetadata
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.manga.repository.MangaMetadataRepository
+
+class GetFlatMetadataById(
+    private val mangaMetadataRepository: MangaMetadataRepository,
+) : MetadataSource.GetFlatMetadataById {
+
+    override suspend fun await(id: Long): FlatMetadata? {
+        return try {
+            val meta = mangaMetadataRepository.getMetadataById(id)
+            return if (meta != null) {
+                val tags = mangaMetadataRepository.getTagsById(id)
+                val titles = mangaMetadataRepository.getTitlesById(id)
+
+                FlatMetadata(meta, tags, titles)
+            } else {
+                null
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+
+    fun subscribe(id: Long): Flow<FlatMetadata?> {
+        return combine(
+            mangaMetadataRepository.subscribeMetadataById(id),
+            mangaMetadataRepository.subscribeTagsById(id),
+            mangaMetadataRepository.subscribeTitlesById(id),
+        ) { meta, tags, titles ->
+            if (meta != null) {
+                FlatMetadata(meta, tags, titles)
+            } else {
+                null
+            }
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetIdsOfFavoriteMangaWithMetadata.kt

@@ -0,0 +1,12 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.repository.MangaMetadataRepository
+
+class GetIdsOfFavoriteMangaWithMetadata(
+    private val mangaMetadataRepository: MangaMetadataRepository,
+) {
+
+    suspend fun await(): List<Long> {
+        return mangaMetadataRepository.getIdsOfFavoriteMangaWithMetadata()
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetLibraryManga.kt

@@ -0,0 +1,30 @@
+package eu.kanade.domain.manga.interactor
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.retry
+import tachiyomi.domain.library.model.LibraryManga
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class GetLibraryManga(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(): List<LibraryManga> {
+        return mangaRepository.getLibraryManga()
+    }
+
+    fun subscribe(): Flow<List<LibraryManga>> {
+        return mangaRepository.getLibraryMangaAsFlow()
+            // SY -->
+            .let {
+                var retries = 0
+                it.retry {
+                    (retries++ < 3) && it is NullPointerException
+                }.onEach {
+                    retries = 0
+                }
+            }
+        // SY <--
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetManga.kt

@@ -0,0 +1,40 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.tachiyomi.source.online.MetadataSource
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class GetManga(
+    private val mangaRepository: MangaRepository,
+) : MetadataSource.GetMangaId {
+
+    suspend fun await(id: Long): Manga? {
+        return try {
+            mangaRepository.getMangaById(id)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+
+    suspend fun subscribe(id: Long): Flow<Manga> {
+        return mangaRepository.getMangaByIdAsFlow(id)
+    }
+
+    fun subscribe(url: String, sourceId: Long): Flow<Manga?> {
+        return mangaRepository.getMangaByUrlAndSourceIdAsFlow(url, sourceId)
+    }
+
+    // SY -->
+    suspend fun await(url: String, sourceId: Long): Manga? {
+        return mangaRepository.getMangaByUrlAndSourceId(url, sourceId)
+    }
+
+    override suspend fun awaitId(url: String, sourceId: Long): Long? {
+        return await(url, sourceId)?.id
+    }
+    // SY <--
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetMangaBySource.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class GetMangaBySource(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(sourceId: Long): List<Manga> {
+        return mangaRepository.getMangaBySourceId(sourceId)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetMangaWithChapters.kt

@@ -0,0 +1,31 @@
+package eu.kanade.domain.manga.interactor
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import tachiyomi.domain.chapter.model.Chapter
+import tachiyomi.domain.chapter.repository.ChapterRepository
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaRepository
+
+class GetMangaWithChapters(
+    private val mangaRepository: MangaRepository,
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun subscribe(id: Long): Flow<Pair<Manga, List<Chapter>>> {
+        return combine(
+            mangaRepository.getMangaByIdAsFlow(id),
+            chapterRepository.getChapterByMangaIdAsFlow(id),
+        ) { manga, chapters ->
+            Pair(manga, chapters)
+        }
+    }
+
+    suspend fun awaitManga(id: Long): Manga {
+        return mangaRepository.getMangaById(id)
+    }
+
+    suspend fun awaitChapters(id: Long): List<Chapter> {
+        return chapterRepository.getChapterByMangaId(id)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetMergedManga.kt

@@ -0,0 +1,25 @@
+package eu.kanade.domain.manga.interactor
+
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaMergeRepository
+
+class GetMergedManga(
+    private val mangaMergeRepository: MangaMergeRepository,
+) {
+
+    suspend fun await(): List<Manga> {
+        return try {
+            mangaMergeRepository.getMergedManga()
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+
+    suspend fun subscribe(): Flow<List<Manga>> {
+        return mangaMergeRepository.subscribeMergedManga()
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetMergedMangaById.kt

@@ -0,0 +1,25 @@
+package eu.kanade.domain.manga.interactor
+
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaMergeRepository
+
+class GetMergedMangaById(
+    private val mangaMergeRepository: MangaMergeRepository,
+) {
+
+    suspend fun await(id: Long): List<Manga> {
+        return try {
+            mangaMergeRepository.getMergedMangaById(id)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+
+    suspend fun subscribe(id: Long): Flow<List<Manga>> {
+        return mangaMergeRepository.subscribeMergedMangaById(id)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetMergedMangaForDownloading.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.manga.interactor
+
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaMergeRepository
+
+class GetMergedMangaForDownloading(
+    private val mangaMergeRepository: MangaMergeRepository,
+) {
+
+    suspend fun await(mergeId: Long): List<Manga> {
+        return mangaMergeRepository.getMergeMangaForDownloading(mergeId)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetMergedReferencesById.kt

@@ -0,0 +1,25 @@
+package eu.kanade.domain.manga.interactor
+
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+import tachiyomi.core.util.system.logcat
+import tachiyomi.domain.manga.model.MergedMangaReference
+import tachiyomi.domain.manga.repository.MangaMergeRepository
+
+class GetMergedReferencesById(
+    private val mangaMergeRepository: MangaMergeRepository,
+) {
+
+    suspend fun await(id: Long): List<MergedMangaReference> {
+        return try {
+            mangaMergeRepository.getReferencesById(id)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+
+    suspend fun subscribe(id: Long): Flow<List<MergedMangaReference>> {
+        return mangaMergeRepository.subscribeReferencesById(id)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetPagePreviews.kt

@@ -0,0 +1,52 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
+import eu.kanade.domain.chapter.model.toSChapter
+import eu.kanade.domain.manga.model.PagePreview
+import eu.kanade.domain.manga.model.toSManga
+import eu.kanade.tachiyomi.data.cache.PagePreviewCache
+import eu.kanade.tachiyomi.source.PagePreviewSource
+import eu.kanade.tachiyomi.source.Source
+import exh.source.getMainSource
+import tachiyomi.domain.manga.model.Manga
+
+class GetPagePreviews(
+    private val pagePreviewCache: PagePreviewCache,
+    private val getChapters: GetChapterByMangaId,
+) {
+
+    suspend fun await(manga: Manga, source: Source, page: Int): Result {
+        @Suppress("NAME_SHADOWING")
+        val source = source.getMainSource<PagePreviewSource>() ?: return Result.Unused
+        val chapters = getChapters.await(manga.id).sortedByDescending { it.sourceOrder }
+        val chapterIds = chapters.map { it.id }
+        return try {
+            val pagePreviews = try {
+                pagePreviewCache.getPageListFromCache(manga, chapterIds, page)
+            } catch (e: Exception) {
+                source.getPagePreviewList(manga.toSManga(), chapters.map { it.toSChapter() }, page).also {
+                    pagePreviewCache.putPageListToCache(manga, chapterIds, it)
+                }
+            }
+            Result.Success(
+                pagePreviews.pagePreviews.map {
+                    PagePreview(it.index, it.imageUrl, source.id)
+                },
+                pagePreviews.hasNextPage,
+                pagePreviews.pagePreviewPages,
+            )
+        } catch (e: Exception) {
+            Result.Error(e)
+        }
+    }
+
+    sealed class Result {
+        object Unused : Result()
+        data class Success(
+            val pagePreviews: List<PagePreview>,
+            val hasNextPage: Boolean,
+            val pageCount: Int?,
+        ) : Result()
+        data class Error(val error: Throwable) : Result()
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetSearchMetadata.kt

@@ -0,0 +1,17 @@
+package eu.kanade.domain.manga.interactor
+
+import exh.metadata.sql.models.SearchMetadata
+import tachiyomi.domain.manga.repository.MangaMetadataRepository
+
+class GetSearchMetadata(
+    private val mangaMetadataRepository: MangaMetadataRepository,
+) {
+
+    suspend fun await(mangaId: Long): SearchMetadata? {
+        return mangaMetadataRepository.getMetadataById(mangaId)
+    }
+
+    suspend fun await(): List<SearchMetadata> {
+        return mangaMetadataRepository.getSearchMetadata()
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetSearchTags.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.manga.interactor
+
+import exh.metadata.sql.models.SearchTag
+import tachiyomi.domain.manga.repository.MangaMetadataRepository
+
+class GetSearchTags(
+    private val mangaMetadataRepository: MangaMetadataRepository,
+) {
+
+    suspend fun await(mangaId: Long): List<SearchTag> {
+        return mangaMetadataRepository.getTagsById(mangaId)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetSearchTitles.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.manga.interactor
+
+import exh.metadata.sql.models.SearchTitle
+import tachiyomi.domain.manga.repository.MangaMetadataRepository
+
+class GetSearchTitles(
+    private val mangaMetadataRepository: MangaMetadataRepository,
+) {
+
+    suspend fun await(mangaId: Long): List<SearchTitle> {
+        return mangaMetadataRepository.getTitlesById(mangaId)
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/GetSortTag.kt

@@ -0,0 +1,29 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.domain.library.service.LibraryPreferences
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+class GetSortTag(private val preferences: LibraryPreferences) {
+
+    fun subscribe(): Flow<List<String>> {
+        return preferences.sortTagsForLibrary().changes()
+            .map(::mapSortTags)
+    }
+
+    fun await() = getSortTags(preferences).let(::mapSortTags)
+
+    companion object {
+        fun getSortTags(preferences: LibraryPreferences) = preferences.sortTagsForLibrary().get()
+
+        fun mapSortTags(tags: Set<String>) = tags.mapNotNull {
+            val index = it.indexOf('|')
+            if (index != -1) {
+                (it.substring(0, index).toIntOrNull() ?: return@mapNotNull null) to it.substring(index + 1)
+            } else {
+                null
+            }
+        }
+            .sortedBy { it.first }.map { it.second }
+    }
+}