use snackbar instead because toasts are dumb

closes #2503

.github/ISSUE_TEMPLATE/bug-issue.yml

@@ -1,61 +0,0 @@
-name: 🐞 Bug report
-description: Create a new bug report.
-title: 'bug: <title>'
-labels: [bug]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        # ReVanced Manager bug report
-
-        Please check for existing issues [here](https://github.com/revanced/revanced-manager/labels/bug) before creating a new one.
-  - type: textarea
-    attributes:
-      label: Bug description
-      description: |
-        - Describe your bug in detail
-        - Add steps to reproduce the bug if possible (Step 1. Download some files. Step 2. ...)
-        - Add images and videos if possible
-        - List selected patches if applicable
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Version of ReVanced Manager and version & name of application you tried to patch
-    validations:
-      required: true
-  - type: dropdown
-    attributes:
-      label: Installation type
-      options:
-        - Non-root
-        - Root
-    validations:
-      required: false
-  - type: textarea
-    attributes:
-      label: Device logs
-      description: Export logs in ReVanced Manager settings.
-      render: shell
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Patcher logs
-      description: Export logs in "Patcher" screen.
-      render: shell
-    validations:
-      required: false
-  - type: checkboxes
-    attributes:
-      label: Acknowledgements
-      description: Your issue will be closed if you don't follow the checklist below!
-      options:
-        - label: This request is not a duplicate of an existing issue.
-          required: true
-        - label: I have chosen an appropriate title.
-          required: true
-        - label: All requested information has been provided properly.
-          required: true
-        - label: The issue is solely related to the ReVanced Manager
-          required: true

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,109 @@
+name: 🐞 Bug report
+description: Report a bug or an issue.
+title: 'bug: '
+labels: ['Bug report']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        <p align="center">
+          <picture>
+            <source
+              width="256px"
+              media="(prefers-color-scheme: dark)"
+              srcset="https://raw.githubusercontent.com/revanced/revanced-manager/main/assets/revanced-headline/revanced-headline-vertical-dark.svg"
+            >
+            <img 
+              width="256px"
+              src="https://raw.githubusercontent.com/revanced/revanced-manager/main/assets/revanced-headline/revanced-headline-vertical-light.svg"
+            >
+          </picture>
+          <br>
+          <a href="https://revanced.app/">
+             <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/revanced/revanced-manager/main/assets/revanced-logo/revanced-logo.svg" />
+                 <img height="24px" src="https://raw.githubusercontent.com/revanced/revanced-manager/main/assets/revanced-logo/revanced-logo.svg" />
+             </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://github.com/ReVanced">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://i.ibb.co/dMMmCrW/Git-Hub-Mark.png" />
+                   <img height="24px" src="https://i.ibb.co/9wV3HGF/Git-Hub-Mark-Light.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="http://revanced.app/discord">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+                   <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://reddit.com/r/revancedapp">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+                   <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://t.me/app_revanced">
+              <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+                 <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+              </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://x.com/revancedapp">
+              <picture>
+                 <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/93124920/270180600-7c1b38bf-889b-4d68-bd5e-b9d86f91421a.png">
+                 <img height="24px" src="https://user-images.githubusercontent.com/93124920/270108715-d80743fa-b330-4809-b1e6-79fbdc60d09c.png" />
+              </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://www.youtube.com/@ReVanced">
+              <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+                 <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+             </picture>
+           </a>
+           <br>
+           <br>
+           Continuing the legacy of Vanced
+        </p>
+
+        # ReVanced Manager bug report
+
+        Before creating a new bug report, please keep the following in mind:
+
+        - **Do not submit a duplicate bug report**: Search for existing bug reports [here](https://github.com/ReVanced/revanced-manager/issues?q=label%3A%22Bug+report%22).
+        - **Review the contribution guidelines**: Make sure your bug report adheres to it. You can find the guidelines [here](https://github.com/ReVanced/revanced-manager/blob/main/CONTRIBUTING.md).
+        - **Do not use the issue page for support**: If you need help or have questions, check out other platforms on [revanced.app](https://revanced.app).
+  - type: textarea
+    attributes:
+      label: Bug description
+      description: |
+        - Describe your bug in detail
+        - Add steps to reproduce the bug if possible (Step 1. ... Step 2. ...)
+        - Add images and videos if possible
+        - List used patches, downloader and settings if applicable
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Patch logs
+      description: Patch logs can be exported by clicking on the "Logs" button in the "Patcher" screen, when patching finishes.
+      render: shell
+  - type: textarea
+    attributes:
+      label: Debug logs
+      description: Debug logs can be exported by clicking on  "Export debug logs" in "Settings" > "Advanced".
+    validations:
+      required: true
+  - type: checkboxes
+    attributes:
+      label: Acknowledgements
+      description: Your bug report will be closed if you don't follow the checklist below.
+      options:
+        - label: I have checked all open and closed bug reports and this is not a duplicate.
+          required: true
+        - label: I have chosen an appropriate title.
+          required: true
+        - label: All requested information has been provided properly.
+          required: true
+        - label: The bug is only related to ReVanced Manager.
+          required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +1,5 @@
-blank_issues_enabled: false
+blank_issues_enabled: false
+contact_links:
+  - name: 🗨 Discussions
+    url: https://github.com/revanced/revanced-suggestions/discussions
+    about: Have something unspecific to ReVanced Manager in mind? Search for or start a new discussion!

.github/ISSUE_TEMPLATE/feature-issue.yml

@@ -1,42 +0,0 @@
-name: ⭐ Feature request
-description: Create a new feature request.
-title: 'feat: <title>'
-labels: [feature request]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        # ReVanced Manager feature request
-
-        Please check for existing feature requests [here](https://github.com/revanced/revanced-manager/labels/bug) before creating a new one.
-  - type: textarea
-    attributes:
-      label: Feature description
-      description: Describe your feature in detail.
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Motivation
-      description: Explain why the lack of it is a problem.
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: Additional context
-      description: In case there is something else you want to add.
-    validations:
-      required: false
-  - type: checkboxes
-    attributes:
-      label: Acknowledgements
-      description: Your issue will be closed if you don't follow the checklist below!
-      options:
-        - label: This request is not a duplicate of an existing issue.
-          required: true
-        - label: I have chosen an appropriate title.
-          required: true
-        - label: All requested information has been provided properly.
-          required: true
-        - label: The issue is solely related to the ReVanced Manager
-          required: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,103 @@
+body:
+  - type: markdown
+    attributes:
+      value: |
+        <p align="center">
+          <picture>
+            <source
+              width="256px"
+              media="(prefers-color-scheme: dark)"
+              srcset="https://raw.githubusercontent.com/revanced/revanced-manager/main/assets/revanced-headline/revanced-headline-vertical-dark.svg"
+            >
+            <img 
+              width="256px"
+              src="https://raw.githubusercontent.com/revanced/revanced-manager/main/assets/revanced-headline/revanced-headline-vertical-light.svg"
+            >
+          </picture>
+          <br>
+          <a href="https://revanced.app/">
+             <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/revanced/revanced-manager/main/assets/revanced-logo/revanced-logo.svg" />
+                 <img height="24px" src="https://raw.githubusercontent.com/revanced/revanced-manager/main/assets/revanced-logo/revanced-logo.svg" />
+             </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://github.com/ReVanced">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://i.ibb.co/dMMmCrW/Git-Hub-Mark.png" />
+                   <img height="24px" src="https://i.ibb.co/9wV3HGF/Git-Hub-Mark-Light.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="http://revanced.app/discord">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+                   <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://reddit.com/r/revancedapp">
+               <picture>
+                   <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+                   <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+               </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://t.me/app_revanced">
+              <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+                 <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+              </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://x.com/revancedapp">
+              <picture>
+                 <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/93124920/270180600-7c1b38bf-889b-4d68-bd5e-b9d86f91421a.png">
+                 <img height="24px" src="https://user-images.githubusercontent.com/93124920/270108715-d80743fa-b330-4809-b1e6-79fbdc60d09c.png" />
+              </picture>
+           </a>&nbsp;&nbsp;&nbsp;
+           <a href="https://www.youtube.com/@ReVanced">
+              <picture>
+                 <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+                 <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+             </picture>
+           </a>
+           <br>
+           <br>
+           Continuing the legacy of Vanced
+        </p>
+
+        # ReVanced Manager feature request
+
+        Before creating a new feature request, please keep the following in mind:
+
+        - **Do not submit a duplicate feature request**: Search for existing feature requests [here](https://github.com/ReVanced/revanced-manager/issues?q=label%3A%22Feature+request%22).
+        - **Review the contribution guidelines**: Make sure your feature request adheres to it. You can find the guidelines [here](https://github.com/ReVanced/revanced-manager/blob/main/CONTRIBUTING.md).
+        - **Do not use the issue page for support**: If you need help or have questions, check out other platforms on [revanced.app](https://revanced.app).
+  - type: textarea
+    attributes:
+      label: Feature description
+      description: |
+        - Describe your feature in detail
+        - Add images, videos, links, examples, references, etc. if possible
+  - type: textarea
+    attributes:
+      label: Motivation
+      description: |
+        A strong motivation is necessary for a feature request to be considered.
+        
+        - Why should this feature be implemented? 
+        - What is the explicit use case?
+        - What are the benefits?
+        - What makes this feature important?
+    validations:
+      required: true
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Your feature request will be closed if you don't follow the checklist below.
+      options:
+        - label: I have checked all open and closed feature requests and this is not a duplicate
+          required: true
+        - label: I have chosen an appropriate title.
+          required: true
+        - label: All requested information has been provided properly.
+          required: true
+        - label: The feature request is only related to ReVanced Manager.
+          required: true

.github/config.yaml

@@ -1,2 +1,2 @@
 firstPRMergeComment: >
-  ❤️ Thank you for contributing to ReVanced Manager. Join us on [Discord](https://revanced.app/discord) if you want to receive a contributor role.
+  Thank you for contributing to ReVanced. Join us on [Discord](https://revanced.app/discord) to receive a role for your contribution.

.github/workflows/build_pull_request.yml

@@ -0,0 +1,25 @@
+name: Build pull request
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches:
+      - dev
+
+jobs:
+  release:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Cache Gradle
+        uses: burrunan/gradle-cache-action@v1
+
+      - name: Build
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: ./gradlew build --no-daemon

.github/workflows/open_pull_request.yml

@@ -0,0 +1,26 @@
+name: Open a PR to main
+
+on:
+  push:
+    branches:
+      - dev
+  workflow_dispatch:
+
+env:
+  MESSAGE: Merge branch `${{ github.head_ref || github.ref_name }}` to `main`
+
+jobs:
+  pull-request:
+    name: Open pull request
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Open pull request
+        uses: repo-sync/pull-request@v2
+        with:
+          destination_branch: 'main'
+          pr_title: 'chore: ${{ env.MESSAGE }}'
+          pr_body: 'This pull request will ${{ env.MESSAGE }}.'
+          pr_draft: true

.github/workflows/pr-build.yml

@@ -1,40 +0,0 @@
-name: Build pull request
-
-on:
-  pull_request:
-    paths:
-      - ".github/workflows/pr-build.yml"
-      - "app/**"
-      - "gradle/**"
-      - "*.properties"
-      - ".kts"
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Get commit hash
-        id: get_commit_hash
-        run: echo "hash=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          java-version: '17'
-          distribution: 'temurin'
-
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2
-
-      - name: Build with Gradle
-        run: ./gradlew assembleRelease --no-daemon -PnoProguard -Psuffix=${{ steps.get_commit_hash.outputs.hash }}
-
-      - name: Upload build
-        uses: actions/upload-artifact@v3
-        with:
-          name: revanced-manager-${{ steps.get_commit_hash.outputs.hash }}
-          path: app/build/outputs/apk/release/*.apk

.github/workflows/release-build.yml

@@ -1,52 +0,0 @@
-name: Release Build
-
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - main
-      - dev
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          java-version: '17'
-          distribution: 'temurin'
-
-      - name: Set up Node.js 20
-        uses: actions/setup-node@v2
-        with:
-          node-version: '20'
-
-      - name: Cache Node modules
-        uses: actions/cache@v3
-        with:
-          path: |
-            node_modules
-          key: npm-${{ hashFiles('package-lock.json') }}
-
-      - name: Setup semantic-release
-        run: npm install
-
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2
-        with:
-          cache-disabled: true
-
-      - name: Build with Gradle
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          signingKey: "keystore.jks"
-          keyStorePassword: ${{ secrets.SIGNING_KEYSTORE_PASSWORD }}
-          keyAlias: ${{ secrets.SIGNING_KEY_ALIAS }}
-          keyPassword: ${{ secrets.SIGNING_KEY_PASSWORD }}
-        run: |
-          echo "${{ secrets.SIGNING_KEYSTORE }}" | base64 --decode > app/keystore.jks
-          npx semantic-release

.github/workflows/release.yml

@@ -0,0 +1,64 @@
+name: Release
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+      - dev
+
+jobs:
+  release:
+    name: Release
+    permissions:
+      contents: write
+      id-token: write
+      attestations: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Cache Gradle
+        uses: burrunan/gradle-cache-action@v1
+
+      - name: Build
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: ./gradlew assembleRelease
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "lts/*"
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Setup keystore
+        run: |
+          echo "${{ secrets.KEYSTORE }}" | base64 --decode > "app/keystore.jks"
+
+      - name: Semantic Release
+        uses: cycjimmy/semantic-release-action@v4
+        id: semantic
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
+          KEYSTORE_ENTRY_ALIAS: ${{ secrets.KEYSTORE_ENTRY_ALIAS }}
+          KEYSTORE_ENTRY_PASSWORD: ${{ secrets.KEYSTORE_ENTRY_PASSWORD }}
+
+      - name: Attest
+        if: steps.semantic.outputs.new_release_published == 'true'
+        uses: actions/attest-build-provenance@v2
+        with:
+          subject-path: build/app/outputs/apk/release/revanced-manager-*.apk

.github/workflows/update_documentation.yml

@@ -11,9 +11,9 @@ jobs:
     name: Dispatch event to documentation repository
     if: github.ref == 'refs/heads/main'
     steps:
-      - uses: peter-evans/repository-dispatch@v2
+      - uses: peter-evans/repository-dispatch@v3
         with:
           token: ${{ secrets.DOCUMENTATION_REPO_ACCESS_TOKEN  }}
           repository: revanced/revanced-documentation
           event-type: update-documentation
-          client-payload: '{"repo": "${{ github.event.repository.name }}", "ref": "${{ github.ref }}"}'
+          client-payload: '{"repo": "${{ github.event.repository.name }}", "ref": "${{ github.ref }}"}'

.gitignore

@@ -8,4 +8,5 @@
 .externalNativeBuild
 .cxx
 local.properties
-/node_modules
+
+.kotlin/

.releaserc

@@ -1,47 +0,0 @@
-{
-  "branches": [
-    "main",
-    {
-      "name": "dev",
-      "prerelease": true
-    }
-  ],
-  "plugins": [
-    [
-      "@semantic-release/commit-analyzer", {
-        "releaseRules": [
-          { "type": "build", "scope": "Needs bump", "release": "patch" }
-        ]
-      }
-    ],
-    "@semantic-release/changelog",
-    "@semantic-release/release-notes-generator",
-    "gradle-semantic-release-plugin",
-    [
-      "@semantic-release/git",
-      {
-        "assets": [
-          "gradle.properties"
-        ]
-      }
-    ],
-    [
-      "@semantic-release/github",
-      {
-        "assets": [
-          {
-            "path": "app/build/outputs/apk/release/revanced-manager*.apk"
-          }
-        ],
-        "successComment": false
-      }
-    ],
-    [
-      "@saithodev/semantic-release-backmerge",
-      {
-        "backmergeBranches": [{"from": "main", "to": "dev"}],
-        "clearWorkspace": true
-      }
-    ]
-  ]
-}

CONTRIBUTING.md

@@ -13,8 +13,8 @@
   <br>
   <a href="https://revanced.app/">
        <picture>
-           <source height="24px" media="(prefers-color-scheme: dark)" srcset="assets/revanced-logo/revanced-logo-round.svg" />
-           <img height="24px" src="assets/revanced-logo/revanced-logo-round.svg" />
+           <source height="24px" media="(prefers-color-scheme: dark)" srcset="assets/revanced-logo/revanced-logo.svg" />
+           <img height="24px" src="assets/revanced-logo/revanced-logo.svg" />
        </picture>
    </a>&nbsp;&nbsp;&nbsp;
    <a href="https://github.com/ReVanced">
@@ -58,21 +58,46 @@
    Continuing the legacy of Vanced
 </p>
 
-# 🔒 Security Policy
+# 👋 Contribution guidelines
 
-This document describes how to report security vulnerabilities for ReVanced Manager.
+This document describes how to contribute to ReVanced Manager.
 
-## 🚨 Reporting a Vulnerability
+## 📖 Resources to help you get started
 
-Please open an issue in our [advisory tracker](https://github.com/ReVanced/revanced-manager/security/advisories/new) or reach out privately to us on [Discord](https://discord.gg/revanced).
+* The [documentation](/docs/README.md) provides steps to build ReVanced Manager from source
+* Our [backlog](https://github.com/orgs/ReVanced/projects/12) is where we keep track of what we're working on
+* [Issues](https://github.com/ReVanced/revanced-manager/issues) are where we keep track of bugs and feature requests
 
-If a vulnerability is confirmed and accepted, you can join our [Discord](https://discord.gg/revanced) server to receive a special contributor role.
+## 🙏 Submitting a feature request
 
-### ⏳ Supported Versions
+Features can be requested by opening an issue using the
+[Feature request issue template](https://github.com/ReVanced/revanced-manager/issues/new?assignees=&labels=Feature+request&projects=&template=feature_request.yml&title=feat%3A+).
 
-| Version | Branch      | Supported          |
-| ------- | ------------|------------------- |
-| v1.18.0 | main        | :white_check_mark: |
-| latest  | dev         | :white_check_mark: |
-| latest  | compose-dev | :white_check_mark: |
+> **Note**
+> Requests can be accepted or rejected at the discretion of maintainers of ReVanced Manager.
+> Good motivation has to be provided for a request to be accepted.
 
+## 🐞 Submitting a bug report
+
+If you encounter a bug while using ReVanced Manager, open an issue using the
+[Bug report issue template](https://github.com/ReVanced/revanced-manager/issues/new?assignees=&labels=Bug+report&projects=&template=bug_report.yml&title=bug%3A+).
+
+## 📝 How to contribute
+
+1. Before contributing, it is recommended to open an issue to discuss your change
+   with the maintainers of ReVanced Manager. This will help you determine whether your change is acceptable
+   and whether it is worth your time to implement it
+2. Development happens on the `dev` branch. Fork the repository and create your branch from `dev`
+3. Commit your changes
+4. Submit a pull request to the `dev` branch of the repository and reference issues
+   that your pull request closes in the description of your pull request
+5. Our team will review your pull request and provide feedback. Once your pull request is approved,
+   it will be merged into the `dev` branch and will be included in the next release of ReVanced Manager
+
+## 🤚 I want to contribute but don't know how to code
+
+Even if you don't know how to code, you can still contribute by
+translating ReVanced Manager on [Crowdin](https://translate.revanced.app/).
+
+❤️ Thank you for considering contributing to ReVanced Manager,  
+ReVanced

README.md

@@ -1,55 +1,104 @@
-# ReVanced Manager (Compose Rewrite)
+<p align="center">
+  <picture>
+    <source
+      width="256px"
+      media="(prefers-color-scheme: dark)"
+      srcset="assets/revanced-headline/revanced-headline-vertical-dark.svg"
+    >
+    <img 
+      width="256px"
+      src="assets/revanced-headline/revanced-headline-vertical-light.svg"
+    >
+  </picture>
+  <br>
+  <a href="https://revanced.app/">
+       <picture>
+           <source height="24px" media="(prefers-color-scheme: dark)" srcset="assets/revanced-logo/revanced-logo.svg" />
+           <img height="24px" src="assets/revanced-logo/revanced-logo.svg" />
+       </picture>
+   </a>&nbsp;&nbsp;&nbsp;
+   <a href="https://github.com/ReVanced">
+       <picture>
+           <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://i.ibb.co/dMMmCrW/Git-Hub-Mark.png" />
+           <img height="24px" src="https://i.ibb.co/9wV3HGF/Git-Hub-Mark-Light.png" />
+       </picture>
+   </a>&nbsp;&nbsp;&nbsp;
+   <a href="http://revanced.app/discord">
+       <picture>
+           <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+           <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032563-d4e084b7-244e-4358-af50-26bde6dd4996.png" />
+       </picture>
+   </a>&nbsp;&nbsp;&nbsp;
+   <a href="https://reddit.com/r/revancedapp">
+       <picture>
+           <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+           <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032351-9d9d5619-8ef7-470a-9eec-2744ece54553.png" />
+       </picture>
+   </a>&nbsp;&nbsp;&nbsp;
+   <a href="https://t.me/app_revanced">
+      <picture>
+         <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+         <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032213-faf25ab8-0bc3-4a94-a730-b524c96df124.png" />
+      </picture>
+   </a>&nbsp;&nbsp;&nbsp;
+   <a href="https://x.com/revancedapp">
+      <picture>
+         <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/93124920/270180600-7c1b38bf-889b-4d68-bd5e-b9d86f91421a.png">
+         <img height="24px" src="https://user-images.githubusercontent.com/93124920/270108715-d80743fa-b330-4809-b1e6-79fbdc60d09c.png" />
+      </picture>
+   </a>&nbsp;&nbsp;&nbsp;
+   <a href="https://www.youtube.com/@ReVanced">
+      <picture>
+         <source height="24px" media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+         <img height="24px" src="https://user-images.githubusercontent.com/13122796/178032714-c51c7492-0666-44ac-99c2-f003a695ab50.png" />
+     </picture>
+   </a>
+   <br>
+   <br>
+   Continuing the legacy of Vanced
+</p>
 
-[![GitHub license](https://img.shields.io/github/license/revanced/revanced-manager)](../../blob/main/LICENSE)
-[![GitHub last commit](https://img.shields.io/github/last-commit/revanced/revanced-manager/compose-dev)](https://github.com/ReVanced/revanced-manager/commits/compose-dev)
-[![GitHub commit activity](https://img.shields.io/github/commit-activity/w/revanced/revanced-manager/compose-dev)](https://github.com/ReVanced/revanced-manager/commits/compose-dev)
+# 💊 ReVanced Manager
 
-_(Yet another)_ rewrite of the ReVanced Manager using Kotlin and Jetpack Compose.
+![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/ReVanced/revanced-manager/release.yml)
+![GPLv3 License](https://img.shields.io/badge/License-GPL%20v3-yellow.svg)
 
-## Design system
+Application to use ReVanced on Android
 
-In this rewrite, we are adopting the latest Material Design principles and guidelines by using Material 3 and Material You.
+## ❓ About
 
-Material Design is a design system developed by Google that provides a unified visual language for building beautiful and consistent user interfaces across all platforms and devices. Material You is an extension of Material Design that provides even more customization options for users, making it possible for them to personalize their device and create a unique look and feel.
+ReVanced Manager is an application that uses [ReVanced Patcher](https://github.com/revanced/revanced-patcher) to patch Android apps.
 
-### Why Material 3?
+## 💪 Features
 
-* **Consistent design language**
-* **Improved accessibility**
-* **Better user experience**
+Some of the features ReVanced Manager provides are:
 
-By using Material 3 and Material You, we are ensuring that the app's user interface is consistent, customizable, accessible, and engaging for our users. This will help to improve the overall user experience and increase user satisfaction with the the manager.
-
-## Technology stack
-
-* Kotlin: Kotlin is a modern and concise programming language that is fully interoperable with Java and provides improved safety, readability, and maintainability compared to Java.
-* Jetpack Compose: Jetpack Compose is a modern UI toolkit for Android development that allows developers to build beautiful and performant user interfaces using declarative programming. It provides a unified and efficient way of building UI that is well-integrated with the Android framework.
-
-## Why Kotlin and Compose?
-
-* **Improved safety:** Kotlin provides improved safety compared to Java, which reduces the likelihood of common programming mistakes that can cause security vulnerabilities or crashes.
-* **Concise and readable code:** Kotlin's concise syntax and expressive type system make the code more readable, which makes it easier for developers to understand and maintain the codebase.
-* **Better performance:** Jetpack Compose uses the power of the Android framework to provide smooth and fast performance, which enhances the user experience.
-* **Modern and efficient UI development:** Jetpack Compose provides a modern and efficient way of building UI, which makes it easier for developers to create beautiful and performant user interfaces.
+- ⬇️ **Download**: Automatically download apps using the ReVanced Manager downloader plugin system
+- 💉 **Patch**: Select and apply patches to any Android app
+- 🛠️ **Customize**: Manage patches, apps, signing, themes, updates, and many more settings
 
 ## 🔽 Download
 
-You can obtain ReVanced Manager by downloading it from either [revanced.app/download](https://revanced.app/download) or [GitHub Releases](https://github.com/ReVanced/revanced-manager/releases)
+You can download the most recent version of ReVanced Manager at [revanced.app/download](https://revanced.app/download) or from [GitHub releases](https://github.com/ReVanced/revanced-manager/releases/latest).  
+Learn how to use ReVanced Manager by following the [documentation](/docs).
 
-## 📝 Prerequisites
+## 📚 Everything else
 
-For a list of prerequisites, refer to [docs/0_prerequisites.md](docs/0_prerequisites.md)
+### 📙 Contributing
 
-## 🔴 Issues
+Thank you for considering contributing to ReVanced Manager.
+You can find the contribution guidelines [here](CONTRIBUTING.md).
 
-For suggestions and bug reports, open an issue [here](https://github.com/revanced/revanced-manager/issues/new/choose).
+### 🛠️ Building
 
-## 🌐 Translation
+To build a ReVanced Manager, you can follow the [documentation](/docs).
 
-[![Crowdin](https://badges.crowdin.net/revanced/localized.svg)](https://crowdin.com/project/revanced)
+### 📄 Documentation
 
-We're accepting translations on [Crowdin](https://translate.revanced.app)
+You can find the documentation for ReVanced Manager [here](/docs).
 
-## 🛠️ Building Manager from source
+## ⚖️ License
 
-For instructions on how to build ReVanced Manager from source, refer to [docs/4_building.md](docs/4_building.md)
+ReVanced Manager is licensed under the GPLv3 license. Please see the [license file](LICENSE) for more information.
+[tl;dr](https://www.tldrlegal.com/license/gnu-general-public-license-v3-gpl-3) you may copy, distribute and modify ReVanced Manager as long as you track changes/dates in source files.
+Any modifications to ReVanced Manager must also be made available under the GPL, along with build & install instructions.

app/build.gradle.kts

@@ -1,68 +1,63 @@
+import kotlin.random.Random
+
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.serialization)
+    alias(libs.plugins.kotlin.parcelize)
+    alias(libs.plugins.compose.compiler)
     alias(libs.plugins.devtools)
     alias(libs.plugins.about.libraries)
-    id("kotlin-parcelize")
-    kotlin("plugin.serialization") version "1.9.10"
 }
 
-val (majorVersion, minorVersion, patchVersion, devVersion) = "${project.version}.0".replace("-dev","").split(".")
 android {
     namespace = "app.revanced.manager"
-    compileSdk = 34
-    buildToolsVersion = "34.0.0"
+    compileSdk = 35
+    buildToolsVersion = "35.0.1"
 
     defaultConfig {
         applicationId = "app.revanced.manager"
         minSdk = 26
-        targetSdk = 34
-        versionName = project.version.toString()
-        versionCode = (majorVersion.toInt() * 100000000) + (minorVersion.toInt() * 100000) + (patchVersion.toInt() * 100) + devVersion.toInt()
-        resourceConfigurations.addAll(listOf(
-            "en",
-        ))
+        targetSdk = 35
+        versionCode = 1
+        versionName = "0.0.1"
         vectorDrawables.useSupportLibrary = true
     }
 
     buildTypes {
         debug {
             applicationIdSuffix = ".debug"
-            resValue("string", "app_name", "ReVanced Manager Debug")
+            resValue("string", "app_name", "ReVanced Manager (Debug)")
+            isPseudoLocalesEnabled = true
+
+            buildConfigField("long", "BUILD_ID", "${Random.nextLong()}L")
         }
 
         release {
-            if (System.getenv("signingKey") != null) {
-                signingConfigs {
-                    create("release") {
-                        storeFile = file(System.getenv("signingKey"))
-                        storePassword = System.getenv("keyStorePassword")
-                        keyAlias = System.getenv("keyAlias")
-                        keyPassword = System.getenv("keyPassword")
-                    }
-                }
-                signingConfig = signingConfigs.getByName("release")
-            } else {
-                applicationIdSuffix = ".debug"
-                resValue("string", "app_name", "ReVanced Manager Debug")
-                signingConfig = signingConfigs.getByName("debug")
-            }
             if (!project.hasProperty("noProguard")) {
                 isMinifyEnabled = true
                 isShrinkResources = true
                 proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
             }
-            var suffix = "v${project.version}"
-            if (project.hasProperty("suffix")) {
-                suffix = "${project.property("suffix")}"
-            }
-            applicationVariants.all {
-                this.outputs
-                    .map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
-                    .forEach { output ->
-                        output.outputFileName = "revanced-manager-${suffix}.apk"
-                    }
+
+            val keystoreFile = file("keystore.jks")
+
+            if (project.hasProperty("signAsDebug") || !keystoreFile.exists()) {
+                applicationIdSuffix = ".debug_signed"
+                resValue("string", "app_name", "ReVanced Manager (Debug signed)")
+                signingConfig = signingConfigs.getByName("debug")
+
+                isPseudoLocalesEnabled = true
+            } else {
+                signingConfig = signingConfigs.create("release") {
+                    storeFile = keystoreFile
+                    storePassword = System.getenv("KEYSTORE_PASSWORD")
+                    keyAlias = System.getenv("KEYSTORE_ENTRY_ALIAS")
+                    keyPassword = System.getenv("KEYSTORE_ENTRY_PASSWORD")
+                }
             }
+
+            buildConfigField("long", "BUILD_ID", "0L")
         }
     }
 
@@ -77,15 +72,17 @@ android {
     }
 
     packaging {
-        resources.excludes.addAll(listOf(
-            "/prebuilt/**",
-            "META-INF/DEPENDENCIES",
-            "META-INF/**.version",
-            "DebugProbesKt.bin",
-            "kotlin-tooling-metadata.json",
-            "org/bouncycastle/pqc/**.properties",
-            "org/bouncycastle/x509/**.properties",
-        ))
+        resources.excludes.addAll(
+            listOf(
+                "/prebuilt/**",
+                "META-INF/DEPENDENCIES",
+                "META-INF/**.version",
+                "DebugProbesKt.bin",
+                "kotlin-tooling-metadata.json",
+                "org/bouncycastle/pqc/**.properties",
+                "org/bouncycastle/x509/**.properties",
+            )
+        )
         jniLibs {
             useLegacyPackaging = true
         }
@@ -99,23 +96,30 @@ android {
         jvmTarget = "17"
     }
 
-    buildFeatures.compose = true
-    buildFeatures.aidl = true
-    buildFeatures.buildConfig=true
+    buildFeatures {
+        compose = true
+        aidl = true
+        buildConfig = true
+    }
 
-    composeOptions.kotlinCompilerExtensionVersion = "1.5.3"
+    android {
+        androidResources {
+            generateLocaleConfig = true
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path = file("src/main/cpp/CMakeLists.txt")
+            version = "3.22.1"
+        }
+    }
 }
 
 kotlin {
     jvmToolchain(17)
 }
 
-tasks.register("publish") {
-    group = "Build"
-    description = "Assemble main outputs for all the variants."
-    dependsOn("assembleRelease")
-}
-
 dependencies {
 
     // AndroidX Core
@@ -123,10 +127,10 @@ dependencies {
     implementation(libs.runtime.ktx)
     implementation(libs.runtime.compose)
     implementation(libs.splash.screen)
-    implementation(libs.compose.activity)
-    implementation(libs.paging.common.ktx)
+    implementation(libs.activity.compose)
     implementation(libs.work.runtime.ktx)
     implementation(libs.preferences.datastore)
+    implementation(libs.appcompat)
 
     // Compose
     implementation(platform(libs.compose.bom))
@@ -136,11 +140,13 @@ dependencies {
     implementation(libs.compose.livedata)
     implementation(libs.compose.material.icons.extended)
     implementation(libs.compose.material3)
+    implementation(libs.navigation.compose)
 
     // Accompanist
     implementation(libs.accompanist.drawablepainter)
-    implementation(libs.accompanist.webview)
-    implementation(libs.accompanist.placeholder)
+
+    // Placeholder
+    implementation(libs.placeholder.material3)
 
     // HTML Scraper
     implementation(libs.skrapeit.dsl)
@@ -153,6 +159,7 @@ dependencies {
     // KotlinX
     implementation(libs.kotlinx.serialization.json)
     implementation(libs.kotlinx.collection.immutable)
+    implementation(libs.kotlinx.datetime)
 
     // Room
     implementation(libs.room.runtime)
@@ -164,6 +171,16 @@ dependencies {
     implementation(libs.revanced.patcher)
     implementation(libs.revanced.library)
 
+    // Downloader plugins
+    implementation(libs.plugin.api)
+
+    // Native processes
+    implementation(libs.kotlin.process)
+
+    // HiddenAPI
+    compileOnly(libs.hidden.api.stub)
+
+    // LibSU
     implementation(libs.libsu.core)
     implementation(libs.libsu.service)
     implementation(libs.libsu.nio)
@@ -171,11 +188,9 @@ dependencies {
     // Koin
     implementation(libs.koin.android)
     implementation(libs.koin.compose)
+    implementation(libs.koin.compose.navigation)
     implementation(libs.koin.workmanager)
 
-    // Compose Navigation
-    implementation(libs.reimagined.navigation)
-
     // Licenses
     implementation(libs.about.libraries)
 
@@ -194,4 +209,14 @@ dependencies {
 
     // Scrollbars
     implementation(libs.scrollbars)
+
+    // EnumUtil
+    implementation(libs.enumutil)
+    ksp(libs.enumutil.ksp)
+
+    // Reorderable lists
+    implementation(libs.reorderable)
+
+    // Compose Icons
+    implementation(libs.compose.icons.fontawesome)
 }

app/proguard-rules.pro

@@ -26,6 +26,10 @@
     kotlinx.serialization.KSerializer serializer(...);
 }
 
+# This required for the process runtime.
+-keep class app.revanced.manager.patcher.runtime.process.* {
+  *;
+}
 # Required for the patcher to function correctly
 -keep class app.revanced.patcher.** {
   *;
@@ -45,6 +49,11 @@
 -keep class com.android.** {
   *;
 }
+-keep class app.revanced.manager.plugin.** {
+  *;
+}
+
+-dontwarn com.google.auto.value.**
 -dontwarn java.awt.**
 -dontwarn javax.**
 -dontwarn org.slf4j.**

app/schemas/app.revanced.manager.data.room.AppDatabase/1.json

@@ -2,11 +2,11 @@
   "formatVersion": 1,
   "database": {
     "version": 1,
-    "identityHash": "802fa2fda94b930bf0ebb85d195f1022",
+    "identityHash": "d0119047505da435972c5247181de675",
     "entities": [
       {
         "tableName": "patch_bundles",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER NOT NULL, `name` TEXT NOT NULL, `source` TEXT NOT NULL, `auto_update` INTEGER NOT NULL, `version` TEXT, `integrations_version` TEXT, PRIMARY KEY(`uid`))",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER NOT NULL, `name` TEXT NOT NULL, `version` TEXT, `source` TEXT NOT NULL, `auto_update` INTEGER NOT NULL, PRIMARY KEY(`uid`))",
         "fields": [
           {
             "fieldPath": "uid",
@@ -20,6 +20,12 @@
             "affinity": "TEXT",
             "notNull": true
           },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "TEXT",
+            "notNull": false
+          },
           {
             "fieldPath": "source",
             "columnName": "source",
@@ -31,18 +37,6 @@
             "columnName": "auto_update",
             "affinity": "INTEGER",
             "notNull": true
-          },
-          {
-            "fieldPath": "versionInfo.patches",
-            "columnName": "version",
-            "affinity": "TEXT",
-            "notNull": false
-          },
-          {
-            "fieldPath": "versionInfo.integrations",
-            "columnName": "integrations_version",
-            "affinity": "TEXT",
-            "notNull": false
           }
         ],
         "primaryKey": {
@@ -51,17 +45,7 @@
             "uid"
           ]
         },
-        "indices": [
-          {
-            "name": "index_patch_bundles_name",
-            "unique": true,
-            "columnNames": [
-              "name"
-            ],
-            "orders": [],
-            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_patch_bundles_name` ON `${TABLE_NAME}` (`name`)"
-          }
-        ],
+        "indices": [],
         "foreignKeys": []
       },
       {
@@ -160,7 +144,7 @@
       },
       {
         "tableName": "downloaded_app",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `version` TEXT NOT NULL, `directory` TEXT NOT NULL, PRIMARY KEY(`package_name`, `version`))",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `version` TEXT NOT NULL, `directory` TEXT NOT NULL, `last_used` INTEGER NOT NULL, PRIMARY KEY(`package_name`, `version`))",
         "fields": [
           {
             "fieldPath": "packageName",
@@ -179,6 +163,12 @@
             "columnName": "directory",
             "affinity": "TEXT",
             "notNull": true
+          },
+          {
+            "fieldPath": "lastUsed",
+            "columnName": "last_used",
+            "affinity": "INTEGER",
+            "notNull": true
           }
         ],
         "primaryKey": {
@@ -231,7 +221,7 @@
       },
       {
         "tableName": "applied_patch",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `bundle` INTEGER NOT NULL, `patch_name` TEXT NOT NULL, PRIMARY KEY(`package_name`, `bundle`, `patch_name`), FOREIGN KEY(`package_name`) REFERENCES `installed_app`(`current_package_name`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`bundle`) REFERENCES `patch_bundles`(`uid`) ON UPDATE NO ACTION ON DELETE NO ACTION )",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `bundle` INTEGER NOT NULL, `patch_name` TEXT NOT NULL, PRIMARY KEY(`package_name`, `bundle`, `patch_name`), FOREIGN KEY(`package_name`) REFERENCES `installed_app`(`current_package_name`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`bundle`) REFERENCES `patch_bundles`(`uid`) ON UPDATE NO ACTION ON DELETE CASCADE )",
         "fields": [
           {
             "fieldPath": "packageName",
@@ -285,7 +275,7 @@
           },
           {
             "table": "patch_bundles",
-            "onDelete": "NO ACTION",
+            "onDelete": "CASCADE",
             "onUpdate": "NO ACTION",
             "columns": [
               "bundle"
@@ -402,12 +392,38 @@
             ]
           }
         ]
+      },
+      {
+        "tableName": "trusted_downloader_plugins",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `signature` BLOB NOT NULL, PRIMARY KEY(`package_name`))",
+        "fields": [
+          {
+            "fieldPath": "packageName",
+            "columnName": "package_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "signature",
+            "columnName": "signature",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "package_name"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
       }
     ],
     "views": [],
     "setupQueries": [
       "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '802fa2fda94b930bf0ebb85d195f1022')"
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'd0119047505da435972c5247181de675')"
     ]
   }
 }

app/src/main/AndroidManifest.xml

@@ -2,9 +2,16 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
-    <permission android:name="android.permission.QUERY_ALL_PACKAGES"
-        tools:ignore="ReservedSystemPermission" />
+    <permission
+        android:name="app.revanced.manager.permission.PLUGIN_HOST"
+        android:protectionLevel="signature"
+        android:label="@string/plugin_host_permission_label"
+        android:description="@string/plugin_host_permission_description"
+        />
 
+    <uses-permission android:name="app.revanced.manager.permission.PLUGIN_HOST" />
+    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"
+        tools:ignore="QueryAllPackagesPermission" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
@@ -17,12 +24,6 @@
         tools:ignore="ScopedStorage" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
 
-    <queries>
-        <intent>
-            <action android:name="android.intent.action.MAIN" />
-        </intent>
-    </queries>
-
     <application
         android:name=".ManagerApplication"
         android:allowBackup="true"
@@ -47,6 +48,8 @@
             </intent-filter>
         </activity>
 
+        <activity android:name=".plugin.downloader.webview.WebViewActivity" android:exported="false" android:theme="@style/Theme.WebViewActivity" />
+
         <service android:name=".service.InstallService" />
         <service android:name=".service.UninstallService" />
 

app/src/main/aidl/app/revanced/manager/patcher/runtime/process/IPatcherEvents.aidl

@@ -0,0 +1,11 @@
+// IPatcherEvents.aidl
+package app.revanced.manager.patcher.runtime.process;
+
+// Interface for sending events back to the main app process.
+oneway interface IPatcherEvents {
+    void log(String level, String msg);
+    void patchSucceeded();
+    void progress(String name, String state, String msg);
+    // The patching process has ended. The exceptionStackTrace is null if it finished successfully.
+    void finished(String exceptionStackTrace);
+}

app/src/main/aidl/app/revanced/manager/patcher/runtime/process/IPatcherProcess.aidl

@@ -0,0 +1,14 @@
+// IPatcherProcess.aidl
+package app.revanced.manager.patcher.runtime.process;
+
+import app.revanced.manager.patcher.runtime.process.Parameters;
+import app.revanced.manager.patcher.runtime.process.IPatcherEvents;
+
+interface IPatcherProcess {
+    // Returns BuildConfig.BUILD_ID, which is used to ensure the main app and runner process are running the same code.
+    long buildId();
+    // Makes the patcher process exit with code 0
+    oneway void exit();
+    // Starts patching.
+    oneway void start(in Parameters parameters, IPatcherEvents events);
+}

app/src/main/aidl/app/revanced/manager/patcher/runtime/process/Parameters.aidl

@@ -0,0 +1,4 @@
+// Parameters.aidl
+package app.revanced.manager.patcher.runtime.process;
+
+parcelable Parameters;

app/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,38 @@
+
+# For more information about using CMake with Android Studio, read the
+# documentation: https://d.android.com/studio/projects/add-native-code.html.
+# For more examples on how to use CMake, see https://github.com/android/ndk-samples.
+
+# Sets the minimum CMake version required for this project.
+cmake_minimum_required(VERSION 3.22.1)
+
+# Declares the project name. The project name can be accessed via ${ PROJECT_NAME},
+# Since this is the top level CMakeLists.txt, the project name is also accessible
+# with ${CMAKE_PROJECT_NAME} (both CMake variables are in-sync within the top level
+# build script scope).
+project("prop_override")
+
+# Creates and names a library, sets it as either STATIC
+# or SHARED, and provides the relative paths to its source code.
+# You can define multiple libraries, and CMake builds them for you.
+# Gradle automatically packages shared libraries with your APK.
+#
+# In this top level CMakeLists.txt, ${CMAKE_PROJECT_NAME} is used to define
+# the target library name; in the sub-module's CMakeLists.txt, ${PROJECT_NAME}
+# is preferred for the same purpose.
+#
+# In order to load a library into your app from Java/Kotlin, you must call
+# System.loadLibrary() and pass the name of the library defined here;
+# for GameActivity/NativeActivity derived applications, the same library name must be
+# used in the AndroidManifest.xml file.
+add_library(${CMAKE_PROJECT_NAME} SHARED
+    # List C/C++ source files with relative paths to this CMakeLists.txt.
+        prop_override.cpp)
+
+# Specifies libraries CMake should link to your target library. You
+# can link libraries from various origins, such as libraries defined in this
+# build script, prebuilt third-party libraries, or Android system libraries.
+target_link_libraries(${CMAKE_PROJECT_NAME}
+    # List libraries link to the target library
+    android
+    log)

app/src/main/cpp/prop_override.cpp

@@ -0,0 +1,62 @@
+// Library for overriding Android system properties via environment variables.
+//
+// Usage: LD_PRELOAD=prop_override.so PROP_dalvik.vm.heapsize=123M getprop dalvik.vm.heapsize
+// Output: 123M
+#include <string>
+#include <cstring>
+#include <cstdlib>
+#include <dlfcn.h>
+
+// Source: https://android.googlesource.com/platform/system/core/+/100b08a848d018eeb1caa5d5e7c7c2aaac65da15/libcutils/include/cutils/properties.h
+#define PROP_VALUE_MAX 92
+// This is the mangled name of "android::base::GetProperty".
+#define GET_PROPERTY_MANGLED_NAME "_ZN7android4base11GetPropertyERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_"
+
+extern "C" typedef int (*property_get_ptr)(const char *, char *, const char *);
+typedef std::string (*GetProperty_ptr)(const std::string &, const std::string &);
+
+char *GetPropOverride(const std::string &key) {
+    auto envKey = "PROP_" + key;
+
+    return getenv(envKey.c_str());
+}
+
+// See: https://android.googlesource.com/platform/system/core/+/100b08a848d018eeb1caa5d5e7c7c2aaac65da15/libcutils/properties.cpp
+extern "C" int property_get(const char *key, char *value, const char *default_value) {
+    auto replacement = GetPropOverride(std::string(key));
+    if (replacement) {
+        int len = strnlen(replacement, PROP_VALUE_MAX);
+
+        strncpy(value, replacement, len);
+        return len;
+    }
+
+    static property_get_ptr original = NULL;
+    if (!original) {
+        // Get the address of the original function.
+        original = reinterpret_cast<property_get_ptr>(dlsym(RTLD_NEXT, "property_get"));
+    }
+
+    return original(key, value, default_value);
+}
+
+// Defining android::base::GetProperty ourselves won't work because std::string has a slightly different "path" in the NDK version of the C++ standard library.
+// We can get around this by forcing the function to adopt a specific name using the asm keyword.
+std::string GetProperty(const std::string &, const std::string &) asm(GET_PROPERTY_MANGLED_NAME);
+
+
+// See: https://android.googlesource.com/platform/system/libbase/+/1a34bb67c4f3ba0a1ea6f4f20ac9fe117ba4fe64/properties.cpp
+// This isn't used for the properties we want to override, but property_get is deprecated so that could change in the future.
+std::string GetProperty(const std::string &key, const std::string &default_value) {
+    auto replacement = GetPropOverride(key);
+    if (replacement) {
+        return std::string(replacement);
+    }
+
+    static GetProperty_ptr original = NULL;
+    if (!original) {
+        original = reinterpret_cast<GetProperty_ptr>(dlsym(RTLD_NEXT, GET_PROPERTY_MANGLED_NAME));
+    }
+
+    return original(key, default_value);
+}

app/src/main/java/app/revanced/manager/MainActivity.kt

@@ -1,185 +1,336 @@
 package app.revanced.manager
 
+import android.content.ActivityNotFoundException
 import android.os.Bundle
+import android.os.Parcelable
 import androidx.activity.ComponentActivity
+import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.animation.ExperimentalAnimationApi
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
 import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Update
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.compose.ui.res.stringResource
+import androidx.compose.runtime.remember
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
-import app.revanced.manager.ui.component.AutoUpdatesDialog
-import app.revanced.manager.ui.destination.Destination
-import app.revanced.manager.ui.destination.SettingsDestination
+import androidx.core.view.WindowCompat
+import androidx.lifecycle.lifecycleScope
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavController
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.navigation
+import androidx.navigation.compose.rememberNavController
+import androidx.navigation.toRoute
+import app.revanced.manager.ui.model.navigation.AppSelector
+import app.revanced.manager.ui.model.navigation.ComplexParameter
+import app.revanced.manager.ui.model.navigation.Dashboard
+import app.revanced.manager.ui.model.navigation.InstalledApplicationInfo
+import app.revanced.manager.ui.model.navigation.Patcher
+import app.revanced.manager.ui.model.navigation.SelectedApplicationInfo
+import app.revanced.manager.ui.model.navigation.Settings
+import app.revanced.manager.ui.model.navigation.Update
 import app.revanced.manager.ui.screen.AppSelectorScreen
 import app.revanced.manager.ui.screen.DashboardScreen
 import app.revanced.manager.ui.screen.InstalledAppInfoScreen
 import app.revanced.manager.ui.screen.PatcherScreen
+import app.revanced.manager.ui.screen.PatchesSelectorScreen
+import app.revanced.manager.ui.screen.RequiredOptionsScreen
 import app.revanced.manager.ui.screen.SelectedAppInfoScreen
 import app.revanced.manager.ui.screen.SettingsScreen
-import app.revanced.manager.ui.screen.VersionSelectorScreen
+import app.revanced.manager.ui.screen.UpdateScreen
+import app.revanced.manager.ui.screen.settings.AboutSettingsScreen
+import app.revanced.manager.ui.screen.settings.AdvancedSettingsScreen
+import app.revanced.manager.ui.screen.settings.ContributorSettingsScreen
+import app.revanced.manager.ui.screen.settings.DeveloperSettingsScreen
+import app.revanced.manager.ui.screen.settings.DownloadsSettingsScreen
+import app.revanced.manager.ui.screen.settings.GeneralSettingsScreen
+import app.revanced.manager.ui.screen.settings.ImportExportSettingsScreen
+import app.revanced.manager.ui.screen.settings.LicensesSettingsScreen
+import app.revanced.manager.ui.screen.settings.update.ChangelogsSettingsScreen
+import app.revanced.manager.ui.screen.settings.update.UpdatesSettingsScreen
 import app.revanced.manager.ui.theme.ReVancedManagerTheme
 import app.revanced.manager.ui.theme.Theme
 import app.revanced.manager.ui.viewmodel.MainViewModel
 import app.revanced.manager.ui.viewmodel.SelectedAppInfoViewModel
-import dev.olshevski.navigation.reimagined.AnimatedNavHost
-import dev.olshevski.navigation.reimagined.NavBackHandler
-import dev.olshevski.navigation.reimagined.navigate
-import dev.olshevski.navigation.reimagined.pop
-import dev.olshevski.navigation.reimagined.popUpTo
-import dev.olshevski.navigation.reimagined.rememberNavController
+import app.revanced.manager.util.EventEffect
+import kotlinx.coroutines.launch
+import org.koin.androidx.compose.koinViewModel
+import org.koin.androidx.compose.navigation.koinNavViewModel
 import org.koin.core.parameter.parametersOf
-import org.koin.androidx.compose.getViewModel as getComposeViewModel
-import org.koin.androidx.viewmodel.ext.android.getViewModel as getAndroidViewModel
+import org.koin.androidx.viewmodel.ext.android.getViewModel as getActivityViewModel
 
 class MainActivity : ComponentActivity() {
     @ExperimentalAnimationApi
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
+        WindowCompat.setDecorFitsSystemWindows(window, false)
+        enableEdgeToEdge()
         installSplashScreen()
 
-        val vm: MainViewModel = getAndroidViewModel()
-
-        vm.importLegacySettings(this)
+        val vm: MainViewModel = getActivityViewModel()
 
         setContent {
+            val launcher = rememberLauncherForActivityResult(
+                ActivityResultContracts.StartActivityForResult(),
+                onResult = vm::applyLegacySettings
+            )
             val theme by vm.prefs.theme.getAsState()
             val dynamicColor by vm.prefs.dynamicColor.getAsState()
 
+            EventEffect(vm.legacyImportActivityFlow) {
+                try {
+                    launcher.launch(it)
+                } catch (_: ActivityNotFoundException) {
+                }
+            }
+
             ReVancedManagerTheme(
                 darkTheme = theme == Theme.SYSTEM && isSystemInDarkTheme() || theme == Theme.DARK,
                 dynamicColor = dynamicColor
             ) {
-                val navController =
-                    rememberNavController<Destination>(startDestination = Destination.Dashboard)
-
-                NavBackHandler(navController)
-
-                val firstLaunch by vm.prefs.firstLaunch.getAsState()
-
-                if (firstLaunch) AutoUpdatesDialog(vm::applyAutoUpdatePrefs)
-
-                vm.updatedManagerVersion?.let {
-                    AlertDialog(
-                        onDismissRequest = vm::dismissUpdateDialog,
-                        confirmButton = {
-                            TextButton(
-                                onClick = {
-                                    vm.dismissUpdateDialog()
-                                    navController.navigate(Destination.Settings(SettingsDestination.Update(false)))
-                                }
-                            ) {
-                                Text(stringResource(R.string.update))
-                            }
-                        },
-                        dismissButton = {
-                            TextButton(onClick = vm::dismissUpdateDialog) {
-                                Text(stringResource(R.string.dismiss_temporary))
-                            }
-                        },
-                        icon = { Icon(Icons.Outlined.Update, null) },
-                        title = { Text(stringResource(R.string.update_available_dialog_title)) },
-                        text = { Text(stringResource(R.string.update_available_dialog_description, it)) }
-                    )
-                }
-
-                AnimatedNavHost(
-                    controller = navController
-                ) { destination ->
-                    when (destination) {
-                        is Destination.Dashboard -> DashboardScreen(
-                            onSettingsClick = { navController.navigate(Destination.Settings()) },
-                            onAppSelectorClick = { navController.navigate(Destination.AppSelector) },
-                            onAppClick = { installedApp ->
-                                navController.navigate(
-                                    Destination.InstalledApplicationInfo(
-                                        installedApp
-                                    )
-                                )
-                            }
-                        )
-
-                        is Destination.InstalledApplicationInfo -> InstalledAppInfoScreen(
-                            onPatchClick = { packageName, patchSelection ->
-                                navController.navigate(
-                                    Destination.VersionSelector(
-                                        packageName,
-                                        patchSelection
-                                    )
-                                )
-                            },
-                            onBackClick = { navController.pop() },
-                            viewModel = getComposeViewModel { parametersOf(destination.installedApp) }
-                        )
-
-                        is Destination.Settings -> SettingsScreen(
-                            onBackClick = { navController.pop() },
-                            startDestination = destination.startDestination
-                        )
-
-                        is Destination.AppSelector -> AppSelectorScreen(
-                            onAppClick = { navController.navigate(Destination.VersionSelector(it)) },
-                            onStorageClick = {
-                                navController.navigate(
-                                    Destination.SelectedApplicationInfo(
-                                        it
-                                    )
-                                )
-                            },
-                            onBackClick = { navController.pop() }
-                        )
-
-                        is Destination.VersionSelector -> VersionSelectorScreen(
-                            onBackClick = { navController.pop() },
-                            onAppClick = { selectedApp ->
-                                navController.navigate(
-                                    Destination.SelectedApplicationInfo(
-                                        selectedApp,
-                                        destination.patchSelection,
-                                    )
-                                )
-                            },
-                            viewModel = getComposeViewModel {
-                                parametersOf(
-                                    destination.packageName,
-                                    destination.patchSelection
-                                )
-                            }
-                        )
-
-                        is Destination.SelectedApplicationInfo -> SelectedAppInfoScreen(
-                            onPatchClick = { app, patches, options ->
-                                navController.navigate(
-                                    Destination.Patcher(
-                                        app, patches, options
-                                    )
-                                )
-                            },
-                            onBackClick = navController::pop,
-                            vm = getComposeViewModel {
-                                parametersOf(
-                                    SelectedAppInfoViewModel.Params(
-                                        destination.selectedApp,
-                                        destination.patchSelection
-                                    )
-                                )
-                            }
-                        )
-
-                        is Destination.Patcher -> PatcherScreen(
-                            onBackClick = { navController.popUpTo { it is Destination.Dashboard } },
-                            vm = getComposeViewModel { parametersOf(destination) }
-                        )
-                    }
-                }
+                ReVancedManager(vm)
             }
         }
     }
 }
+
+@Composable
+private fun ReVancedManager(vm: MainViewModel) {
+    val navController = rememberNavController()
+
+    EventEffect(vm.appSelectFlow) { app ->
+        navController.navigateComplex(
+            SelectedApplicationInfo,
+            SelectedApplicationInfo.ViewModelParams(app)
+        )
+    }
+
+    NavHost(
+        navController = navController,
+        startDestination = Dashboard,
+        enterTransition = { slideInHorizontally(initialOffsetX = { it }) },
+        exitTransition = { slideOutHorizontally(targetOffsetX = { -it / 3 }) },
+        popEnterTransition = { slideInHorizontally(initialOffsetX = { -it / 3 }) },
+        popExitTransition = { slideOutHorizontally(targetOffsetX = { it }) },
+    ) {
+        composable<Dashboard> {
+            DashboardScreen(
+                onSettingsClick = { navController.navigate(Settings) },
+                onAppSelectorClick = {
+                    navController.navigate(AppSelector)
+                },
+                onUpdateClick = {
+                    navController.navigate(Update())
+                },
+                onDownloaderPluginClick = {
+                    navController.navigate(Settings.Downloads)
+                },
+                onAppClick = { packageName ->
+                    navController.navigate(InstalledApplicationInfo(packageName))
+                }
+            )
+        }
+
+        composable<InstalledApplicationInfo> {
+            val data = it.toRoute<InstalledApplicationInfo>()
+
+            InstalledAppInfoScreen(
+                onPatchClick = vm::selectApp,
+                onBackClick = navController::popBackStack,
+                viewModel = koinViewModel { parametersOf(data.packageName) }
+            )
+        }
+
+        composable<AppSelector> {
+            AppSelectorScreen(
+                onSelect = vm::selectApp,
+                onStorageSelect = vm::selectApp,
+                onBackClick = navController::popBackStack
+            )
+        }
+
+        composable<Patcher> {
+            PatcherScreen(
+                onBackClick = {
+                    navController.navigate(route = Dashboard) {
+                        launchSingleTop = true
+                        popUpTo<Dashboard> {
+                            inclusive = false
+                        }
+                    }
+                },
+                viewModel = koinViewModel { parametersOf(it.getComplexArg<Patcher.ViewModelParams>()) }
+            )
+        }
+
+        composable<Update> {
+            val data = it.toRoute<Update>()
+
+            UpdateScreen(
+                onBackClick = navController::popBackStack,
+                vm = koinViewModel { parametersOf(data.downloadOnScreenEntry) }
+            )
+        }
+
+        navigation<SelectedApplicationInfo>(startDestination = SelectedApplicationInfo.Main) {
+            composable<SelectedApplicationInfo.Main> {
+                val parentBackStackEntry = navController.navGraphEntry(it)
+                val data =
+                    parentBackStackEntry.getComplexArg<SelectedApplicationInfo.ViewModelParams>()
+                val viewModel =
+                    koinNavViewModel<SelectedAppInfoViewModel>(viewModelStoreOwner = parentBackStackEntry) {
+                        parametersOf(data)
+                    }
+
+                SelectedAppInfoScreen(
+                    onBackClick = navController::popBackStack,
+                    onPatchClick = {
+                        it.lifecycleScope.launch {
+                            navController.navigateComplex(
+                                Patcher,
+                                viewModel.getPatcherParams()
+                            )
+                        }
+                    },
+                    onPatchSelectorClick = { app, patches, options ->
+                        navController.navigateComplex(
+                            SelectedApplicationInfo.PatchesSelector,
+                            SelectedApplicationInfo.PatchesSelector.ViewModelParams(
+                                app,
+                                patches,
+                                options
+                            )
+                        )
+                    },
+                    onRequiredOptions = { app, patches, options ->
+                        navController.navigateComplex(
+                            SelectedApplicationInfo.RequiredOptions,
+                            SelectedApplicationInfo.PatchesSelector.ViewModelParams(
+                                app,
+                                patches,
+                                options
+                            )
+                        )
+                    },
+                    vm = viewModel
+                )
+            }
+
+            composable<SelectedApplicationInfo.PatchesSelector> {
+                val data =
+                    it.getComplexArg<SelectedApplicationInfo.PatchesSelector.ViewModelParams>()
+                val selectedAppInfoVm = koinNavViewModel<SelectedAppInfoViewModel>(
+                    viewModelStoreOwner = navController.navGraphEntry(it)
+                )
+
+                PatchesSelectorScreen(
+                    onBackClick = navController::popBackStack,
+                    onSave = { patches, options ->
+                        selectedAppInfoVm.updateConfiguration(patches, options)
+                        navController.popBackStack()
+                    },
+                    vm = koinViewModel { parametersOf(data) }
+                )
+            }
+
+            composable<SelectedApplicationInfo.RequiredOptions> {
+                val data =
+                    it.getComplexArg<SelectedApplicationInfo.PatchesSelector.ViewModelParams>()
+                val selectedAppInfoVm = koinNavViewModel<SelectedAppInfoViewModel>(
+                    viewModelStoreOwner = navController.navGraphEntry(it)
+                )
+
+                RequiredOptionsScreen(
+                    onBackClick = navController::popBackStack,
+                    onContinue = { patches, options ->
+                        selectedAppInfoVm.updateConfiguration(patches, options)
+                        it.lifecycleScope.launch {
+                            navController.navigateComplex(
+                                Patcher,
+                                selectedAppInfoVm.getPatcherParams()
+                            )
+                        }
+                    },
+                    vm = koinViewModel { parametersOf(data) }
+                )
+            }
+        }
+
+        navigation<Settings>(startDestination = Settings.Main) {
+            composable<Settings.Main> {
+                SettingsScreen(
+                    onBackClick = navController::popBackStack,
+                    navigate = navController::navigate
+                )
+            }
+
+            composable<Settings.General> {
+                GeneralSettingsScreen(onBackClick = navController::popBackStack)
+            }
+
+            composable<Settings.Advanced> {
+                AdvancedSettingsScreen(onBackClick = navController::popBackStack)
+            }
+
+            composable<Settings.Developer> {
+                DeveloperSettingsScreen(onBackClick = navController::popBackStack)
+            }
+
+            composable<Settings.Updates> {
+                UpdatesSettingsScreen(
+                    onBackClick = navController::popBackStack,
+                    onChangelogClick = { navController.navigate(Settings.Changelogs) },
+                    onUpdateClick = { navController.navigate(Update()) }
+                )
+            }
+
+            composable<Settings.Downloads> {
+                DownloadsSettingsScreen(onBackClick = navController::popBackStack)
+            }
+
+            composable<Settings.ImportExport> {
+                ImportExportSettingsScreen(onBackClick = navController::popBackStack)
+            }
+
+            composable<Settings.About> {
+                AboutSettingsScreen(
+                    onBackClick = navController::popBackStack,
+                    navigate = navController::navigate
+                )
+            }
+
+            composable<Settings.Changelogs> {
+                ChangelogsSettingsScreen(onBackClick = navController::popBackStack)
+            }
+
+            composable<Settings.Contributors> {
+                ContributorSettingsScreen(onBackClick = navController::popBackStack)
+            }
+
+            composable<Settings.Licenses> {
+                LicensesSettingsScreen(onBackClick = navController::popBackStack)
+            }
+
+        }
+    }
+}
+
+@Composable
+private fun NavController.navGraphEntry(entry: NavBackStackEntry) =
+    remember(entry) { getBackStackEntry(entry.destination.parent!!.id) }
+
+// Androidx Navigation does not support storing complex types in route objects, so we have to store them inside the saved state handle of the back stack entry instead.
+private fun <T : Parcelable, R : ComplexParameter<T>> NavController.navigateComplex(
+    route: R,
+    data: T
+) {
+    navigate(route)
+    getBackStackEntry(route).savedStateHandle["args"] = data
+}
+
+private fun <T : Parcelable> NavBackStackEntry.getComplexArg() = savedStateHandle.get<T>("args")!!

app/src/main/java/app/revanced/manager/ManagerApplication.kt

@@ -1,23 +1,24 @@
 package app.revanced.manager
 
+import android.app.Activity
 import android.app.Application
-import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+import app.revanced.manager.data.platform.Filesystem
 import app.revanced.manager.di.*
 import app.revanced.manager.domain.manager.PreferencesManager
+import app.revanced.manager.domain.repository.DownloaderPluginRepository
 import app.revanced.manager.domain.repository.PatchBundleRepository
-import app.revanced.manager.service.ManagerRootService
-import app.revanced.manager.service.RootConnection
+import app.revanced.manager.util.tag
 import kotlinx.coroutines.Dispatchers
 import coil.Coil
 import coil.ImageLoader
 import com.topjohnwu.superuser.Shell
 import com.topjohnwu.superuser.internal.BuilderImpl
-import com.topjohnwu.superuser.ipc.RootService
 import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.launch
 import me.zhanghai.android.appiconloader.coil.AppIconFetcher
 import me.zhanghai.android.appiconloader.coil.AppIconKeyer
-import org.koin.android.ext.android.get
 import org.koin.android.ext.android.inject
 import org.koin.android.ext.koin.androidContext
 import org.koin.android.ext.koin.androidLogger
@@ -28,6 +29,9 @@ class ManagerApplication : Application() {
     private val scope = MainScope()
     private val prefs: PreferencesManager by inject()
     private val patchBundleRepository: PatchBundleRepository by inject()
+    private val downloaderPluginRepository: DownloaderPluginRepository by inject()
+    private val fs: Filesystem by inject()
+
     override fun onCreate() {
         super.onCreate()
 
@@ -61,17 +65,46 @@ class ManagerApplication : Application() {
         val shellBuilder = BuilderImpl.create().setFlags(Shell.FLAG_MOUNT_MASTER)
         Shell.setDefaultBuilder(shellBuilder)
 
-        val intent = Intent(this, ManagerRootService::class.java)
-        RootService.bind(intent, get<RootConnection>())
-
         scope.launch {
             prefs.preload()
         }
+        scope.launch(Dispatchers.Default) {
+            downloaderPluginRepository.reload()
+        }
         scope.launch(Dispatchers.Default) {
             with(patchBundleRepository) {
                 reload()
                 updateCheck()
             }
         }
+        registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
+            private var firstActivityCreated = false
+
+            override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+                if (firstActivityCreated) return
+                firstActivityCreated = true
+
+                // We do not want to call onFreshProcessStart() if there is state to restore.
+                // This can happen on system-initiated process death.
+                if (savedInstanceState == null) {
+                    Log.d(tag, "Fresh process created")
+                    onFreshProcessStart()
+                } else Log.d(tag, "System-initiated process death detected")
+            }
+
+            override fun onActivityStarted(activity: Activity) {}
+            override fun onActivityResumed(activity: Activity) {}
+            override fun onActivityPaused(activity: Activity) {}
+            override fun onActivityStopped(activity: Activity) {}
+            override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+            override fun onActivityDestroyed(activity: Activity) {}
+        })
+    }
+
+    private fun onFreshProcessStart() {
+        fs.uiTempDir.apply {
+            deleteRecursively()
+            mkdirs()
+        }
     }
 }

app/src/main/java/app/revanced/manager/data/platform/Filesystem.kt

@@ -1,13 +1,16 @@
 package app.revanced.manager.data.platform
 
+import android.Manifest
 import android.app.Application
+import android.content.Context
+import android.content.pm.PackageManager
 import android.os.Build
 import android.os.Environment
-import android.Manifest
-import android.content.pm.PackageManager
 import androidx.activity.result.contract.ActivityResultContract
 import androidx.activity.result.contract.ActivityResultContracts
 import app.revanced.manager.util.RequestManageStorageContract
+import java.io.File
+import java.nio.file.Path
 
 class Filesystem(private val app: Application) {
     val contentResolver = app.contentResolver // TODO: move Content Resolver operations to here.
@@ -16,21 +19,33 @@ class Filesystem(private val app: Application) {
      * A directory that gets cleared when the app restarts.
      * Do not store paths to this directory in a parcel.
      */
-    val tempDir = app.cacheDir.resolve("ephemeral").apply {
+    val tempDir: File = app.getDir("ephemeral", Context.MODE_PRIVATE).apply {
         deleteRecursively()
         mkdirs()
     }
 
-    fun externalFilesDir() = Environment.getExternalStorageDirectory().toPath()
+    /**
+     * A directory for storing temporary files related to UI.
+     * This is the same as [tempDir], but does not get cleared on system-initiated process death.
+     * Paths to this directory can be safely stored in parcels.
+     */
+    val uiTempDir: File = app.getDir("ui_ephemeral", Context.MODE_PRIVATE)
+
+    fun externalFilesDir(): Path = Environment.getExternalStorageDirectory().toPath()
 
     private fun usesManagePermission() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
 
-    private val storagePermissionName = if (usesManagePermission()) Manifest.permission.MANAGE_EXTERNAL_STORAGE else Manifest.permission.READ_EXTERNAL_STORAGE
+    private val storagePermissionName =
+        if (usesManagePermission()) Manifest.permission.MANAGE_EXTERNAL_STORAGE else Manifest.permission.READ_EXTERNAL_STORAGE
 
     fun permissionContract(): Pair<ActivityResultContract<String, Boolean>, String> {
-        val contract = if (usesManagePermission()) RequestManageStorageContract() else ActivityResultContracts.RequestPermission()
+        val contract =
+            if (usesManagePermission()) RequestManageStorageContract() else ActivityResultContracts.RequestPermission()
         return contract to storagePermissionName
     }
 
-    fun hasStoragePermission() = if (usesManagePermission()) Environment.isExternalStorageManager() else app.checkSelfPermission(storagePermissionName) == PackageManager.PERMISSION_GRANTED
+    fun hasStoragePermission() =
+        if (usesManagePermission()) Environment.isExternalStorageManager() else app.checkSelfPermission(
+            storagePermissionName
+        ) == PackageManager.PERMISSION_GRANTED
 }

app/src/main/java/app/revanced/manager/data/room/AppDatabase.kt

@@ -16,9 +16,14 @@ import app.revanced.manager.data.room.bundles.PatchBundleEntity
 import app.revanced.manager.data.room.options.Option
 import app.revanced.manager.data.room.options.OptionDao
 import app.revanced.manager.data.room.options.OptionGroup
+import app.revanced.manager.data.room.plugins.TrustedDownloaderPlugin
+import app.revanced.manager.data.room.plugins.TrustedDownloaderPluginDao
 import kotlin.random.Random
 
-@Database(entities = [PatchBundleEntity::class, PatchSelection::class, SelectedPatch::class, DownloadedApp::class, InstalledApp::class, AppliedPatch::class, OptionGroup::class, Option::class], version = 1)
+@Database(
+    entities = [PatchBundleEntity::class, PatchSelection::class, SelectedPatch::class, DownloadedApp::class, InstalledApp::class, AppliedPatch::class, OptionGroup::class, Option::class, TrustedDownloaderPlugin::class],
+    version = 1
+)
 @TypeConverters(Converters::class)
 abstract class AppDatabase : RoomDatabase() {
     abstract fun patchBundleDao(): PatchBundleDao
@@ -26,6 +31,7 @@ abstract class AppDatabase : RoomDatabase() {
     abstract fun downloadedAppDao(): DownloadedAppDao
     abstract fun installedAppDao(): InstalledAppDao
     abstract fun optionDao(): OptionDao
+    abstract fun trustedDownloaderPluginDao(): TrustedDownloaderPluginDao
 
     companion object {
         fun generateUid() = Random.Default.nextInt()

app/src/main/java/app/revanced/manager/data/room/Converters.kt

@@ -2,7 +2,7 @@ package app.revanced.manager.data.room
 
 import androidx.room.TypeConverter
 import app.revanced.manager.data.room.bundles.Source
-import io.ktor.http.*
+import app.revanced.manager.data.room.options.Option.SerializedValue
 import java.io.File
 
 class Converters {
@@ -17,4 +17,10 @@ class Converters {
 
     @TypeConverter
     fun fileToString(file: File): String = file.path
+
+    @TypeConverter
+    fun serializedOptionFromString(value: String) = SerializedValue.fromJsonString(value)
+
+    @TypeConverter
+    fun serializedOptionToString(value: SerializedValue) = value.toJsonString()
 }

app/src/main/java/app/revanced/manager/data/room/apps/downloaded/DownloadedApp.kt

@@ -12,4 +12,5 @@ data class DownloadedApp(
     @ColumnInfo(name = "package_name") val packageName: String,
     @ColumnInfo(name = "version") val version: String,
     @ColumnInfo(name = "directory") val directory: File,
+    @ColumnInfo(name = "last_used") val lastUsed: Long = System.currentTimeMillis()
 )

app/src/main/java/app/revanced/manager/data/room/apps/downloaded/DownloadedAppDao.kt

@@ -4,6 +4,7 @@ import androidx.room.Dao
 import androidx.room.Delete
 import androidx.room.Insert
 import androidx.room.Query
+import androidx.room.Upsert
 import kotlinx.coroutines.flow.Flow
 
 @Dao
@@ -14,8 +15,11 @@ interface DownloadedAppDao {
     @Query("SELECT * FROM downloaded_app WHERE package_name = :packageName AND version = :version")
     suspend fun get(packageName: String, version: String): DownloadedApp?
 
-    @Insert
-    suspend fun insert(downloadedApp: DownloadedApp)
+    @Upsert
+    suspend fun upsert(downloadedApp: DownloadedApp)
+
+    @Query("UPDATE downloaded_app SET last_used = :newValue WHERE package_name = :packageName AND version = :version")
+    suspend fun markUsed(packageName: String, version: String, newValue: Long = System.currentTimeMillis())
 
     @Delete
     suspend fun delete(downloadedApps: Collection<DownloadedApp>)

app/src/main/java/app/revanced/manager/data/room/apps/installed/AppliedPatch.kt

@@ -22,7 +22,8 @@ import kotlinx.parcelize.Parcelize
         ForeignKey(
             PatchBundleEntity::class,
             parentColumns = ["uid"],
-            childColumns = ["bundle"]
+            childColumns = ["bundle"],
+            onDelete = ForeignKey.CASCADE
         )
     ],
     indices = [Index(value = ["bundle"], unique = false)]

app/src/main/java/app/revanced/manager/data/room/apps/installed/InstalledApp.kt

@@ -1,18 +1,15 @@
 package app.revanced.manager.data.room.apps.installed
 
-import android.os.Parcelable
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
 import app.revanced.manager.R
-import kotlinx.parcelize.Parcelize
 
 enum class InstallType(val stringResource: Int) {
     DEFAULT(R.string.default_install),
-    ROOT(R.string.root_install)
+    MOUNT(R.string.mount_install)
 }
 
-@Parcelize
 @Entity(tableName = "installed_app")
 data class InstalledApp(
     @PrimaryKey
@@ -20,4 +17,4 @@ data class InstalledApp(
     @ColumnInfo(name = "original_package_name") val originalPackageName: String,
     @ColumnInfo(name = "version") val version: String,
     @ColumnInfo(name = "install_type") val installType: InstallType
-) : Parcelable
+)

app/src/main/java/app/revanced/manager/data/room/apps/installed/InstalledAppDao.kt

@@ -3,7 +3,7 @@ package app.revanced.manager.data.room.apps.installed
 import androidx.room.Dao
 import androidx.room.Delete
 import androidx.room.Insert
-import androidx.room.MapInfo
+import androidx.room.MapColumn
 import androidx.room.Query
 import androidx.room.Transaction
 import androidx.room.Upsert
@@ -17,12 +17,13 @@ interface InstalledAppDao {
     @Query("SELECT * FROM installed_app WHERE current_package_name = :packageName")
     suspend fun get(packageName: String): InstalledApp?
 
-    @MapInfo(keyColumn = "bundle", valueColumn = "patch_name")
     @Query(
         "SELECT bundle, patch_name FROM applied_patch" +
                 " WHERE package_name = :packageName"
     )
-    suspend fun getPatchesSelection(packageName: String): Map<Int, List<String>>
+    suspend fun getPatchesSelection(packageName: String): Map<@MapColumn("bundle") Int, List<@MapColumn(
+        "patch_name"
+    ) String>>
 
     @Transaction
     suspend fun upsertApp(installedApp: InstalledApp, appliedPatches: List<AppliedPatch>) {

app/src/main/java/app/revanced/manager/data/room/bundles/PatchBundleDao.kt

@@ -8,22 +8,25 @@ interface PatchBundleDao {
     @Query("SELECT * FROM patch_bundles")
     suspend fun all(): List<PatchBundleEntity>
 
-    @Query("SELECT version, integrations_version, auto_update FROM patch_bundles WHERE uid = :uid")
-    fun getPropsById(uid: Int): Flow<BundleProperties>
+    @Query("SELECT version, auto_update FROM patch_bundles WHERE uid = :uid")
+    fun getPropsById(uid: Int): Flow<BundleProperties?>
 
-    @Query("UPDATE patch_bundles SET version = :patches, integrations_version = :integrations WHERE uid = :uid")
-    suspend fun updateVersion(uid: Int, patches: String?, integrations: String?)
+    @Query("UPDATE patch_bundles SET version = :patches WHERE uid = :uid")
+    suspend fun updateVersion(uid: Int, patches: String?)
 
     @Query("UPDATE patch_bundles SET auto_update = :value WHERE uid = :uid")
     suspend fun setAutoUpdate(uid: Int, value: Boolean)
 
+    @Query("UPDATE patch_bundles SET name = :value WHERE uid = :uid")
+    suspend fun setName(uid: Int, value: String)
+
     @Query("DELETE FROM patch_bundles WHERE uid != 0")
     suspend fun purgeCustomBundles()
 
     @Transaction
     suspend fun reset() {
         purgeCustomBundles()
-        updateVersion(0, null, null) // Reset the main source
+        updateVersion(0, null) // Reset the main source
     }
 
     @Query("DELETE FROM patch_bundles WHERE uid = :uid")

app/src/main/java/app/revanced/manager/data/room/bundles/PatchBundleEntity.kt

@@ -21,7 +21,7 @@ sealed class Source {
     }
 
     companion object {
-        fun from(value: String) = when(value) {
+        fun from(value: String) = when (value) {
             Local.SENTINEL -> Local
             API.SENTINEL -> API
             else -> Remote(Url(value))
@@ -29,21 +29,16 @@ sealed class Source {
     }
 }
 
-data class VersionInfo(
-    @ColumnInfo(name = "version") val patches: String? = null,
-    @ColumnInfo(name = "integrations_version") val integrations: String? = null,
-)
-
-@Entity(tableName = "patch_bundles", indices = [Index(value = ["name"], unique = true)])
+@Entity(tableName = "patch_bundles")
 data class PatchBundleEntity(
     @PrimaryKey val uid: Int,
     @ColumnInfo(name = "name") val name: String,
-    @Embedded val versionInfo: VersionInfo,
+    @ColumnInfo(name = "version") val version: String? = null,
     @ColumnInfo(name = "source") val source: Source,
     @ColumnInfo(name = "auto_update") val autoUpdate: Boolean
 )
 
 data class BundleProperties(
-    @Embedded val versionInfo: VersionInfo,
+    @ColumnInfo(name = "version") val version: String? = null,
     @ColumnInfo(name = "auto_update") val autoUpdate: Boolean
 )

app/src/main/java/app/revanced/manager/data/room/options/Option.kt

@@ -3,6 +3,25 @@ package app.revanced.manager.data.room.options
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.ForeignKey
+import app.revanced.manager.patcher.patch.Option
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.add
+import kotlinx.serialization.json.boolean
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.float
+import kotlinx.serialization.json.int
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.long
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
 
 @Entity(
     tableName = "options",
@@ -19,5 +38,79 @@ data class Option(
     @ColumnInfo(name = "patch_name") val patchName: String,
     @ColumnInfo(name = "key") val key: String,
     // Encoded as Json.
-    @ColumnInfo(name = "value") val value: String,
-)
+    @ColumnInfo(name = "value") val value: SerializedValue,
+) {
+    @Serializable
+    data class SerializedValue(val raw: JsonElement) {
+        fun toJsonString() = json.encodeToString(raw)
+        fun deserializeFor(option: Option<*>): Any? {
+            if (raw is JsonNull) return null
+
+            val errorMessage = "Cannot deserialize value as ${option.type}"
+            try {
+                if (option.type.classifier == List::class) {
+                    val elementType = option.type.arguments.first().type!!
+                    return raw.jsonArray.map { deserializeBasicType(elementType, it.jsonPrimitive) }
+                }
+
+                return deserializeBasicType(option.type, raw.jsonPrimitive)
+            } catch (e: IllegalArgumentException) {
+                throw SerializationException(errorMessage, e)
+            } catch (e: IllegalStateException) {
+                throw SerializationException(errorMessage, e)
+            } catch (e: kotlinx.serialization.SerializationException) {
+                throw SerializationException(errorMessage, e)
+            }
+        }
+
+        companion object {
+            private val json = Json {
+                // Patcher does not forbid the use of these values, so we should support them.
+                allowSpecialFloatingPointValues = true
+            }
+
+            private fun deserializeBasicType(type: KType, value: JsonPrimitive) = when (type) {
+                typeOf<Boolean>() -> value.boolean
+                typeOf<Int>() -> value.int
+                typeOf<Long>() -> value.long
+                typeOf<Float>() -> value.float
+                typeOf<String>() -> value.content.also {
+                    if (!value.isString) throw SerializationException(
+                        "Expected value to be a string: $value"
+                    )
+                }
+
+                else -> throw SerializationException("Unknown type: $type")
+            }
+
+            fun fromJsonString(value: String) = SerializedValue(json.decodeFromString(value))
+            fun fromValue(value: Any?) = SerializedValue(when (value) {
+                null -> JsonNull
+                is Number -> JsonPrimitive(value)
+                is Boolean -> JsonPrimitive(value)
+                is String -> JsonPrimitive(value)
+                is List<*> -> buildJsonArray {
+                    var elementClass: KClass<out Any>? = null
+
+                    value.forEach {
+                        when (it) {
+                            null -> throw SerializationException("List elements must not be null")
+                            is Number -> add(it)
+                            is Boolean -> add(it)
+                            is String -> add(it)
+                            else -> throw SerializationException("Unknown element type: ${it::class.simpleName}")
+                        }
+
+                        if (elementClass == null) elementClass = it::class
+                        else if (elementClass != it::class) throw SerializationException("List elements must have the same type")
+                    }
+                }
+
+                else -> throw SerializationException("Unknown type: ${value::class.simpleName}")
+            })
+        }
+    }
+
+    class SerializationException(message: String, cause: Throwable? = null) :
+        Exception(message, cause)
+}

app/src/main/java/app/revanced/manager/data/room/options/OptionDao.kt

@@ -2,7 +2,7 @@ package app.revanced.manager.data.room.options
 
 import androidx.room.Dao
 import androidx.room.Insert
-import androidx.room.MapInfo
+import androidx.room.MapColumn
 import androidx.room.Query
 import androidx.room.Transaction
 import kotlinx.coroutines.flow.Flow
@@ -10,13 +10,12 @@ import kotlinx.coroutines.flow.Flow
 @Dao
 abstract class OptionDao {
     @Transaction
-    @MapInfo(keyColumn = "patch_bundle")
     @Query(
         "SELECT patch_bundle, `group`, patch_name, `key`, value FROM option_groups" +
                 " LEFT JOIN options ON uid = options.`group`" +
                 " WHERE package_name = :packageName"
     )
-    abstract suspend fun getOptions(packageName: String): Map<Int, List<Option>>
+    abstract suspend fun getOptions(packageName: String): Map<@MapColumn("patch_bundle") Int, List<Option>>
 
     @Query("SELECT uid FROM option_groups WHERE patch_bundle = :bundleUid AND package_name = :packageName")
     abstract suspend fun getGroupId(bundleUid: Int, packageName: String): Int?

app/src/main/java/app/revanced/manager/data/room/plugins/TrustedDownloaderPlugin.kt

@@ -0,0 +1,11 @@
+package app.revanced.manager.data.room.plugins
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity(tableName = "trusted_downloader_plugins")
+class TrustedDownloaderPlugin(
+    @PrimaryKey @ColumnInfo(name = "package_name") val packageName: String,
+    @ColumnInfo(name = "signature") val signature: ByteArray
+)

app/src/main/java/app/revanced/manager/data/room/plugins/TrustedDownloaderPluginDao.kt

@@ -0,0 +1,22 @@
+package app.revanced.manager.data.room.plugins
+
+import androidx.room.Dao
+import androidx.room.Query
+import androidx.room.Transaction
+import androidx.room.Upsert
+
+@Dao
+interface TrustedDownloaderPluginDao {
+    @Query("SELECT signature FROM trusted_downloader_plugins WHERE package_name = :packageName")
+    suspend fun getTrustedSignature(packageName: String): ByteArray?
+
+    @Upsert
+    suspend fun upsertTrust(plugin: TrustedDownloaderPlugin)
+
+    @Query("DELETE FROM trusted_downloader_plugins WHERE package_name = :packageName")
+    suspend fun remove(packageName: String)
+
+    @Transaction
+    @Query("DELETE FROM trusted_downloader_plugins WHERE package_name IN (:packageNames)")
+    suspend fun removeAll(packageNames: Set<String>)
+}

app/src/main/java/app/revanced/manager/data/room/selection/SelectionDao.kt

@@ -2,29 +2,31 @@ package app.revanced.manager.data.room.selection
 
 import androidx.room.Dao
 import androidx.room.Insert
-import androidx.room.MapInfo
+import androidx.room.MapColumn
 import androidx.room.Query
 import androidx.room.Transaction
 
 @Dao
 abstract class SelectionDao {
     @Transaction
-    @MapInfo(keyColumn = "patch_bundle", valueColumn = "patch_name")
     @Query(
         "SELECT patch_bundle, patch_name FROM patch_selections" +
                 " LEFT JOIN selected_patches ON uid = selected_patches.selection" +
                 " WHERE package_name = :packageName"
     )
-    abstract suspend fun getSelectedPatches(packageName: String): Map<Int, List<String>>
+    abstract suspend fun getSelectedPatches(packageName: String): Map<@MapColumn("patch_bundle") Int, List<@MapColumn(
+        "patch_name"
+    ) String>>
 
     @Transaction
-    @MapInfo(keyColumn = "package_name", valueColumn = "patch_name")
     @Query(
         "SELECT package_name, patch_name FROM patch_selections" +
                 " LEFT JOIN selected_patches ON uid = selected_patches.selection" +
                 " WHERE patch_bundle = :bundleUid"
     )
-    abstract suspend fun exportSelection(bundleUid: Int): Map<String, List<String>>
+    abstract suspend fun exportSelection(bundleUid: Int): Map<@MapColumn("package_name") String, List<@MapColumn(
+        "patch_name"
+    ) String>>
 
     @Query("SELECT uid FROM patch_selections WHERE patch_bundle = :bundleUid AND package_name = :packageName")
     abstract suspend fun getSelectionId(bundleUid: Int, packageName: String): Int?

app/src/main/java/app/revanced/manager/di/RepositoryModule.kt

@@ -22,6 +22,7 @@ val repositoryModule = module {
         // It is best to load patch bundles ASAP
         createdAtStart()
     }
+    singleOf(::DownloaderPluginRepository)
     singleOf(::WorkerRepository)
     singleOf(::DownloadedAppRepository)
     singleOf(::InstalledAppRepository)

app/src/main/java/app/revanced/manager/di/RootModule.kt

@@ -1,11 +1,9 @@
 package app.revanced.manager.di
 
 import app.revanced.manager.domain.installer.RootInstaller
-import app.revanced.manager.service.RootConnection
 import org.koin.core.module.dsl.singleOf
 import org.koin.dsl.module
 
 val rootModule = module {
-    singleOf(::RootConnection)
     singleOf(::RootInstaller)
 }

app/src/main/java/app/revanced/manager/di/ServiceModule.kt

@@ -1,11 +1,9 @@
 package app.revanced.manager.di
 
 import app.revanced.manager.network.service.HttpService
-import app.revanced.manager.network.service.ReVancedService
 import org.koin.core.module.dsl.singleOf
 import org.koin.dsl.module
 
 val serviceModule = module {
-    singleOf(::ReVancedService)
     singleOf(::HttpService)
 }

app/src/main/java/app/revanced/manager/di/ViewModelModule.kt

@@ -9,14 +9,15 @@ val viewModelModule = module {
     viewModelOf(::DashboardViewModel)
     viewModelOf(::SelectedAppInfoViewModel)
     viewModelOf(::PatchesSelectorViewModel)
-    viewModelOf(::SettingsViewModel)
+    viewModelOf(::GeneralSettingsViewModel)
     viewModelOf(::AdvancedSettingsViewModel)
     viewModelOf(::AppSelectorViewModel)
-    viewModelOf(::VersionSelectorViewModel)
     viewModelOf(::PatcherViewModel)
     viewModelOf(::UpdateViewModel)
     viewModelOf(::ChangelogsViewModel)
     viewModelOf(::ImportExportViewModel)
+    viewModelOf(::AboutViewModel)
+    viewModelOf(::DeveloperOptionsViewModel)
     viewModelOf(::ContributorViewModel)
     viewModelOf(::DownloadsViewModel)
     viewModelOf(::InstalledAppsViewModel)

app/src/main/java/app/revanced/manager/domain/bundles/LocalPatchBundle.kt

@@ -4,22 +4,18 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.io.File
 import java.io.InputStream
-import java.nio.file.Files
-import java.nio.file.StandardCopyOption
 
-class LocalPatchBundle(name: String, id: Int, directory: File) : PatchBundleSource(name, id, directory) {
-    suspend fun replace(patches: InputStream? = null, integrations: InputStream? = null) {
+class LocalPatchBundle(name: String, id: Int, directory: File) :
+    PatchBundleSource(name, id, directory) {
+    suspend fun replace(patches: InputStream) {
         withContext(Dispatchers.IO) {
-            patches?.let { inputStream ->
-                patchBundleOutputStream().use { outputStream ->
-                    inputStream.copyTo(outputStream)
-                }
-            }
-            integrations?.let {
-                Files.copy(it, this@LocalPatchBundle.integrationsFile.toPath(), StandardCopyOption.REPLACE_EXISTING)
+            patchBundleOutputStream().use { outputStream ->
+                patches.copyTo(outputStream)
             }
         }
 
-        reload()
+        reload()?.also {
+            saveVersion(it.readManifestAttribute("Version"))
+        }
     }
 }

app/src/main/java/app/revanced/manager/domain/bundles/PatchBundleSource.kt

@@ -1,12 +1,22 @@
 package app.revanced.manager.domain.bundles
 
+import android.app.Application
 import android.util.Log
+import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Stable
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.revanced.manager.R
+import app.revanced.manager.domain.repository.PatchBundlePersistenceRepository
 import app.revanced.manager.patcher.patch.PatchBundle
 import app.revanced.manager.util.tag
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
 import java.io.File
 import java.io.OutputStream
 
@@ -14,13 +24,20 @@ import java.io.OutputStream
  * A [PatchBundle] source.
  */
 @Stable
-sealed class PatchBundleSource(val name: String, val uid: Int, directory: File) {
+sealed class PatchBundleSource(initialName: String, val uid: Int, directory: File) : KoinComponent {
+    protected val configRepository: PatchBundlePersistenceRepository by inject()
+    private val app: Application by inject()
     protected val patchesFile = directory.resolve("patches.jar")
-    protected val integrationsFile = directory.resolve("integrations.apk")
 
     private val _state = MutableStateFlow(load())
     val state = _state.asStateFlow()
 
+    private val _nameFlow = MutableStateFlow(initialName)
+    val nameFlow =
+        _nameFlow.map { it.ifEmpty { app.getString(if (isDefault) R.string.bundle_name_default else R.string.bundle_name_fallback) } }
+
+    suspend fun getName() = nameFlow.first()
+
     /**
      * Returns true if the bundle has been downloaded to local storage.
      */
@@ -40,15 +57,40 @@ sealed class PatchBundleSource(val name: String, val uid: Int, directory: File)
         if (!hasInstalled()) return State.Missing
 
         return try {
-            State.Loaded(PatchBundle(patchesFile, integrationsFile.takeIf(File::exists)))
+            State.Loaded(PatchBundle(patchesFile))
         } catch (t: Throwable) {
-            Log.e(tag, "Failed to load patch bundle $name", t)
+            Log.e(tag, "Failed to load patch bundle with UID $uid", t)
             State.Failed(t)
         }
     }
 
-    fun reload() {
-        _state.value = load()
+    suspend fun reload(): PatchBundle? {
+        val newState = load()
+        _state.value = newState
+
+        val bundle = newState.patchBundleOrNull()
+        // Try to read the name from the patch bundle manifest if the bundle does not have a name.
+        if (bundle != null && _nameFlow.value.isEmpty()) {
+            bundle.readManifestAttribute("Name")?.let { setName(it) }
+        }
+
+        return bundle
+    }
+
+    /**
+     * Create a flow that emits the [app.revanced.manager.data.room.bundles.BundleProperties] of this [PatchBundleSource].
+     * The flow will emit null if the associated [PatchBundleSource] is deleted.
+     */
+    fun propsFlow() = configRepository.getProps(uid).flowOn(Dispatchers.Default)
+    suspend fun getProps() = propsFlow().first()!!
+
+    suspend fun currentVersion() = getProps().version
+    protected suspend fun saveVersion(version: String?) =
+        configRepository.updateVersion(uid, version)
+
+    suspend fun setName(name: String) {
+        configRepository.setName(uid, name)
+        _nameFlow.value = name
     }
 
     sealed interface State {
@@ -61,9 +103,12 @@ sealed class PatchBundleSource(val name: String, val uid: Int, directory: File)
         }
     }
 
-    companion object {
-        val PatchBundleSource.isDefault get() = uid == 0
-        val PatchBundleSource.asRemoteOrNull get() = this as? RemotePatchBundle
-        fun PatchBundleSource.propsOrNullFlow() = asRemoteOrNull?.propsFlow() ?: flowOf(null)
+    companion object Extensions {
+        val PatchBundleSource.isDefault inline get() = uid == 0
+        val PatchBundleSource.asRemoteOrNull inline get() = this as? RemotePatchBundle
+        val PatchBundleSource.nameState
+            @Composable inline get() = nameFlow.collectAsStateWithLifecycle(
+                ""
+            )
     }
 }

app/src/main/java/app/revanced/manager/domain/bundles/RemotePatchBundle.kt

@@ -1,54 +1,31 @@
 package app.revanced.manager.domain.bundles
 
 import androidx.compose.runtime.Stable
-import app.revanced.manager.data.room.bundles.VersionInfo
-import app.revanced.manager.domain.repository.PatchBundlePersistenceRepository
 import app.revanced.manager.network.api.ReVancedAPI
-import app.revanced.manager.network.api.ReVancedAPI.Extensions.findAssetByType
-import app.revanced.manager.network.dto.BundleAsset
-import app.revanced.manager.network.dto.BundleInfo
+import app.revanced.manager.network.dto.ReVancedAsset
 import app.revanced.manager.network.service.HttpService
 import app.revanced.manager.network.utils.getOrThrow
-import app.revanced.manager.util.APK_MIMETYPE
-import app.revanced.manager.util.JAR_MIMETYPE
 import io.ktor.client.request.url
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 import java.io.File
 
 @Stable
 sealed class RemotePatchBundle(name: String, id: Int, directory: File, val endpoint: String) :
-    PatchBundleSource(name, id, directory), KoinComponent {
-    private val configRepository: PatchBundlePersistenceRepository by inject()
+    PatchBundleSource(name, id, directory) {
     protected val http: HttpService by inject()
 
-    protected abstract suspend fun getLatestInfo(): BundleInfo
+    protected abstract suspend fun getLatestInfo(): ReVancedAsset
 
-    private suspend fun download(info: BundleInfo) = withContext(Dispatchers.IO) {
-        val (patches, integrations) = info
-        coroutineScope {
-            launch {
-                patchBundleOutputStream().use {
-                    http.streamTo(it) {
-                        url(patches.url)
-                    }
-                }
-            }
-
-            launch {
-                http.download(integrationsFile) {
-                    url(integrations.url)
-                }
+    private suspend fun download(info: ReVancedAsset) = withContext(Dispatchers.IO) {
+        patchBundleOutputStream().use {
+            http.streamTo(it) {
+                url(info.downloadUrl)
             }
         }
 
-        saveVersion(patches.version, integrations.version)
+        saveVersion(info.version)
         reload()
     }
 
@@ -58,29 +35,18 @@ sealed class RemotePatchBundle(name: String, id: Int, directory: File, val endpo
 
     suspend fun update(): Boolean = withContext(Dispatchers.IO) {
         val info = getLatestInfo()
-        if (hasInstalled() && VersionInfo(
-                info.patches.version,
-                info.integrations.version
-            ) == currentVersion()
-        ) {
+        if (hasInstalled() && info.version == currentVersion())
             return@withContext false
-        }
 
         download(info)
         true
     }
 
-    private suspend fun currentVersion() = configRepository.getProps(uid).first().versionInfo
-    private suspend fun saveVersion(patches: String, integrations: String) =
-        configRepository.updateVersion(uid, patches, integrations)
-
     suspend fun deleteLocalFiles() = withContext(Dispatchers.Default) {
-        arrayOf(patchesFile, integrationsFile).forEach(File::delete)
+        patchesFile.delete()
         reload()
     }
 
-    fun propsFlow() = configRepository.getProps(uid)
-
     suspend fun setAutoUpdate(value: Boolean) = configRepository.setAutoUpdate(uid, value)
 
     companion object {
@@ -91,7 +57,7 @@ sealed class RemotePatchBundle(name: String, id: Int, directory: File, val endpo
 class JsonPatchBundle(name: String, id: Int, directory: File, endpoint: String) :
     RemotePatchBundle(name, id, directory, endpoint) {
     override suspend fun getLatestInfo() = withContext(Dispatchers.IO) {
-        http.request<BundleInfo> {
+        http.request<ReVancedAsset> {
             url(endpoint)
         }.getOrThrow()
     }
@@ -101,22 +67,5 @@ class APIPatchBundle(name: String, id: Int, directory: File, endpoint: String) :
     RemotePatchBundle(name, id, directory, endpoint) {
     private val api: ReVancedAPI by inject()
 
-    override suspend fun getLatestInfo() = coroutineScope {
-        fun getAssetAsync(repo: String, mime: String) = async(Dispatchers.IO) {
-            api
-                .getLatestRelease(repo)
-                .getOrThrow()
-                .let {
-                    BundleAsset(it.version, it.findAssetByType(mime).downloadUrl)
-                }
-        }
-
-        val patches = getAssetAsync("revanced-patches", JAR_MIMETYPE)
-        val integrations = getAssetAsync("revanced-integrations", APK_MIMETYPE)
-
-        BundleInfo(
-            patches.await(),
-            integrations.await()
-        )
-    }
+    override suspend fun getLatestInfo() = api.getPatchesUpdate().getOrThrow()
 }

app/src/main/java/app/revanced/manager/domain/installer/RootInstaller.kt

@@ -1,49 +1,97 @@
 package app.revanced.manager.domain.installer
 
 import android.app.Application
-import app.revanced.manager.service.RootConnection
+import android.content.ComponentName
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.IBinder
+import app.revanced.manager.IRootSystemService
+import app.revanced.manager.service.ManagerRootService
 import app.revanced.manager.util.PM
 import com.topjohnwu.superuser.Shell
+import com.topjohnwu.superuser.ipc.RootService
+import com.topjohnwu.superuser.nio.FileSystemManager
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.time.withTimeoutOrNull
 import kotlinx.coroutines.withContext
 import java.io.File
+import java.time.Duration
 
 class RootInstaller(
     private val app: Application,
-    private val rootConnection: RootConnection,
     private val pm: PM
-) {
+) : ServiceConnection {
+    private var remoteFS = CompletableDeferred<FileSystemManager>()
+
+    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
+        val ipc = IRootSystemService.Stub.asInterface(service)
+        val binder = ipc.fileSystemService
+
+        remoteFS.complete(FileSystemManager.getRemote(binder))
+    }
+
+    override fun onServiceDisconnected(name: ComponentName?) {
+        remoteFS = CompletableDeferred()
+    }
+
+    private suspend fun awaitRemoteFS(): FileSystemManager {
+        if (remoteFS.isActive) {
+            withContext(Dispatchers.Main) {
+                val intent = Intent(app, ManagerRootService::class.java)
+                RootService.bind(intent, this@RootInstaller)
+            }
+        }
+
+        return withTimeoutOrNull(Duration.ofSeconds(20L)) {
+            remoteFS.await()
+        } ?: throw RootServiceException()
+    }
+
+    private suspend fun getShell() = with(CompletableDeferred<Shell>()) {
+        Shell.getShell(::complete)
+
+        await()
+    }
+
+    suspend fun execute(vararg commands: String) = getShell().newJob().add(*commands).exec()
+
     fun hasRootAccess() = Shell.isAppGrantedRoot() ?: false
 
-    fun isAppInstalled(packageName: String) =
-        rootConnection.remoteFS?.getFile("$modulesPath/$packageName-revanced")
-            ?.exists() ?: throw RootServiceException()
+    fun isDeviceRooted() = System.getenv("PATH")?.split(":")?.any { path ->
+        File(path, "su").canExecute()
+    } ?: false
 
-    fun isAppMounted(packageName: String): Boolean {
-        return pm.getPackageInfo(packageName)?.applicationInfo?.sourceDir?.let {
-            Shell.cmd("mount | grep \"$it\"").exec().isSuccess
+    suspend fun isAppInstalled(packageName: String) =
+        awaitRemoteFS().getFile("$modulesPath/$packageName-revanced").exists()
+
+    suspend fun isAppMounted(packageName: String) = withContext(Dispatchers.IO) {
+        pm.getPackageInfo(packageName)?.applicationInfo?.sourceDir?.let {
+            execute("mount | grep \"$it\"").isSuccess
         } ?: false
     }
 
-    fun mount(packageName: String) {
+    suspend fun mount(packageName: String) {
         if (isAppMounted(packageName)) return
 
-        val stockAPK = pm.getPackageInfo(packageName)?.applicationInfo?.sourceDir
-            ?: throw Exception("Failed to load application info")
-        val patchedAPK = "$modulesPath/$packageName-revanced/$packageName.apk"
+        withContext(Dispatchers.IO) {
+            val stockAPK = pm.getPackageInfo(packageName)?.applicationInfo?.sourceDir
+                ?: throw Exception("Failed to load application info")
+            val patchedAPK = "$modulesPath/$packageName-revanced/$packageName.apk"
 
-        Shell.cmd("mount -o bind \"$patchedAPK\" \"$stockAPK\"").exec()
-            .also { if (!it.isSuccess) throw Exception("Failed to mount APK") }
+            execute("mount -o bind \"$patchedAPK\" \"$stockAPK\"").assertSuccess("Failed to mount APK")
+        }
     }
 
-    fun unmount(packageName: String) {
+    suspend fun unmount(packageName: String) {
         if (!isAppMounted(packageName)) return
 
-        val stockAPK = pm.getPackageInfo(packageName)?.applicationInfo?.sourceDir
-            ?: throw Exception("Failed to load application info")
+        withContext(Dispatchers.IO) {
+            val stockAPK = pm.getPackageInfo(packageName)?.applicationInfo?.sourceDir
+                ?: throw Exception("Failed to load application info")
 
-        Shell.cmd("umount -l \"$stockAPK\"").exec()
-            .also { if (!it.isSuccess) throw Exception("Failed to unmount APK") }
+            execute("umount -l \"$stockAPK\"").assertSuccess("Failed to unmount APK")
+        }
     }
 
     suspend fun install(
@@ -52,80 +100,82 @@ class RootInstaller(
         packageName: String,
         version: String,
         label: String
-    ) {
-        withContext(Dispatchers.IO) {
-            rootConnection.remoteFS?.let { remoteFS ->
-                val assets = app.assets
-                val modulePath = "$modulesPath/$packageName-revanced"
+    ) = withContext(Dispatchers.IO) {
+        val remoteFS = awaitRemoteFS()
+        val assets = app.assets
+        val modulePath = "$modulesPath/$packageName-revanced"
 
-                unmount(packageName)
+        unmount(packageName)
 
-                stockAPK?.let { stockApp ->
-                    pm.getPackageInfo(packageName)?.let { packageInfo ->
-                        if (packageInfo.versionName <= version)
-                            Shell.cmd("pm uninstall -k --user 0 $packageName").exec()
-                                .also { if (!it.isSuccess) throw Exception("Failed to uninstall stock app") }
+        stockAPK?.let { stockApp ->
+            pm.getPackageInfo(packageName)?.let { packageInfo ->
+                // TODO: get user id programmatically
+                if (pm.getVersionCode(packageInfo) <= pm.getVersionCode(
+                        pm.getPackageInfo(patchedAPK)
+                            ?: error("Failed to get package info for patched app")
+                    )
+                )
+                    execute("pm uninstall -k --user 0 $packageName").assertSuccess("Failed to uninstall stock app")
+            }
+
+            execute("pm install \"${stockApp.absolutePath}\"").assertSuccess("Failed to install stock app")
+        }
+
+        remoteFS.getFile(modulePath).mkdir()
+
+        listOf(
+            "service.sh",
+            "module.prop",
+        ).forEach { file ->
+            assets.open("root/$file").use { inputStream ->
+                remoteFS.getFile("$modulePath/$file").newOutputStream()
+                    .use { outputStream ->
+                        val content = String(inputStream.readBytes())
+                            .replace("__PKG_NAME__", packageName)
+                            .replace("__VERSION__", version)
+                            .replace("__LABEL__", label)
+                            .toByteArray()
+
+                        outputStream.write(content)
                     }
+            }
+        }
 
-                    Shell.cmd("pm install \"${stockApp.absolutePath}\"").exec()
-                        .also { if (!it.isSuccess) throw Exception("Failed to install stock app") }
-                }
+        "$modulePath/$packageName.apk".let { apkPath ->
 
-                remoteFS.getFile(modulePath).mkdir()
-
-                listOf(
-                    "service.sh",
-                    "module.prop",
-                ).forEach { file ->
-                    assets.open("root/$file").use { inputStream ->
-                        remoteFS.getFile("$modulePath/$file").newOutputStream()
-                            .use { outputStream ->
-                                val content = String(inputStream.readBytes())
-                                    .replace("__PKG_NAME__", packageName)
-                                    .replace("__VERSION__", version)
-                                    .replace("__LABEL__", label)
-                                    .toByteArray()
-
-                                outputStream.write(content)
-                            }
+            remoteFS.getFile(patchedAPK.absolutePath)
+                .also { if (!it.exists()) throw Exception("File doesn't exist") }
+                .newInputStream().use { inputStream ->
+                    remoteFS.getFile(apkPath).newOutputStream().use { outputStream ->
+                        inputStream.copyTo(outputStream)
                     }
                 }
 
-                "$modulePath/$packageName.apk".let { apkPath ->
-
-                    remoteFS.getFile(patchedAPK.absolutePath)
-                        .also { if (!it.exists()) throw Exception("File doesn't exist") }
-                        .newInputStream().use { inputStream ->
-                        remoteFS.getFile(apkPath).newOutputStream().use { outputStream ->
-                            inputStream.copyTo(outputStream)
-                        }
-                    }
-
-                    Shell.cmd(
-                        "chmod 644 $apkPath",
-                        "chown system:system $apkPath",
-                        "chcon u:object_r:apk_data_file:s0 $apkPath",
-                        "chmod +x $modulePath/service.sh"
-                    ).exec()
-                        .let { if (!it.isSuccess) throw Exception("Failed to set file permissions") }
-                }
-            } ?: throw RootServiceException()
+            execute(
+                "chmod 644 $apkPath",
+                "chown system:system $apkPath",
+                "chcon u:object_r:apk_data_file:s0 $apkPath",
+                "chmod +x $modulePath/service.sh"
+            ).assertSuccess("Failed to set file permissions")
         }
     }
 
-    fun uninstall(packageName: String) {
-        rootConnection.remoteFS?.let { remoteFS ->
-            if (isAppMounted(packageName))
-                unmount(packageName)
+    suspend fun uninstall(packageName: String) {
+        val remoteFS = awaitRemoteFS()
+        if (isAppMounted(packageName))
+            unmount(packageName)
 
-            remoteFS.getFile("$modulesPath/$packageName-revanced").deleteRecursively()
-                .also { if (!it) throw Exception("Failed to delete files") }
-        } ?: throw RootServiceException()
+        remoteFS.getFile("$modulesPath/$packageName-revanced").deleteRecursively()
+            .also { if (!it) throw Exception("Failed to delete files") }
     }
 
     companion object {
         const val modulesPath = "/data/adb/modules"
+
+        private fun Shell.Result.assertSuccess(errorMessage: String) {
+            if (!isSuccess) throw Exception(errorMessage)
+        }
     }
 }
 
-class RootServiceException: Exception("Root not available")
+class RootServiceException : Exception("Root not available")

app/src/main/java/app/revanced/manager/domain/manager/KeystoreManager.kt

@@ -12,6 +12,8 @@ import java.io.InputStream
 import java.io.OutputStream
 import java.nio.file.Files
 import java.security.UnrecoverableKeyException
+import java.util.Date
+import kotlin.time.Duration.Companion.days
 
 class KeystoreManager(app: Application, private val prefs: PreferencesManager) {
     companion object Constants {
@@ -19,6 +21,7 @@ class KeystoreManager(app: Application, private val prefs: PreferencesManager) {
          * Default alias and password for the keystore.
          */
         const val DEFAULT = "ReVanced"
+        private val eightYearsFromNow get() = Date(System.currentTimeMillis() + (365.days * 8).inWholeMilliseconds * 24)
     }
 
     private val keystorePath =
@@ -29,40 +32,45 @@ class KeystoreManager(app: Application, private val prefs: PreferencesManager) {
         prefs.keystorePass.value = pass
     }
 
-    private suspend fun signingOptions(path: File = keystorePath) = ApkUtils.SigningOptions(
+    private suspend fun signingDetails(path: File = keystorePath) = ApkUtils.KeyStoreDetails(
         keyStore = path,
         keyStorePassword = null,
         alias = prefs.keystoreCommonName.get(),
-        signer = prefs.keystoreCommonName.get(),
         password = prefs.keystorePass.get()
     )
 
     suspend fun sign(input: File, output: File) = withContext(Dispatchers.Default) {
-        ApkUtils.sign(input, output, signingOptions())
+        ApkUtils.signApk(input, output, prefs.keystoreCommonName.get(), signingDetails())
     }
 
     suspend fun regenerate() = withContext(Dispatchers.Default) {
+        val keyCertPair = ApkSigner.newPrivateKeyCertificatePair(
+            prefs.keystoreCommonName.get(),
+            eightYearsFromNow
+        )
         val ks = ApkSigner.newKeyStore(
-            listOf(
+            setOf(
                 ApkSigner.KeyStoreEntry(
-                    DEFAULT, DEFAULT
+                    DEFAULT, DEFAULT, keyCertPair
                 )
             )
         )
-        keystorePath.outputStream().use {
-            ks.store(it, null)
+        withContext(Dispatchers.IO) {
+            keystorePath.outputStream().use {
+                ks.store(it, null)
+            }
         }
 
         updatePrefs(DEFAULT, DEFAULT)
     }
 
     suspend fun import(cn: String, pass: String, keystore: InputStream): Boolean {
-        val keystoreData = keystore.readBytes()
+        val keystoreData = withContext(Dispatchers.IO) { keystore.readBytes() }
 
         try {
             val ks = ApkSigner.readKeyStore(ByteArrayInputStream(keystoreData), null)
 
-            ApkSigner.readKeyCertificatePair(ks, cn, pass)
+            ApkSigner.readPrivateKeyCertificatePair(ks, cn, pass)
         } catch (_: UnrecoverableKeyException) {
             return false
         } catch (_: IllegalArgumentException) {

app/src/main/java/app/revanced/manager/domain/manager/PreferencesManager.kt

@@ -3,6 +3,7 @@ package app.revanced.manager.domain.manager
 import android.content.Context
 import app.revanced.manager.domain.manager.base.BasePreferencesManager
 import app.revanced.manager.ui.theme.Theme
+import app.revanced.manager.util.isDebuggable
 
 class PreferencesManager(
     context: Context
@@ -12,17 +13,22 @@ class PreferencesManager(
 
     val api = stringPreference("api_url", "https://api.revanced.app")
 
-    val multithreadingDexFileWriter = booleanPreference("multithreading_dex_file_writer", true)
-    val disablePatchVersionCompatCheck = booleanPreference("disable_patch_version_compatibility_check", false)
+    val useProcessRuntime = booleanPreference("use_process_runtime", false)
+    val patcherProcessMemoryLimit = intPreference("process_runtime_memory_limit", 700)
 
     val keystoreCommonName = stringPreference("keystore_cn", KeystoreManager.DEFAULT)
     val keystorePass = stringPreference("keystore_pass", KeystoreManager.DEFAULT)
 
-    val preferSplits = booleanPreference("prefer_splits", false)
-
     val firstLaunch = booleanPreference("first_launch", true)
     val managerAutoUpdates = booleanPreference("manager_auto_updates", false)
+    val showManagerUpdateDialogOnLaunch = booleanPreference("show_manager_update_dialog_on_launch", true)
 
+    val disablePatchVersionCompatCheck = booleanPreference("disable_patch_version_compatibility_check", false)
     val disableSelectionWarning = booleanPreference("disable_selection_warning", false)
-    val enableSelectionWarningCountdown = booleanPreference("enable_selection_warning_countdown", true)
+    val disableUniversalPatchWarning = booleanPreference("disable_universal_patch_warning", false)
+    val suggestedVersionSafeguard = booleanPreference("suggested_version_safeguard", true)
+
+    val acknowledgedDownloaderPlugins = stringSetPreference("acknowledged_downloader_plugins", emptySet())
+
+    val showDeveloperSettings = booleanPreference("show_developer_settings", context.isDebuggable)
 }

app/src/main/java/app/revanced/manager/domain/manager/base/BasePreferencesManager.kt

@@ -26,6 +26,9 @@ abstract class BasePreferencesManager(private val context: Context, name: String
     protected fun stringPreference(key: String, default: String) =
         StringPreference(dataStore, key, default)
 
+    protected fun stringSetPreference(key: String, default: Set<String>) =
+        StringSetPreference(dataStore, key, default)
+
     protected fun booleanPreference(key: String, default: Boolean) =
         BooleanPreference(dataStore, key, default)
 
@@ -52,11 +55,15 @@ class EditorContext(private val prefs: MutablePreferences) {
     var <T> Preference<T>.value
         get() = prefs.run { read() }
         set(value) = prefs.run { write(value) }
+
+    operator fun Preference<Set<String>>.plusAssign(value: String) = prefs.run {
+        write(read() + value)
+    }
 }
 
 abstract class Preference<T>(
     private val dataStore: DataStore<Preferences>,
-    protected val default: T
+    val default: T
 ) {
     internal abstract fun Preferences.read(): T
     internal abstract fun MutablePreferences.write(value: T)
@@ -65,10 +72,12 @@ abstract class Preference<T>(
 
     suspend fun get() = flow.first()
     fun getBlocking() = runBlocking { get() }
+
     @Composable
     fun getAsState() = flow.collectAsStateWithLifecycle(initialValue = remember {
         getBlocking()
     })
+
     suspend fun update(value: T) = dataStore.editor {
         this@Preference.value = value
     }
@@ -108,6 +117,14 @@ class StringPreference(
     override val key = stringPreferencesKey(key)
 }
 
+class StringSetPreference(
+    dataStore: DataStore<Preferences>,
+    key: String,
+    default: Set<String>
+) : BasePreference<Set<String>>(dataStore, default) {
+    override val key = stringSetPreferencesKey(key)
+}
+
 class BooleanPreference(
     dataStore: DataStore<Preferences>,
     key: String,

app/src/main/java/app/revanced/manager/domain/repository/DownloadedAppRepository.kt

@@ -2,56 +2,126 @@ package app.revanced.manager.domain.repository
 
 import android.app.Application
 import android.content.Context
+import android.os.Parcelable
 import app.revanced.manager.data.room.AppDatabase
 import app.revanced.manager.data.room.AppDatabase.Companion.generateUid
 import app.revanced.manager.data.room.apps.downloaded.DownloadedApp
-import app.revanced.manager.network.downloader.AppDownloader
+import app.revanced.manager.network.downloader.LoadedDownloaderPlugin
+import app.revanced.manager.plugin.downloader.OutputDownloadScope
+import app.revanced.manager.util.PM
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.flow.conflate
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flowOn
 import java.io.File
+import java.io.FilterOutputStream
+import java.nio.file.StandardOpenOption
+import java.util.concurrent.atomic.AtomicLong
+import kotlin.io.path.outputStream
 
 class DownloadedAppRepository(
-    app: Application,
-    db: AppDatabase
+    private val app: Application,
+    db: AppDatabase,
+    private val pm: PM
 ) {
     private val dir = app.getDir("downloaded-apps", Context.MODE_PRIVATE)
     private val dao = db.downloadedAppDao()
 
     fun getAll() = dao.getAllApps().distinctUntilChanged()
 
-    fun getApkFileForApp(app: DownloadedApp): File = getApkFileForDir(dir.resolve(app.directory))
+    fun getApkFileForApp(app: DownloadedApp): File =
+        getApkFileForDir(dir.resolve(app.directory))
+
     private fun getApkFileForDir(directory: File) = directory.listFiles()!!.first()
 
     suspend fun download(
-        app: AppDownloader.App,
-        preferSplits: Boolean,
-        onDownload: suspend (downloadProgress: Pair<Float, Float>?) -> Unit = {},
+        plugin: LoadedDownloaderPlugin,
+        data: Parcelable,
+        expectedPackageName: String,
+        expectedVersion: String?,
+        onDownload: suspend (downloadProgress: Pair<Long, Long?>) -> Unit,
     ): File {
-        this.get(app.packageName, app.version)?.let { downloaded ->
-            return getApkFileForApp(downloaded)
-        }
-
         // Converted integers cannot contain / or .. unlike the package name or version, so they are safer to use here.
         val relativePath = File(generateUid().toString())
-        val savePath = dir.resolve(relativePath).also { it.mkdirs() }
+        val saveDir = dir.resolve(relativePath).also { it.mkdirs() }
+        val targetFile = saveDir.resolve("base.apk").toPath()
 
         try {
-            app.download(savePath, preferSplits, onDownload)
+            val downloadSize = AtomicLong(0)
+            val downloadedBytes = AtomicLong(0)
 
-            dao.insert(DownloadedApp(
-                packageName = app.packageName,
-                version = app.version,
-                directory = relativePath,
-            ))
+            channelFlow {
+                val scope = object : OutputDownloadScope {
+                    override val pluginPackageName = plugin.packageName
+                    override val hostPackageName = app.packageName
+                    override suspend fun reportSize(size: Long) {
+                        require(size > 0) { "Size must be greater than zero" }
+                        require(
+                            downloadSize.compareAndSet(
+                                0,
+                                size
+                            )
+                        ) { "Download size has already been set" }
+                        send(downloadedBytes.get() to size)
+                    }
+                }
+
+                fun emitProgress(bytes: Long) {
+                    val newValue = downloadedBytes.addAndGet(bytes)
+                    val totalSize = downloadSize.get()
+                    if (totalSize < 1) return
+                    trySend(newValue to totalSize).getOrThrow()
+                }
+
+                targetFile.outputStream(StandardOpenOption.CREATE_NEW).buffered().use {
+                    val stream = object : FilterOutputStream(it) {
+                        override fun write(b: Int) = out.write(b).also { emitProgress(1) }
+
+                        override fun write(b: ByteArray?, off: Int, len: Int) =
+                            out.write(b, off, len).also {
+                                emitProgress(
+                                    (len - off).toLong()
+                                )
+                            }
+                    }
+                    plugin.download(scope, data, stream)
+                }
+            }
+                .conflate()
+                .flowOn(Dispatchers.IO)
+                .collect { (downloaded, size) -> onDownload(downloaded to size) }
+
+            if (downloadedBytes.get() < 1) error("Downloader did not download anything.")
+            val pkgInfo =
+                pm.getPackageInfo(targetFile.toFile()) ?: error("Downloaded APK file is invalid")
+            if (pkgInfo.packageName != expectedPackageName) error("Downloaded APK has the wrong package name. Expected: $expectedPackageName, Actual: ${pkgInfo.packageName}")
+            if (expectedVersion != null && pkgInfo.versionName != expectedVersion) error("Downloaded APK has the wrong version. Expected: $expectedVersion, Actual: ${pkgInfo.versionName}")
+
+            // Delete the previous copy (if present).
+            dao.get(pkgInfo.packageName, pkgInfo.versionName!!)?.directory?.let {
+                if (!dir.resolve(it).deleteRecursively()) throw Exception("Failed to delete existing directory")
+            }
+            dao.upsert(
+                DownloadedApp(
+                    packageName = pkgInfo.packageName,
+                    version = pkgInfo.versionName!!,
+                    directory = relativePath,
+                )
+            )
         } catch (e: Exception) {
-            savePath.deleteRecursively()
+            saveDir.deleteRecursively()
             throw e
         }
 
         // Return the Apk file.
-        return getApkFileForDir(savePath)
+        return getApkFileForDir(saveDir)
     }
 
-    suspend fun get(packageName: String, version: String) = dao.get(packageName, version)
+    suspend fun get(packageName: String, version: String, markUsed: Boolean = false) =
+        dao.get(packageName, version)?.also {
+            if (markUsed) dao.markUsed(packageName, version)
+        }
 
     suspend fun delete(downloadedApps: Collection<DownloadedApp>) {
         downloadedApps.forEach {

app/src/main/java/app/revanced/manager/domain/repository/DownloaderPluginRepository.kt

@@ -0,0 +1,168 @@
+package app.revanced.manager.domain.repository
+
+import android.app.Application
+import android.content.pm.PackageManager
+import android.os.Parcelable
+import android.util.Log
+import app.revanced.manager.data.room.AppDatabase
+import app.revanced.manager.data.room.plugins.TrustedDownloaderPlugin
+import app.revanced.manager.domain.manager.PreferencesManager
+import app.revanced.manager.network.downloader.DownloaderPluginState
+import app.revanced.manager.network.downloader.LoadedDownloaderPlugin
+import app.revanced.manager.network.downloader.ParceledDownloaderData
+import app.revanced.manager.plugin.downloader.DownloaderBuilder
+import app.revanced.manager.plugin.downloader.PluginHostApi
+import app.revanced.manager.plugin.downloader.Scope
+import app.revanced.manager.util.PM
+import app.revanced.manager.util.tag
+import dalvik.system.PathClassLoader
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.withContext
+import java.lang.reflect.Modifier
+
+@OptIn(PluginHostApi::class)
+class DownloaderPluginRepository(
+    private val pm: PM,
+    private val prefs: PreferencesManager,
+    private val app: Application,
+    db: AppDatabase
+) {
+    private val trustDao = db.trustedDownloaderPluginDao()
+    private val _pluginStates = MutableStateFlow(emptyMap<String, DownloaderPluginState>())
+    val pluginStates = _pluginStates.asStateFlow()
+    val loadedPluginsFlow = pluginStates.map { states ->
+        states.values.filterIsInstance<DownloaderPluginState.Loaded>().map { it.plugin }
+    }
+
+    private val acknowledgedDownloaderPlugins = prefs.acknowledgedDownloaderPlugins
+    private val installedPluginPackageNames = MutableStateFlow(emptySet<String>())
+    val newPluginPackageNames = combine(
+        installedPluginPackageNames,
+        acknowledgedDownloaderPlugins.flow
+    ) { installed, acknowledged ->
+        installed subtract acknowledged
+    }
+
+    suspend fun reload() {
+        val plugins =
+            withContext(Dispatchers.IO) {
+                pm.getPackagesWithFeature(PLUGIN_FEATURE)
+                    .associate { it.packageName to loadPlugin(it.packageName) }
+            }
+
+        _pluginStates.value = plugins
+        installedPluginPackageNames.value = plugins.keys
+
+        val acknowledgedPlugins = acknowledgedDownloaderPlugins.get()
+        val uninstalledPlugins = acknowledgedPlugins subtract installedPluginPackageNames.value
+        if (uninstalledPlugins.isNotEmpty()) {
+            Log.d(tag, "Uninstalled plugins: ${uninstalledPlugins.joinToString(", ")}")
+            acknowledgedDownloaderPlugins.update(acknowledgedPlugins subtract uninstalledPlugins)
+            trustDao.removeAll(uninstalledPlugins)
+        }
+    }
+
+    fun unwrapParceledData(data: ParceledDownloaderData): Pair<LoadedDownloaderPlugin, Parcelable> {
+        val plugin =
+            (_pluginStates.value[data.pluginPackageName] as? DownloaderPluginState.Loaded)?.plugin
+                ?: throw Exception("Downloader plugin with name ${data.pluginPackageName} is not available")
+
+        return plugin to data.unwrapWith(plugin)
+    }
+
+    private suspend fun loadPlugin(packageName: String): DownloaderPluginState {
+        try {
+            if (!verify(packageName)) return DownloaderPluginState.Untrusted
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            Log.e(tag, "Got exception while verifying plugin $packageName", e)
+            return DownloaderPluginState.Failed(e)
+        }
+
+        return try {
+            val packageInfo = pm.getPackageInfo(packageName, flags = PackageManager.GET_META_DATA)!!
+            val className = packageInfo.applicationInfo!!.metaData.getString(METADATA_PLUGIN_CLASS)
+                ?: throw Exception("Missing metadata attribute $METADATA_PLUGIN_CLASS")
+
+            val classLoader =
+                PathClassLoader(packageInfo.applicationInfo!!.sourceDir, app.classLoader)
+            val pluginContext = app.createPackageContext(packageName, 0)
+
+            val downloader = classLoader
+                .loadClass(className)
+                .getDownloaderBuilder()
+                .build(
+                    scopeImpl = object : Scope {
+                        override val hostPackageName = app.packageName
+                        override val pluginPackageName = pluginContext.packageName
+                    },
+                    context = pluginContext
+                )
+
+            DownloaderPluginState.Loaded(
+                LoadedDownloaderPlugin(
+                    packageName,
+                    with(pm) { packageInfo.label() },
+                    packageInfo.versionName!!,
+                    downloader.get,
+                    downloader.download,
+                    classLoader
+                )
+            )
+        } catch (e: CancellationException) {
+            throw e
+        } catch (t: Throwable) {
+            Log.e(tag, "Failed to load plugin $packageName", t)
+            DownloaderPluginState.Failed(t)
+        }
+    }
+
+    suspend fun trustPackage(packageName: String) {
+        trustDao.upsertTrust(
+            TrustedDownloaderPlugin(
+                packageName,
+                pm.getSignature(packageName).toByteArray()
+            )
+        )
+
+        reload()
+        prefs.edit {
+            acknowledgedDownloaderPlugins += packageName
+        }
+    }
+
+    suspend fun revokeTrustForPackage(packageName: String) =
+        trustDao.remove(packageName).also { reload() }
+
+    suspend fun acknowledgeAllNewPlugins() =
+        acknowledgedDownloaderPlugins.update(installedPluginPackageNames.value)
+
+    private suspend fun verify(packageName: String): Boolean {
+        val expectedSignature =
+            trustDao.getTrustedSignature(packageName) ?: return false
+
+        return pm.hasSignature(packageName, expectedSignature)
+    }
+
+    private companion object {
+        const val PLUGIN_FEATURE = "app.revanced.manager.plugin.downloader"
+        const val METADATA_PLUGIN_CLASS = "app.revanced.manager.plugin.downloader.class"
+
+        const val PUBLIC_STATIC = Modifier.PUBLIC or Modifier.STATIC
+        val Int.isPublicStatic get() = (this and PUBLIC_STATIC) == PUBLIC_STATIC
+        val Class<*>.isDownloaderBuilder get() = DownloaderBuilder::class.java.isAssignableFrom(this)
+
+        @Suppress("UNCHECKED_CAST")
+        fun Class<*>.getDownloaderBuilder() =
+            declaredMethods
+                .firstOrNull { it.modifiers.isPublicStatic && it.returnType.isDownloaderBuilder && it.parameterTypes.isEmpty() }
+                ?.let { it(null) as DownloaderBuilder<Parcelable> }
+                ?: throw Exception("Could not find a valid downloader implementation in class $canonicalName")
+    }
+}

app/src/main/java/app/revanced/manager/domain/repository/PatchBundlePersistenceRepository.kt

@@ -4,8 +4,6 @@ import app.revanced.manager.data.room.AppDatabase
 import app.revanced.manager.data.room.AppDatabase.Companion.generateUid
 import app.revanced.manager.data.room.bundles.PatchBundleEntity
 import app.revanced.manager.data.room.bundles.Source
-import app.revanced.manager.data.room.bundles.VersionInfo
-import io.ktor.http.*
 import kotlinx.coroutines.flow.distinctUntilChanged
 
 class PatchBundlePersistenceRepository(db: AppDatabase) {
@@ -23,12 +21,11 @@ class PatchBundlePersistenceRepository(db: AppDatabase) {
 
     suspend fun reset() = dao.reset()
 
-
     suspend fun create(name: String, source: Source, autoUpdate: Boolean = false) =
         PatchBundleEntity(
             uid = generateUid(),
             name = name,
-            versionInfo = VersionInfo(),
+            version = null,
             source = source,
             autoUpdate = autoUpdate
         ).also {
@@ -37,18 +34,20 @@ class PatchBundlePersistenceRepository(db: AppDatabase) {
 
     suspend fun delete(uid: Int) = dao.remove(uid)
 
-    suspend fun updateVersion(uid: Int, patches: String, integrations: String) =
-        dao.updateVersion(uid, patches, integrations)
+    suspend fun updateVersion(uid: Int, version: String?) =
+        dao.updateVersion(uid, version)
 
     suspend fun setAutoUpdate(uid: Int, value: Boolean) = dao.setAutoUpdate(uid, value)
 
+    suspend fun setName(uid: Int, name: String) = dao.setName(uid, name)
+
     fun getProps(id: Int) = dao.getPropsById(id).distinctUntilChanged()
 
     private companion object {
         val defaultSource = PatchBundleEntity(
             uid = 0,
-            name = "Main",
-            versionInfo = VersionInfo(),
+            name = "",
+            version = null,
             source = Source.API,
             autoUpdate = false
         )

app/src/main/java/app/revanced/manager/domain/repository/PatchBundleRepository.kt

@@ -3,6 +3,7 @@ package app.revanced.manager.domain.repository
 import android.app.Application
 import android.content.Context
 import android.util.Log
+import app.revanced.library.mostCommonCompatibleVersions
 import app.revanced.manager.R
 import app.revanced.manager.data.platform.NetworkInfo
 import app.revanced.manager.data.room.bundles.PatchBundleEntity
@@ -12,6 +13,8 @@ import app.revanced.manager.data.room.bundles.Source as SourceInfo
 import app.revanced.manager.domain.bundles.LocalPatchBundle
 import app.revanced.manager.domain.bundles.RemotePatchBundle
 import app.revanced.manager.domain.bundles.PatchBundleSource
+import app.revanced.manager.domain.manager.PreferencesManager
+import app.revanced.manager.patcher.patch.PatchInfo
 import app.revanced.manager.util.flatMapLatestAndCombine
 import app.revanced.manager.util.tag
 import app.revanced.manager.util.uiSafe
@@ -29,6 +32,7 @@ class PatchBundleRepository(
     private val app: Application,
     private val persistenceRepo: PatchBundlePersistenceRepository,
     private val networkInfo: NetworkInfo,
+    private val prefs: PreferencesManager,
 ) {
     private val bundlesDir = app.getDir("patch_bundles", Context.MODE_PRIVATE)
 
@@ -47,6 +51,37 @@ class PatchBundleRepository(
         it.state.map { state -> it.uid to state }
     }
 
+    val suggestedVersions = bundles.map {
+        val allPatches =
+            it.values.flatMap { bundle -> bundle.patches.map(PatchInfo::toPatcherPatch) }.toSet()
+
+        allPatches.mostCommonCompatibleVersions(countUnusedPatches = true)
+            .mapValues { (_, versions) ->
+                if (versions.keys.size < 2)
+                    return@mapValues versions.keys.firstOrNull()
+
+                // The entries are ordered from most compatible to least compatible.
+                // If there are entries with the same number of compatible patches, older versions will be first, which is undesirable.
+                // This means we have to pick the last entry we find that has the highest patch count.
+                // The order may change in future versions of ReVanced Library.
+                var currentHighestPatchCount = -1
+                versions.entries.last { (_, patchCount) ->
+                    if (patchCount >= currentHighestPatchCount) {
+                        currentHighestPatchCount = patchCount
+                        true
+                    } else false
+                }.key
+            }
+    }
+
+    suspend fun isVersionAllowed(packageName: String, version: String) =
+        withContext(Dispatchers.Default) {
+            if (!prefs.suggestedVersionSafeguard.get()) return@withContext true
+
+            val suggestedVersion = suggestedVersions.first()[packageName] ?: return@withContext true
+            suggestedVersion == version
+        }
+
     /**
      * Get the directory of the [PatchBundleSource] with the specified [uid], creating it if needed.
      */
@@ -102,16 +137,16 @@ class PatchBundleRepository(
     private fun addBundle(patchBundle: PatchBundleSource) =
         _sources.update { it.toMutableMap().apply { put(patchBundle.uid, patchBundle) } }
 
-    suspend fun createLocal(name: String, patches: InputStream, integrations: InputStream?) {
-        val id = persistenceRepo.create(name, SourceInfo.Local).uid
-        val bundle = LocalPatchBundle(name, id, directoryOf(id))
+    suspend fun createLocal(patches: InputStream) = withContext(Dispatchers.Default) {
+        val uid = persistenceRepo.create("", SourceInfo.Local).uid
+        val bundle = LocalPatchBundle("", uid, directoryOf(uid))
 
-        bundle.replace(patches, integrations)
+        bundle.replace(patches)
         addBundle(bundle)
     }
 
-    suspend fun createRemote(name: String, url: String, autoUpdate: Boolean) {
-        val entity = persistenceRepo.create(name, SourceInfo.from(url), autoUpdate)
+    suspend fun createRemote(url: String, autoUpdate: Boolean) = withContext(Dispatchers.Default) {
+        val entity = persistenceRepo.create("", SourceInfo.from(url), autoUpdate)
         addBundle(entity.load())
     }
 
@@ -139,8 +174,8 @@ class PatchBundleRepository(
 
                 getBundlesByType<RemotePatchBundle>().forEach {
                     launch {
-                        if (!it.propsFlow().first().autoUpdate) return@launch
-                        Log.d(tag, "Updating patch bundle: ${it.name}")
+                        if (!it.getProps().autoUpdate) return@launch
+                        Log.d(tag, "Updating patch bundle: ${it.getName()}")
                         it.update()
                     }
                 }

app/src/main/java/app/revanced/manager/domain/repository/PatchOptionsRepository.kt

@@ -1,18 +1,14 @@
 package app.revanced.manager.domain.repository
 
+import android.util.Log
 import app.revanced.manager.data.room.AppDatabase
 import app.revanced.manager.data.room.options.Option
 import app.revanced.manager.data.room.options.OptionGroup
+import app.revanced.manager.patcher.patch.PatchInfo
 import app.revanced.manager.util.Options
+import app.revanced.manager.util.tag
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.JsonNull
-import kotlinx.serialization.json.JsonPrimitive
-import kotlinx.serialization.json.booleanOrNull
-import kotlinx.serialization.json.floatOrNull
-import kotlinx.serialization.json.intOrNull
 
 class PatchOptionsRepository(db: AppDatabase) {
     private val dao = db.optionDao()
@@ -24,19 +20,37 @@ class PatchOptionsRepository(db: AppDatabase) {
             packageName = packageName
         ).also { dao.createOptionGroup(it) }.uid
 
-    suspend fun getOptions(packageName: String): Options {
+    suspend fun getOptions(
+        packageName: String,
+        bundlePatches: Map<Int, Map<String, PatchInfo>>
+    ): Options {
         val options = dao.getOptions(packageName)
         // Bundle -> Patches
         return buildMap<Int, MutableMap<String, MutableMap<String, Any?>>>(options.size) {
             options.forEach { (sourceUid, bundlePatchOptionsList) ->
                 // Patches -> Patch options
-                this[sourceUid] = bundlePatchOptionsList.fold(mutableMapOf()) { bundlePatchOptions, option ->
-                    val patchOptions = bundlePatchOptions.getOrPut(option.patchName, ::mutableMapOf)
+                this[sourceUid] =
+                    bundlePatchOptionsList.fold(mutableMapOf()) { bundlePatchOptions, dbOption ->
+                        val deserializedPatchOptions =
+                            bundlePatchOptions.getOrPut(dbOption.patchName, ::mutableMapOf)
 
-                    patchOptions[option.key] = deserialize(option.value)
+                        val option =
+                            bundlePatches[sourceUid]?.get(dbOption.patchName)?.options?.find { it.key == dbOption.key }
+                        if (option != null) {
+                            try {
+                                deserializedPatchOptions[option.key] =
+                                    dbOption.value.deserializeFor(option)
+                            } catch (e: Option.SerializationException) {
+                                Log.w(
+                                    tag,
+                                    "Option ${dbOption.patchName}:${option.key} could not be deserialized",
+                                    e
+                                )
+                            }
+                        }
 
-                    bundlePatchOptions
-                }
+                        bundlePatchOptions
+                    }
             }
         }
     }
@@ -47,8 +61,12 @@ class PatchOptionsRepository(db: AppDatabase) {
 
             groupId to bundlePatchOptions.flatMap { (patchName, patchOptions) ->
                 patchOptions.mapNotNull { (key, value) ->
-                    val serialized = serialize(value)
-                        ?: return@mapNotNull null // Don't save options that we can't serialize.
+                    val serialized = try {
+                        Option.SerializedValue.fromValue(value)
+                    } catch (e: Option.SerializationException) {
+                        Log.e(tag, "Option $patchName:$key could not be serialized", e)
+                        return@mapNotNull null
+                    }
 
                     Option(groupId, patchName, key, serialized)
                 }
@@ -61,29 +79,4 @@ class PatchOptionsRepository(db: AppDatabase) {
     suspend fun clearOptionsForPackage(packageName: String) = dao.clearForPackage(packageName)
     suspend fun clearOptionsForPatchBundle(uid: Int) = dao.clearForPatchBundle(uid)
     suspend fun reset() = dao.reset()
-
-    private companion object {
-        fun deserialize(value: String): Any? {
-            val primitive = Json.decodeFromString<JsonPrimitive>(value)
-
-            return when {
-                primitive.isString -> primitive.content
-                primitive is JsonNull -> null
-                else -> primitive.booleanOrNull ?: primitive.intOrNull ?: primitive.floatOrNull
-            }
-        }
-
-        fun serialize(value: Any?): String? {
-            val primitive = when (value) {
-                null -> JsonNull
-                is String -> JsonPrimitive(value)
-                is Int -> JsonPrimitive(value)
-                is Float -> JsonPrimitive(value)
-                is Boolean -> JsonPrimitive(value)
-                else -> return null
-            }
-
-            return Json.encodeToString(primitive)
-        }
-    }
 }

app/src/main/java/app/revanced/manager/network/api/ReVancedAPI.kt

@@ -2,34 +2,41 @@ package app.revanced.manager.network.api
 
 import android.os.Build
 import app.revanced.manager.domain.manager.PreferencesManager
-import app.revanced.manager.network.dto.ReVancedRelease
-import app.revanced.manager.network.service.ReVancedService
+import app.revanced.manager.network.dto.ReVancedAsset
+import app.revanced.manager.network.dto.ReVancedGitRepository
+import app.revanced.manager.network.dto.ReVancedInfo
+import app.revanced.manager.network.service.HttpService
+import app.revanced.manager.network.utils.APIResponse
 import app.revanced.manager.network.utils.getOrThrow
-import app.revanced.manager.network.utils.transform
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import io.ktor.client.request.url
 
 class ReVancedAPI(
-    private val service: ReVancedService,
+    private val client: HttpService,
     private val prefs: PreferencesManager
 ) {
     private suspend fun apiUrl() = prefs.api.get()
 
-    suspend fun getContributors() = service.getContributors(apiUrl()).transform { it.repositories }
+    private suspend inline fun <reified T> request(api: String, route: String): APIResponse<T> =
+        withContext(
+            Dispatchers.IO
+        ) {
+            client.request {
+                url("$api/v4/$route")
+            }
+        }
 
-    suspend fun getLatestRelease(name: String) =
-        service.getLatestRelease(apiUrl(), name).transform { it.release }
-
-    suspend fun getReleases(name: String) =
-        service.getReleases(apiUrl(), name).transform { it.releases }
+    private suspend inline fun <reified T> request(route: String) = request<T>(apiUrl(), route)
 
     suspend fun getAppUpdate() =
-        getLatestRelease("revanced-manager")
-            .getOrThrow()
-            .takeIf { it.version != Build.VERSION.RELEASE }
+        getLatestAppInfo().getOrThrow().takeIf { it.version != Build.VERSION.RELEASE }
 
-    companion object Extensions {
-        fun ReVancedRelease.findAssetByType(mime: String) =
-            assets.singleOrNull { it.contentType == mime } ?: throw MissingAssetException(mime)
-    }
-}
+    suspend fun getLatestAppInfo() = request<ReVancedAsset>("manager")
 
-class MissingAssetException(type: String) : Exception("No asset with type $type")
+    suspend fun getPatchesUpdate() = request<ReVancedAsset>("patches")
+
+    suspend fun getContributors() = request<List<ReVancedGitRepository>>("contributors")
+
+    suspend fun getInfo(api: String? = null) = request<ReVancedInfo>(api ?: apiUrl(), "about")
+}

app/src/main/java/app/revanced/manager/network/downloader/APKMirror.kt

@@ -1,276 +0,0 @@
-package app.revanced.manager.network.downloader
-
-import android.os.Build.SUPPORTED_ABIS
-import app.revanced.manager.network.service.HttpService
-import io.ktor.client.plugins.onDownload
-import io.ktor.client.request.parameter
-import io.ktor.client.request.url
-import it.skrape.selects.html5.a
-import it.skrape.selects.html5.div
-import it.skrape.selects.html5.form
-import it.skrape.selects.html5.h5
-import it.skrape.selects.html5.input
-import it.skrape.selects.html5.p
-import it.skrape.selects.html5.span
-import kotlinx.coroutines.flow.flow
-import kotlinx.parcelize.IgnoredOnParcel
-import kotlinx.parcelize.Parcelize
-import org.koin.core.component.KoinComponent
-import org.koin.core.component.get
-import org.koin.core.component.inject
-import java.io.File
-
-class APKMirror : AppDownloader, KoinComponent {
-    private val httpClient: HttpService = get()
-
-    enum class APKType {
-        APK,
-        BUNDLE
-    }
-
-    data class Variant(
-        val apkType: APKType,
-        val arch: String,
-        val link: String
-    )
-
-    private suspend fun getAppLink(packageName: String): String {
-        val searchResults = httpClient.getHtml { url("$apkMirror/?post_type=app_release&searchtype=app&s=$packageName") }
-            .div {
-                withId = "content"
-                findFirst {
-                    div {
-                        withClass = "listWidget"
-                        findAll {
-
-                            find {
-                                it.children.first().text.contains(packageName)
-                            }!!.children.mapNotNull {
-                                if (it.classNames.isEmpty()) {
-                                    it.h5 {
-                                        withClass = "appRowTitle"
-                                        findFirst {
-                                            a {
-                                                findFirst {
-                                                    attribute("href")
-                                                }
-                                            }
-                                        }
-                                    }
-                                } else null
-                            }
-
-                        }
-                    }
-                }
-            }
-
-        return searchResults.find { url ->
-            httpClient.getHtml { url(apkMirror + url) }
-                .div {
-                    withId = "primary"
-                    findFirst {
-                        div {
-                            withClass = "tab-buttons"
-                            findFirst {
-                                div {
-                                    withClass = "tab-button-positioning"
-                                    findFirst {
-                                        children.any {
-                                            it.attribute("href") == "https://play.google.com/store/apps/details?id=$packageName"
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-        } ?: throw Exception("App isn't available for download")
-    }
-
-    override fun getAvailableVersions(packageName: String, versionFilter: Set<String>) = flow<AppDownloader.App> {
-
-        // Vanced music uses the same package name so we have to hardcode...
-        val appCategory = if (packageName == "com.google.android.apps.youtube.music")
-            "youtube-music"
-        else
-            getAppLink(packageName).split("/")[3]
-
-        var page = 1
-
-        val versions = mutableListOf<String>()
-
-        while (
-            if (versionFilter.isNotEmpty())
-                versions.size < versionFilter.size && page <= 7
-            else
-                page <= 1
-        ) {
-            httpClient.getHtml {
-                url("$apkMirror/uploads/page/$page/")
-                parameter("appcategory", appCategory)
-            }.div {
-                withClass = "widget_appmanager_recentpostswidget"
-                findFirst {
-                    div {
-                        withClass = "listWidget"
-                        findFirst {
-                            children.mapNotNull { element ->
-                                if (element.className.isEmpty()) {
-
-                                    APKMirrorApp(
-                                        packageName = packageName,
-                                        version = element.div {
-                                            withClass = "infoSlide"
-                                            findFirst {
-                                                p {
-                                                    findFirst {
-                                                        span {
-                                                            withClass = "infoSlide-value"
-                                                            findFirst {
-                                                                text
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }.also {
-                                            if (it in versionFilter)
-                                                versions.add(it)
-                                        },
-                                        downloadLink = element.findFirst {
-                                            a {
-                                                withClass = "downloadLink"
-                                                findFirst {
-                                                    attribute("href")
-                                                }
-                                            }
-                                        }
-                                    )
-
-                                } else null
-                            }
-                        }
-                    }
-                }
-            }.onEach { version -> emit(version) }
-
-            page++
-        }
-    }
-
-    @Parcelize
-    private class APKMirrorApp(
-        override val packageName: String,
-        override val version: String,
-        private val downloadLink: String,
-    ) : AppDownloader.App, KoinComponent {
-        @IgnoredOnParcel private val httpClient: HttpService by inject()
-
-        override suspend fun download(
-            saveDirectory: File,
-            preferSplit: Boolean,
-            onDownload: suspend (downloadProgress: Pair<Float, Float>?) -> Unit
-        ) {
-            val variants = httpClient.getHtml { url(apkMirror + downloadLink) }
-                .div {
-                    withClass = "variants-table"
-                    findFirst { // list of variants
-                        children.drop(1).map {
-                            Variant(
-                                apkType = it.div {
-                                    findFirst {
-                                        span {
-                                            findFirst {
-                                                enumValueOf(text)
-                                            }
-                                        }
-                                    }
-                                },
-                                arch = it.div {
-                                    findSecond {
-                                        text
-                                    }
-                                },
-                                link = it.div {
-                                    findFirst {
-                                        a {
-                                            findFirst {
-                                                attribute("href")
-                                            }
-                                        }
-                                    }
-                                }
-                            )
-                        }
-                    }
-                }
-
-            val orderedAPKTypes = mutableListOf(APKType.APK, APKType.BUNDLE)
-                .also { if (preferSplit) it.reverse() }
-
-            val variant = orderedAPKTypes.firstNotNullOfOrNull { apkType ->
-                supportedArches.firstNotNullOfOrNull { arch ->
-                    variants.find { it.arch == arch && it.apkType == apkType }
-                }
-            } ?: throw Exception("No compatible variant found")
-
-            if (variant.apkType == APKType.BUNDLE) throw Exception("Split apks are not supported yet") // TODO
-
-            val downloadPage = httpClient.getHtml { url(apkMirror + variant.link) }
-                .a {
-                    withClass = "downloadButton"
-                    findFirst {
-                        attribute("href")
-                    }
-                }
-
-            val downloadLink = httpClient.getHtml { url(apkMirror + downloadPage) }
-                .form {
-                    withId = "filedownload"
-                    findFirst {
-                        val apkLink = attribute("action")
-                        val id = input {
-                            withAttribute = "name" to "id"
-                            findFirst {
-                                attribute("value")
-                            }
-                        }
-                        val key = input {
-                            withAttribute = "name" to "key"
-                            findFirst {
-                                attribute("value")
-                            }
-                        }
-                        "$apkLink?id=$id&key=$key"
-                    }
-                }
-
-            val targetFile = saveDirectory.resolve("base.apk")
-
-            try {
-                httpClient.download(targetFile) {
-                    url(apkMirror + downloadLink)
-                    onDownload { bytesSentTotal, contentLength ->
-                        onDownload(bytesSentTotal.div(100000).toFloat().div(10) to contentLength.div(100000).toFloat().div(10))
-                    }
-                }
-
-                if (variant.apkType == APKType.BUNDLE) {
-                    // TODO: Extract temp.zip
-
-                    targetFile.delete()
-                }
-            } finally {
-                onDownload(null)
-            }
-        }
-    }
-
-    companion object {
-        const val apkMirror = "https://www.apkmirror.com"
-
-        val supportedArches = listOf("universal", "noarch") + SUPPORTED_ABIS
-    }
-
-}

app/src/main/java/app/revanced/manager/network/downloader/AppDownloader.kt

@@ -1,27 +0,0 @@
-package app.revanced.manager.network.downloader
-
-import android.os.Parcelable
-import kotlinx.coroutines.flow.Flow
-import java.io.File
-
-interface AppDownloader {
-
-    /**
-     * Returns all downloadable apps.
-     *
-     * @param packageName The package name of the app.
-     * @param versionFilter A set of versions to filter.
-     */
-    fun getAvailableVersions(packageName: String, versionFilter: Set<String>): Flow<App>
-
-    interface App : Parcelable {
-        val packageName: String
-        val version: String
-
-        suspend fun download(
-            saveDirectory: File,
-            preferSplit: Boolean,
-            onDownload: suspend (downloadProgress: Pair<Float, Float>?) -> Unit = {}
-        )
-    }
-}

app/src/main/java/app/revanced/manager/network/downloader/DownloaderPluginState.kt

@@ -0,0 +1,9 @@
+package app.revanced.manager.network.downloader
+
+sealed interface DownloaderPluginState {
+    data object Untrusted : DownloaderPluginState
+
+    data class Loaded(val plugin: LoadedDownloaderPlugin) : DownloaderPluginState
+
+    data class Failed(val throwable: Throwable) : DownloaderPluginState
+}

app/src/main/java/app/revanced/manager/network/downloader/LoadedDownloaderPlugin.kt

@@ -0,0 +1,15 @@
+package app.revanced.manager.network.downloader
+
+import android.os.Parcelable
+import app.revanced.manager.plugin.downloader.OutputDownloadScope
+import app.revanced.manager.plugin.downloader.GetScope
+import java.io.OutputStream
+
+class LoadedDownloaderPlugin(
+    val packageName: String,
+    val name: String,
+    val version: String,
+    val get: suspend GetScope.(packageName: String, version: String?) -> Pair<Parcelable, String?>?,
+    val download: suspend OutputDownloadScope.(data: Parcelable, outputStream: OutputStream) -> Unit,
+    val classLoader: ClassLoader
+)

app/src/main/java/app/revanced/manager/network/downloader/ParceledDownloaderData.kt

@@ -0,0 +1,45 @@
+package app.revanced.manager.network.downloader
+
+import android.os.Build
+import android.os.Bundle
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+/**
+ * A container for [Parcelable] data returned from downloaders. Instances of this class can be safely stored in a bundle without needing to set the [ClassLoader].
+ */
+class ParceledDownloaderData private constructor(
+    val pluginPackageName: String,
+    private val bundle: Bundle
+) : Parcelable {
+    constructor(plugin: LoadedDownloaderPlugin, data: Parcelable) : this(
+        plugin.packageName,
+        createBundle(data)
+    )
+
+    fun unwrapWith(plugin: LoadedDownloaderPlugin): Parcelable {
+        bundle.classLoader = plugin.classLoader
+
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            val className = bundle.getString(CLASS_NAME_KEY)!!
+            val clazz = plugin.classLoader.loadClass(className)
+
+            bundle.getParcelable(DATA_KEY, clazz)!! as Parcelable
+        } else @Suppress("Deprecation") bundle.getParcelable(DATA_KEY)!!
+    }
+
+    private companion object {
+        const val CLASS_NAME_KEY = "class"
+        const val DATA_KEY = "data"
+
+        fun createBundle(data: Parcelable) = Bundle().apply {
+            putParcelable(DATA_KEY, data)
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) putString(
+                CLASS_NAME_KEY,
+                data::class.java.canonicalName
+            )
+        }
+    }
+}

app/src/main/java/app/revanced/manager/network/dto/BundleInfo.kt

@@ -1,9 +0,0 @@
-package app.revanced.manager.network.dto
-
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class BundleInfo(val patches: BundleAsset, val integrations: BundleAsset)
-
-@Serializable
-data class BundleAsset(val version: String, val url: String)

app/src/main/java/app/revanced/manager/network/dto/GithubChangelog.kt

@@ -1,16 +0,0 @@
-package app.revanced.manager.network.dto
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class GithubChangelog(
-    @SerialName("tag_name") val version: String,
-    @SerialName("body") val body: String,
-    @SerialName("assets") val assets: List<GithubAsset>
-)
-
-@Serializable
-data class GithubAsset(
-    @SerialName("download_count") val downloadCount: Int,
-)

app/src/main/java/app/revanced/manager/network/dto/ReVancedAsset.kt

@@ -0,0 +1,18 @@
+package app.revanced.manager.network.dto
+
+import kotlinx.datetime.LocalDateTime
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ReVancedAsset (
+    @SerialName("download_url")
+    val downloadUrl: String,
+    @SerialName("created_at")
+    val createdAt: LocalDateTime,
+    @SerialName("signature_download_url")
+    val signatureDownloadUrl: String? = null,
+    val description: String,
+    val version: String,
+)
+

app/src/main/java/app/revanced/manager/network/dto/ReVancedContributors.kt

@@ -3,19 +3,15 @@ package app.revanced.manager.network.dto
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
-@Serializable
-data class ReVancedGitRepositories(
-    val repositories: List<ReVancedGitRepository>,
-)
-
 @Serializable
 data class ReVancedGitRepository(
     val name: String,
+    val url: String,
     val contributors: List<ReVancedContributor>,
 )
 
 @Serializable
 data class ReVancedContributor(
-    @SerialName("login") val username: String,
+    @SerialName("name") val username: String,
     @SerialName("avatar_url") val avatarUrl: String,
-)
+)

app/src/main/java/app/revanced/manager/network/dto/ReVancedInfo.kt

@@ -0,0 +1,53 @@
+package app.revanced.manager.network.dto
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ReVancedInfo(
+    val name: String,
+    val about: String,
+    val branding: ReVancedBranding,
+    val contact: ReVancedContact,
+    val socials: List<ReVancedSocial>,
+    val donations: ReVancedDonation,
+)
+
+@Serializable
+data class ReVancedBranding(
+    val logo: String,
+)
+
+@Serializable
+data class ReVancedContact(
+    val email: String,
+)
+
+@Serializable
+data class ReVancedSocial(
+    val name: String,
+    val url: String,
+    val preferred: Boolean,
+)
+
+@Serializable
+data class ReVancedDonation(
+    val wallets: List<ReVancedWallet>,
+    val links: List<ReVancedDonationLink>,
+)
+
+@Serializable
+data class ReVancedWallet(
+    val network: String,
+    @SerialName("currency_code")
+    val currencyCode: String,
+    val address: String,
+    val preferred: Boolean
+)
+
+@Serializable
+data class ReVancedDonationLink(
+    val name: String,
+    val url: String,
+    val preferred: Boolean,
+)

app/src/main/java/app/revanced/manager/network/dto/ReVancedRelease.kt

@@ -1,41 +0,0 @@
-package app.revanced.manager.network.dto
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class ReVancedLatestRelease(
-    val release: ReVancedRelease,
-)
-
-@Serializable
-data class ReVancedReleases(
-    val releases: List<ReVancedRelease>
-)
-
-@Serializable
-data class ReVancedRelease(
-    val metadata: ReVancedReleaseMeta,
-    val assets: List<Asset>
-) {
-    val version get() = metadata.tag
-}
-
-@Serializable
-data class ReVancedReleaseMeta(
-    @SerialName("tag_name") val tag: String,
-    val name: String,
-    val draft: Boolean,
-    val prerelease: Boolean,
-    @SerialName("created_at") val createdAt: String,
-    @SerialName("published_at") val publishedAt: String,
-    val body: String,
-)
-
-@Serializable
-data class Asset(
-    val name: String,
-    @SerialName("download_count") val downloadCount: Int,
-    @SerialName("browser_download_url") val downloadUrl: String,
-    @SerialName("content_type") val contentType: String
-)

app/src/main/java/app/revanced/manager/network/service/ReVancedService.kt

@@ -1,34 +0,0 @@
-package app.revanced.manager.network.service
-
-import app.revanced.manager.network.dto.ReVancedLatestRelease
-import app.revanced.manager.network.dto.ReVancedGitRepositories
-import app.revanced.manager.network.dto.ReVancedReleases
-import app.revanced.manager.network.utils.APIResponse
-import io.ktor.client.request.*
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-
-class ReVancedService(
-    private val client: HttpService,
-) {
-    suspend fun getLatestRelease(api: String, repo: String): APIResponse<ReVancedLatestRelease> =
-        withContext(Dispatchers.IO) {
-            client.request {
-                url("$api/v2/$repo/releases/latest")
-            }
-        }
-
-    suspend fun getReleases(api: String, repo: String): APIResponse<ReVancedReleases> =
-        withContext(Dispatchers.IO) {
-            client.request {
-                url("$api/v2/$repo/releases")
-            }
-        }
-
-    suspend fun getContributors(api: String): APIResponse<ReVancedGitRepositories> =
-        withContext(Dispatchers.IO) {
-            client.request {
-                url("$api/contributors")
-            }
-        }
-}

app/src/main/java/app/revanced/manager/patcher/LibraryResolver.kt

@@ -0,0 +1,10 @@
+package app.revanced.manager.patcher
+
+import android.content.Context
+import java.io.File
+
+abstract class LibraryResolver {
+    protected fun findLibrary(context: Context, searchTerm: String): File? = File(context.applicationInfo.nativeLibraryDir).run {
+        list { _, f -> !File(f).isDirectory && f.contains(searchTerm) }?.firstOrNull()?.let { resolve(it) }
+    }
+}

app/src/main/java/app/revanced/manager/patcher/Session.kt

@@ -1,22 +1,20 @@
 package app.revanced.manager.patcher
 
 import android.content.Context
-import app.revanced.library.ApkUtils
+import app.revanced.library.ApkUtils.applyTo
 import app.revanced.manager.R
-import app.revanced.manager.patcher.logger.ManagerLogger
+import app.revanced.manager.patcher.logger.Logger
 import app.revanced.manager.ui.model.State
 import app.revanced.patcher.Patcher
-import app.revanced.patcher.PatcherOptions
+import app.revanced.patcher.PatcherConfig
 import app.revanced.patcher.patch.Patch
 import app.revanced.patcher.patch.PatchResult
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.withContext
 import java.io.Closeable
 import java.io.File
 import java.nio.file.Files
 import java.nio.file.StandardCopyOption
-import java.util.logging.Logger
 
 internal typealias PatchList = List<Patch<*>>
 
@@ -24,11 +22,10 @@ class Session(
     cacheDir: String,
     frameworkDir: String,
     aaptPath: String,
-    multithreadingDexFileWriter: Boolean,
     private val androidContext: Context,
-    private val logger: ManagerLogger,
+    private val logger: Logger,
     private val input: File,
-    private val patchesProgress: MutableStateFlow<Pair<Int, Int>>,
+    private val onPatchCompleted: suspend () -> Unit,
     private val onProgress: (name: String?, state: State?, message: String?) -> Unit
 ) : Closeable {
     private fun updateProgress(name: String? = null, state: State? = null, message: String? = null) =
@@ -36,12 +33,11 @@ class Session(
 
     private val tempDir = File(cacheDir).resolve("patcher").also { it.mkdirs() }
     private val patcher = Patcher(
-        PatcherOptions(
-            inputFile = input,
-            resourceCachePath = tempDir.resolve("aapt-resources"),
+        PatcherConfig(
+            apkFile = input,
+            temporaryFilesPath = tempDir,
             frameworkFileDirectory = frameworkDir,
-            aaptBinaryPath = aaptPath,
-            multithreadingDexFileWriter = multithreadingDexFileWriter,
+            aaptBinaryPath = aaptPath
         )
     )
 
@@ -49,16 +45,16 @@ class Session(
         var nextPatchIndex = 0
 
         updateProgress(
-            name = androidContext.getString(R.string.applying_patch, selectedPatches[nextPatchIndex]),
+            name = androidContext.getString(R.string.executing_patch, selectedPatches[nextPatchIndex]),
             state = State.RUNNING
         )
 
-        this.apply(true).collect { (patch, exception) ->
+        this().collect { (patch, exception) ->
             if (patch !in selectedPatches) return@collect
 
             if (exception != null) {
                 updateProgress(
-                    name = androidContext.getString(R.string.failed_to_apply_patch, patch.name),
+                    name = androidContext.getString(R.string.failed_to_execute_patch, patch.name),
                     state = State.FAILED,
                     message = exception.stackTraceToString()
                 )
@@ -70,13 +66,11 @@ class Session(
 
             nextPatchIndex++
 
-            patchesProgress.value.let {
-                patchesProgress.emit(it.copy(it.first + 1))
-            }
+            onPatchCompleted()
 
             selectedPatches.getOrNull(nextPatchIndex)?.let { nextPatch ->
                 updateProgress(
-                    name = androidContext.getString(R.string.applying_patch, nextPatch.name)
+                    name = androidContext.getString(R.string.executing_patch, nextPatch.name)
                 )
             }
 
@@ -86,28 +80,28 @@ class Session(
         updateProgress(
             state = State.COMPLETED,
             name = androidContext.resources.getQuantityString(
-                R.plurals.patches_applied,
+                R.plurals.patches_executed,
                 selectedPatches.size,
                 selectedPatches.size
             )
         )
     }
 
-    suspend fun run(output: File, selectedPatches: PatchList, integrations: List<File>) {
+    suspend fun run(output: File, selectedPatches: PatchList) {
         updateProgress(state = State.COMPLETED) // Unpacking
-        Logger.getLogger("").apply {
+
+        java.util.logging.Logger.getLogger("").apply {
             handlers.forEach {
                 it.close()
                 removeHandler(it)
             }
 
-            addHandler(logger)
+            addHandler(logger.handler)
         }
+
         with(patcher) {
             logger.info("Merging integrations")
-            acceptIntegrations(integrations)
-            acceptPatches(selectedPatches)
-            updateProgress(state = State.COMPLETED) // Merging
+            this += selectedPatches.toSet()
 
             logger.info("Applying patches...")
             applyPatchesVerbose(selectedPatches.sortedBy { it.name })
@@ -116,13 +110,16 @@ class Session(
         logger.info("Writing patched files...")
         val result = patcher.get()
 
-        val aligned = tempDir.resolve("aligned.apk")
-        ApkUtils.copyAligned(input, aligned, result)
+        val patched = tempDir.resolve("result.apk")
+        withContext(Dispatchers.IO) {
+            Files.copy(input.toPath(), patched.toPath(), StandardCopyOption.REPLACE_EXISTING)
+        }
+        result.applyTo(patched)
 
-        logger.info("Patched apk saved to $aligned")
+        logger.info("Patched apk saved to $patched")
 
         withContext(Dispatchers.IO) {
-            Files.move(aligned.toPath(), output.toPath(), StandardCopyOption.REPLACE_EXISTING)
+            Files.move(patched.toPath(), output.toPath(), StandardCopyOption.REPLACE_EXISTING)
         }
         updateProgress(state = State.COMPLETED) // Saving
     }

app/src/main/java/app/revanced/manager/patcher/aapt/Aapt.kt

@@ -1,18 +1,12 @@
 package app.revanced.manager.patcher.aapt
 
 import android.content.Context
+import app.revanced.manager.patcher.LibraryResolver
 import android.os.Build.SUPPORTED_ABIS as DEVICE_ABIS
-import java.io.File
-
-object Aapt {
-    private val WORKING_ABIS = setOf("arm64-v8a", "x86", "x86_64")
+object Aapt : LibraryResolver() {
+    private val WORKING_ABIS = setOf("arm64-v8a", "x86", "x86_64", "armeabi-v7a")
 
     fun supportsDevice() = (DEVICE_ABIS intersect WORKING_ABIS).isNotEmpty()
 
-    fun binary(context: Context): File? {
-        return File(context.applicationInfo.nativeLibraryDir).resolveAapt()
-    }
+    fun binary(context: Context) = findLibrary(context, "aapt")
 }
-
-private fun File.resolveAapt() =
-    list { _, f -> !File(f).isDirectory && f.contains("aapt") }?.firstOrNull()?.let { resolve(it) }

app/src/main/java/app/revanced/manager/patcher/logger/Logger.kt

@@ -0,0 +1,37 @@
+package app.revanced.manager.patcher.logger
+
+import java.util.logging.Handler
+import java.util.logging.Level
+import java.util.logging.LogRecord
+
+abstract class Logger {
+    abstract fun log(level: LogLevel, message: String)
+
+    fun trace(msg: String) = log(LogLevel.TRACE, msg)
+    fun info(msg: String) = log(LogLevel.INFO, msg)
+    fun warn(msg: String) = log(LogLevel.WARN, msg)
+    fun error(msg: String) = log(LogLevel.ERROR, msg)
+
+    val handler = object : Handler() {
+        override fun publish(record: LogRecord) {
+            val msg = record.message
+
+            when (record.level) {
+                Level.INFO -> info(msg)
+                Level.SEVERE -> error(msg)
+                Level.WARNING -> warn(msg)
+                else -> trace(msg)
+            }
+        }
+
+        override fun flush() = Unit
+        override fun close() = Unit
+    }
+}
+
+enum class LogLevel {
+    TRACE,
+    INFO,
+    WARN,
+    ERROR,
+}

app/src/main/java/app/revanced/manager/patcher/logger/ManagerLogger.kt

@@ -1,59 +0,0 @@
-package app.revanced.manager.patcher.logger
-
-import android.util.Log
-import java.util.logging.Handler
-import java.util.logging.Level
-import java.util.logging.LogRecord
-
-class ManagerLogger : Handler() {
-    private val logs = mutableListOf<Pair<LogLevel, String>>()
-    private fun log(level: LogLevel, msg: String) {
-        level.androidLog(msg)
-        if (level == LogLevel.TRACE) return
-        logs.add(level to msg)
-    }
-
-    fun export() =
-        logs.asSequence().map { (level, msg) -> "[${level.name}]: $msg" }.joinToString("\n")
-
-    fun trace(msg: String) = log(LogLevel.TRACE, msg)
-    fun info(msg: String) = log(LogLevel.INFO, msg)
-    fun warn(msg: String) = log(LogLevel.WARN, msg)
-    fun error(msg: String) = log(LogLevel.ERROR, msg)
-    override fun publish(record: LogRecord) {
-        val msg = record.message
-        val fn = when (record.level) {
-            Level.INFO -> ::info
-            Level.SEVERE -> ::error
-            Level.WARNING -> ::warn
-            else -> ::trace
-        }
-
-        fn(msg)
-    }
-
-    override fun flush() = Unit
-
-    override fun close() = Unit
-}
-
-enum class LogLevel {
-    TRACE {
-        override fun androidLog(msg: String) = Log.v(androidTag, msg)
-    },
-    INFO {
-        override fun androidLog(msg: String) = Log.i(androidTag, msg)
-    },
-    WARN {
-        override fun androidLog(msg: String) = Log.w(androidTag, msg)
-    },
-    ERROR {
-        override fun androidLog(msg: String) = Log.e(androidTag, msg)
-    };
-
-    abstract fun androidLog(msg: String): Int
-
-    private companion object {
-        const val androidTag = "ReVanced Patcher"
-    }
-}

app/src/main/java/app/revanced/manager/patcher/patch/PatchBundle.kt

@@ -2,23 +2,24 @@ package app.revanced.manager.patcher.patch
 
 import android.util.Log
 import app.revanced.manager.util.tag
-import app.revanced.patcher.PatchBundleLoader
 import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.PatchLoader
 import java.io.File
+import java.io.IOException
+import java.util.jar.JarFile
 
-class PatchBundle(private val loader: Iterable<Patch<*>>, val integrations: File?) {
-    constructor(bundleJar: File, integrations: File?) : this(
-        object : Iterable<Patch<*>> {
-            private fun load(): Iterable<Patch<*>> {
-                bundleJar.setReadOnly()
-                return PatchBundleLoader.Dex(bundleJar, optimizedDexDirectory = null)
-            }
+class PatchBundle(val patchesJar: File) {
+    private val loader = object : Iterable<Patch<*>> {
+        private fun load(): Iterable<Patch<*>> {
+            patchesJar.setReadOnly()
+            return PatchLoader.Dex(setOf(patchesJar))
+        }
 
-            override fun iterator(): Iterator<Patch<*>> = load().iterator()
-        },
-        integrations
-    ) {
-        Log.d(tag, "Loaded patch bundle: $bundleJar")
+        override fun iterator(): Iterator<Patch<*>> = load().iterator()
+    }
+
+    init {
+        Log.d(tag, "Loaded patch bundle: $patchesJar")
     }
 
     /**
@@ -26,15 +27,26 @@ class PatchBundle(private val loader: Iterable<Patch<*>>, val integrations: File
      */
     val patches = loader.map(::PatchInfo)
 
+    /**
+     * The [java.util.jar.Manifest] of [patchesJar].
+     */
+    private val manifest = try {
+        JarFile(patchesJar).use { it.manifest }
+    } catch (_: IOException) {
+        null
+    }
+
+    fun readManifestAttribute(name: String) = manifest?.mainAttributes?.getValue(name)
+
     /**
      * Load all patches compatible with the specified package.
      */
-    fun patchClasses(packageName: String) = loader.filter { patch ->
+    fun patches(packageName: String) = loader.filter { patch ->
         val compatiblePackages = patch.compatiblePackages
             ?: // The patch has no compatibility constraints, which means it is universal.
             return@filter true
 
-        if (!compatiblePackages.any { it.name == packageName }) {
+        if (!compatiblePackages.any { (name, _) -> name == packageName }) {
             // Patch is not compatible with this package.
             return@filter false
         }

app/src/main/java/app/revanced/manager/patcher/patch/PatchInfo.kt

@@ -2,69 +2,86 @@ package app.revanced.manager.patcher.patch
 
 import androidx.compose.runtime.Immutable
 import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
+import app.revanced.patcher.patch.Option as PatchOption
+import app.revanced.patcher.patch.resourcePatch
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.ImmutableSet
 import kotlinx.collections.immutable.toImmutableList
 import kotlinx.collections.immutable.toImmutableSet
+import kotlin.reflect.KType
 
 data class PatchInfo(
     val name: String,
     val description: String?,
     val include: Boolean,
     val compatiblePackages: ImmutableList<CompatiblePackage>?,
-    val options: ImmutableList<Option>?
+    val options: ImmutableList<Option<*>>?
 ) {
     constructor(patch: Patch<*>) : this(
         patch.name.orEmpty(),
         patch.description,
         patch.use,
-        patch.compatiblePackages?.map { CompatiblePackage(it) }?.toImmutableList(),
+        patch.compatiblePackages?.map { (pkgName, versions) ->
+            CompatiblePackage(
+                pkgName,
+                versions?.toImmutableSet()
+            )
+        }?.toImmutableList(),
         patch.options.map { (_, option) -> Option(option) }.ifEmpty { null }?.toImmutableList()
     )
 
     fun compatibleWith(packageName: String) =
         compatiblePackages?.any { it.packageName == packageName } ?: true
 
-    fun supportsVersion(packageName: String, versionName: String): Boolean {
+    fun supports(packageName: String, versionName: String?): Boolean {
         val packages = compatiblePackages ?: return true // Universal patch
 
         return packages.any { pkg ->
-            if (pkg.packageName != packageName) {
-                return@any false
-            }
+            if (pkg.packageName != packageName) return@any false
+            if (pkg.versions == null) return@any true
 
-            pkg.versions == null || pkg.versions.contains(versionName)
+            versionName != null && versionName in pkg.versions
         }
     }
+
+    /**
+     * Create a fake [Patch] with the same metadata as the [PatchInfo] instance.
+     * The resulting patch cannot be executed.
+     * This is necessary because some functions in ReVanced Library only accept full [Patch] objects.
+     */
+    fun toPatcherPatch(): Patch<*> =
+        resourcePatch(name = name, description = description, use = include) {
+            compatiblePackages?.let { pkgs ->
+                compatibleWith(*pkgs.map { it.packageName to it.versions }.toTypedArray())
+            }
+        }
 }
 
 @Immutable
 data class CompatiblePackage(
     val packageName: String,
     val versions: ImmutableSet<String>?
-) {
-    constructor(pkg: Patch.CompatiblePackage) : this(
-        pkg.name,
-        pkg.versions?.toImmutableSet()
-    )
-}
+)
 
 @Immutable
-data class Option(
+data class Option<T>(
     val title: String,
     val key: String,
     val description: String,
     val required: Boolean,
-    val type: String,
-    val default: Any?
+    val type: KType,
+    val default: T?,
+    val presets: Map<String, T?>?,
+    val validator: (T?) -> Boolean,
 ) {
-    constructor(option: PatchOption<*>) : this(
+    constructor(option: PatchOption<T>) : this(
         option.title ?: option.key,
         option.key,
         option.description.orEmpty(),
         option.required,
-        option.valueType,
+        option.type,
         option.default,
+        option.values,
+        { option.validator(option, it) },
     )
 }

app/src/main/java/app/revanced/manager/patcher/runtime/CoroutineRuntime.kt

@@ -0,0 +1,66 @@
+package app.revanced.manager.patcher.runtime
+
+import android.content.Context
+import app.revanced.manager.patcher.Session
+import app.revanced.manager.patcher.logger.Logger
+import app.revanced.manager.patcher.worker.ProgressEventHandler
+import app.revanced.manager.ui.model.State
+import app.revanced.manager.util.Options
+import app.revanced.manager.util.PatchSelection
+import java.io.File
+
+/**
+ * Simple [Runtime] implementation that runs the patcher using coroutines.
+ */
+class CoroutineRuntime(private val context: Context) : Runtime(context) {
+    override suspend fun execute(
+        inputFile: String,
+        outputFile: String,
+        packageName: String,
+        selectedPatches: PatchSelection,
+        options: Options,
+        logger: Logger,
+        onPatchCompleted: suspend () -> Unit,
+        onProgress: ProgressEventHandler,
+    ) {
+        val bundles = bundles()
+
+        val selectedBundles = selectedPatches.keys
+        val allPatches = bundles.filterKeys { selectedBundles.contains(it) }
+            .mapValues { (_, bundle) -> bundle.patches(packageName) }
+
+        val patchList = selectedPatches.flatMap { (bundle, selected) ->
+            allPatches[bundle]?.filter { selected.contains(it.name) }
+                ?: throw IllegalArgumentException("Patch bundle $bundle does not exist")
+        }
+
+        // Set all patch options.
+        options.forEach { (bundle, bundlePatchOptions) ->
+            val patches = allPatches[bundle] ?: return@forEach
+            bundlePatchOptions.forEach { (patchName, configuredPatchOptions) ->
+                val patchOptions = patches.single { it.name == patchName }.options
+                configuredPatchOptions.forEach { (key, value) ->
+                    patchOptions[key] = value
+                }
+            }
+        }
+
+        onProgress(null, State.COMPLETED, null) // Loading patches
+
+        Session(
+            cacheDir,
+            frameworkPath,
+            aaptPath,
+            context,
+            logger,
+            File(inputFile),
+            onPatchCompleted = onPatchCompleted,
+            onProgress
+        ).use { session ->
+            session.run(
+                File(outputFile),
+                patchList
+            )
+        }
+    }
+}

app/src/main/java/app/revanced/manager/patcher/runtime/ProcessRuntime.kt

@@ -0,0 +1,189 @@
+package app.revanced.manager.patcher.runtime
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.util.Log
+import androidx.core.content.ContextCompat
+import app.revanced.manager.BuildConfig
+import app.revanced.manager.patcher.runtime.process.IPatcherEvents
+import app.revanced.manager.patcher.runtime.process.IPatcherProcess
+import app.revanced.manager.patcher.LibraryResolver
+import app.revanced.manager.patcher.logger.Logger
+import app.revanced.manager.patcher.runtime.process.Parameters
+import app.revanced.manager.patcher.runtime.process.PatchConfiguration
+import app.revanced.manager.patcher.runtime.process.PatcherProcess
+import app.revanced.manager.patcher.worker.ProgressEventHandler
+import app.revanced.manager.ui.model.State
+import app.revanced.manager.util.Options
+import app.revanced.manager.util.PM
+import app.revanced.manager.util.PatchSelection
+import app.revanced.manager.util.tag
+import com.github.pgreze.process.Redirect
+import com.github.pgreze.process.process
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeout
+import org.koin.core.component.inject
+
+/**
+ * Runs the patcher in another process by using the app_process binary and IPC.
+ */
+class ProcessRuntime(private val context: Context) : Runtime(context) {
+    private val pm: PM by inject()
+
+    private suspend fun awaitBinderConnection(): IPatcherProcess {
+        val binderFuture = CompletableDeferred<IPatcherProcess>()
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                val binder =
+                    intent.getBundleExtra(INTENT_BUNDLE_KEY)?.getBinder(BUNDLE_BINDER_KEY)!!
+
+                binderFuture.complete(IPatcherProcess.Stub.asInterface(binder))
+            }
+        }
+
+        ContextCompat.registerReceiver(context, receiver, IntentFilter().apply {
+            addAction(CONNECT_TO_APP_ACTION)
+        }, ContextCompat.RECEIVER_NOT_EXPORTED)
+
+        return try {
+            withTimeout(10000L) {
+                binderFuture.await()
+            }
+        } finally {
+            context.unregisterReceiver(receiver)
+        }
+    }
+
+    override suspend fun execute(
+        inputFile: String,
+        outputFile: String,
+        packageName: String,
+        selectedPatches: PatchSelection,
+        options: Options,
+        logger: Logger,
+        onPatchCompleted: suspend () -> Unit,
+        onProgress: ProgressEventHandler,
+    ) = coroutineScope {
+        // Get the location of our own Apk.
+        val managerBaseApk = pm.getPackageInfo(context.packageName)!!.applicationInfo!!.sourceDir
+
+        val limit = "${prefs.patcherProcessMemoryLimit.get()}M"
+        val propOverride = resolvePropOverride(context)?.absolutePath
+            ?: throw Exception("Couldn't find prop override library")
+
+        val env =
+            System.getenv().toMutableMap().apply {
+                putAll(
+                    mapOf(
+                        "CLASSPATH" to managerBaseApk,
+                        // Override the props used by ART to set the memory limit.
+                        "LD_PRELOAD" to propOverride,
+                        "PROP_dalvik.vm.heapgrowthlimit" to limit,
+                        "PROP_dalvik.vm.heapsize" to limit,
+                    )
+                )
+            }
+
+        launch(Dispatchers.IO) {
+            val result = process(
+                APP_PROCESS_BIN_PATH,
+                "-Djava.io.tmpdir=$cacheDir", // The process will use /tmp if this isn't set, which is a problem because that folder is not accessible on Android.
+                "/", // The unused cmd-dir parameter
+                "--nice-name=${context.packageName}:Patcher",
+                PatcherProcess::class.java.name, // The class with the main function.
+                context.packageName,
+                env = env,
+                stdout = Redirect.CAPTURE,
+                stderr = Redirect.CAPTURE,
+            ) { line ->
+                // The process shouldn't generally be writing to stdio. Log any lines we get as warnings.
+                logger.warn("[STDIO]: $line")
+            }
+
+            Log.d(tag, "Process finished with exit code ${result.resultCode}")
+
+            if (result.resultCode != 0) throw Exception("Process exited with nonzero exit code ${result.resultCode}")
+        }
+
+        val patching = CompletableDeferred<Unit>()
+        val scope = this
+
+        launch(Dispatchers.IO) {
+            val binder = awaitBinderConnection()
+
+            // Android Studio's fast deployment feature causes an issue where the other process will be running older code compared to the main process.
+            // The patcher process is running outdated code if the randomly generated BUILD_ID numbers don't match.
+            // To fix it, clear the cache in the Android settings or disable fast deployment (Run configurations -> Edit Configurations -> app -> Enable "always deploy with package manager").
+            if (binder.buildId() != BuildConfig.BUILD_ID) throw Exception("app_process is running outdated code. Clear the app cache or disable disable Android 11 deployment optimizations in your IDE")
+
+            val eventHandler = object : IPatcherEvents.Stub() {
+                override fun log(level: String, msg: String) = logger.log(enumValueOf(level), msg)
+
+                override fun patchSucceeded() {
+                    scope.launch { onPatchCompleted() }
+                }
+
+                override fun progress(name: String?, state: String?, msg: String?) =
+                    onProgress(name, state?.let { enumValueOf<State>(it) }, msg)
+
+                override fun finished(exceptionStackTrace: String?) {
+                    binder.exit()
+
+                    exceptionStackTrace?.let {
+                        patching.completeExceptionally(RemoteFailureException(it))
+                        return
+                    }
+                    patching.complete(Unit)
+                }
+            }
+
+            val bundles = bundles()
+
+            val parameters = Parameters(
+                aaptPath = aaptPath,
+                frameworkDir = frameworkPath,
+                cacheDir = cacheDir,
+                packageName = packageName,
+                inputFile = inputFile,
+                outputFile = outputFile,
+                configurations = selectedPatches.map { (id, patches) ->
+                    val bundle = bundles[id]!!
+
+                    PatchConfiguration(
+                        bundle.patchesJar.absolutePath,
+                        patches,
+                        options[id].orEmpty()
+                    )
+                }
+            )
+
+            binder.start(parameters, eventHandler)
+        }
+
+        // Wait until patching finishes.
+        patching.await()
+    }
+
+    companion object : LibraryResolver() {
+        private const val APP_PROCESS_BIN_PATH = "/system/bin/app_process"
+
+        const val CONNECT_TO_APP_ACTION = "CONNECT_TO_APP_ACTION"
+        const val INTENT_BUNDLE_KEY = "BUNDLE"
+        const val BUNDLE_BINDER_KEY = "BINDER"
+
+        private fun resolvePropOverride(context: Context) = findLibrary(context, "prop_override")
+    }
+
+    /**
+     * An [Exception] occurred in the remote process while patching.
+     *
+     * @param originalStackTrace The stack trace of the original [Exception].
+     */
+    class RemoteFailureException(val originalStackTrace: String) : Exception()
+}
+

app/src/main/java/app/revanced/manager/patcher/runtime/Runtime.kt

@@ -0,0 +1,40 @@
+package app.revanced.manager.patcher.runtime
+
+import android.content.Context
+import app.revanced.manager.data.platform.Filesystem
+import app.revanced.manager.domain.manager.PreferencesManager
+import app.revanced.manager.domain.repository.PatchBundleRepository
+import app.revanced.manager.patcher.aapt.Aapt
+import app.revanced.manager.patcher.logger.Logger
+import app.revanced.manager.patcher.worker.ProgressEventHandler
+import app.revanced.manager.util.Options
+import app.revanced.manager.util.PatchSelection
+import kotlinx.coroutines.flow.first
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+import java.io.FileNotFoundException
+
+sealed class Runtime(context: Context) : KoinComponent {
+    private val fs: Filesystem by inject()
+    private val patchBundlesRepo: PatchBundleRepository by inject()
+    protected val prefs: PreferencesManager by inject()
+
+    protected val cacheDir: String = fs.tempDir.absolutePath
+    protected val aaptPath = Aapt.binary(context)?.absolutePath
+        ?: throw FileNotFoundException("Could not resolve aapt.")
+    protected val frameworkPath: String =
+        context.cacheDir.resolve("framework").also { it.mkdirs() }.absolutePath
+
+    protected suspend fun bundles() = patchBundlesRepo.bundles.first()
+
+    abstract suspend fun execute(
+        inputFile: String,
+        outputFile: String,
+        packageName: String,
+        selectedPatches: PatchSelection,
+        options: Options,
+        logger: Logger,
+        onPatchCompleted: suspend () -> Unit,
+        onProgress: ProgressEventHandler,
+    )
+}

app/src/main/java/app/revanced/manager/patcher/runtime/process/Parameters.kt

@@ -0,0 +1,23 @@
+package app.revanced.manager.patcher.runtime.process
+
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+import kotlinx.parcelize.RawValue
+
+@Parcelize
+data class Parameters(
+    val cacheDir: String,
+    val aaptPath: String,
+    val frameworkDir: String,
+    val packageName: String,
+    val inputFile: String,
+    val outputFile: String,
+    val configurations: List<PatchConfiguration>,
+) : Parcelable
+
+@Parcelize
+data class PatchConfiguration(
+    val bundlePath: String,
+    val patches: Set<String>,
+    val options: @RawValue Map<String, Map<String, Any?>>
+) : Parcelable

app/src/main/java/app/revanced/manager/patcher/runtime/process/PatcherProcess.kt

@@ -0,0 +1,138 @@
+package app.revanced.manager.patcher.runtime.process
+
+import android.annotation.SuppressLint
+import android.app.ActivityThread
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.os.Looper
+import app.revanced.manager.BuildConfig
+import app.revanced.manager.patcher.Session
+import app.revanced.manager.patcher.logger.LogLevel
+import app.revanced.manager.patcher.logger.Logger
+import app.revanced.manager.patcher.patch.PatchBundle
+import app.revanced.manager.patcher.runtime.ProcessRuntime
+import app.revanced.manager.ui.model.State
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.io.File
+import kotlin.system.exitProcess
+
+/**
+ * The main class that runs inside the runner process launched by [ProcessRuntime].
+ */
+class PatcherProcess(private val context: Context) : IPatcherProcess.Stub() {
+    private var eventBinder: IPatcherEvents? = null
+
+    private val scope =
+        CoroutineScope(Dispatchers.Default + CoroutineExceptionHandler { _, throwable ->
+            // Try to send the exception information to the main app.
+            eventBinder?.let {
+                try {
+                    it.finished(throwable.stackTraceToString())
+                    return@CoroutineExceptionHandler
+                } catch (_: Exception) {
+                }
+            }
+
+            throwable.printStackTrace()
+            exitProcess(1)
+        })
+
+    override fun buildId() = BuildConfig.BUILD_ID
+    override fun exit() = exitProcess(0)
+
+    override fun start(parameters: Parameters, events: IPatcherEvents) {
+        eventBinder = events
+
+        scope.launch {
+            val logger = object : Logger() {
+                override fun log(level: LogLevel, message: String) =
+                    events.log(level.name, message)
+            }
+
+            logger.info("Memory limit: ${Runtime.getRuntime().maxMemory() / (1024 * 1024)}MB")
+
+            val patchList = parameters.configurations.flatMap { config ->
+                val bundle = PatchBundle(File(config.bundlePath))
+
+                val patches =
+                    bundle.patches(parameters.packageName).filter { it.name in config.patches }
+                        .associateBy { it.name }
+
+                config.options.forEach { (patchName, opts) ->
+                    val patchOptions = patches[patchName]?.options
+                        ?: throw Exception("Patch with name $patchName does not exist.")
+
+                    opts.forEach { (key, value) ->
+                        patchOptions[key] = value
+                    }
+                }
+
+                patches.values
+            }
+
+            events.progress(null, State.COMPLETED.name, null) // Loading patches
+
+            Session(
+                cacheDir = parameters.cacheDir,
+                aaptPath = parameters.aaptPath,
+                frameworkDir = parameters.frameworkDir,
+                androidContext = context,
+                logger = logger,
+                input = File(parameters.inputFile),
+                onPatchCompleted = { events.patchSucceeded() },
+                onProgress = { name, state, message ->
+                    events.progress(name, state?.name, message)
+                }
+            ).use {
+                it.run(File(parameters.outputFile), patchList)
+            }
+
+            events.finished(null)
+        }
+    }
+
+    companion object {
+        private val longArrayClass = LongArray::class.java
+        private val emptyLongArray = LongArray(0)
+
+        @SuppressLint("PrivateApi")
+        @JvmStatic
+        fun main(args: Array<String>) {
+            Looper.prepare()
+
+            val managerPackageName = args[0]
+
+            // Abuse hidden APIs to get a context.
+            val systemContext = ActivityThread.systemMain().systemContext as Context
+            val appContext = systemContext.createPackageContext(managerPackageName, 0)
+
+            // Avoid annoying logs. See https://github.com/robolectric/robolectric/blob/ad0484c6b32c7d11176c711abeb3cb4a900f9258/robolectric/src/main/java/org/robolectric/android/internal/AndroidTestEnvironment.java#L376-L388
+            Class.forName("android.app.AppCompatCallbacks").apply {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+                    getDeclaredMethod("install", longArrayClass, longArrayClass).also { it.isAccessible = true }(null, emptyLongArray, emptyLongArray)
+                } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                    getDeclaredMethod("install", longArrayClass).also { it.isAccessible = true }(null, emptyLongArray)
+                }
+            }
+
+            val ipcInterface = PatcherProcess(appContext)
+
+            appContext.sendBroadcast(Intent().apply {
+                action = ProcessRuntime.CONNECT_TO_APP_ACTION
+                `package` = managerPackageName
+
+                putExtra(ProcessRuntime.INTENT_BUNDLE_KEY, Bundle().apply {
+                    putBinder(ProcessRuntime.BUNDLE_BINDER_KEY, ipcInterface.asBinder())
+                })
+            })
+
+            Looper.loop()
+            exitProcess(1) // Shouldn't happen
+        }
+    }
+}

app/src/main/java/app/revanced/manager/patcher/worker/PatcherWorker.kt

@@ -1,5 +1,6 @@
 package app.revanced.manager.patcher.worker
 
+import android.app.Activity
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
@@ -9,9 +10,10 @@ import android.content.Intent
 import android.content.pm.ServiceInfo
 import android.graphics.drawable.Icon
 import android.os.Build
+import android.os.Parcelable
 import android.os.PowerManager
 import android.util.Log
-import android.view.WindowManager
+import androidx.activity.result.ActivityResult
 import androidx.core.content.ContextCompat
 import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
@@ -22,50 +24,58 @@ import app.revanced.manager.domain.installer.RootInstaller
 import app.revanced.manager.domain.manager.KeystoreManager
 import app.revanced.manager.domain.manager.PreferencesManager
 import app.revanced.manager.domain.repository.DownloadedAppRepository
+import app.revanced.manager.domain.repository.DownloaderPluginRepository
 import app.revanced.manager.domain.repository.InstalledAppRepository
-import app.revanced.manager.domain.repository.PatchBundleRepository
 import app.revanced.manager.domain.worker.Worker
 import app.revanced.manager.domain.worker.WorkerRepository
-import app.revanced.manager.patcher.Session
-import app.revanced.manager.patcher.aapt.Aapt
-import app.revanced.manager.patcher.logger.ManagerLogger
+import app.revanced.manager.network.downloader.LoadedDownloaderPlugin
+import app.revanced.manager.patcher.logger.Logger
+import app.revanced.manager.patcher.runtime.CoroutineRuntime
+import app.revanced.manager.patcher.runtime.ProcessRuntime
+import app.revanced.manager.plugin.downloader.GetScope
+import app.revanced.manager.plugin.downloader.PluginHostApi
+import app.revanced.manager.plugin.downloader.UserInteractionException
 import app.revanced.manager.ui.model.SelectedApp
 import app.revanced.manager.ui.model.State
 import app.revanced.manager.util.Options
 import app.revanced.manager.util.PM
 import app.revanced.manager.util.PatchSelection
 import app.revanced.manager.util.tag
-import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 import java.io.File
-import java.io.FileNotFoundException
 
+typealias ProgressEventHandler = (name: String?, state: State?, message: String?) -> Unit
+
+@OptIn(PluginHostApi::class)
 class PatcherWorker(
     context: Context,
     parameters: WorkerParameters
 ) : Worker<PatcherWorker.Args>(context, parameters), KoinComponent {
-    private val patchBundleRepository: PatchBundleRepository by inject()
     private val workerRepository: WorkerRepository by inject()
     private val prefs: PreferencesManager by inject()
     private val keystoreManager: KeystoreManager by inject()
+    private val downloaderPluginRepository: DownloaderPluginRepository by inject()
     private val downloadedAppRepository: DownloadedAppRepository by inject()
     private val pm: PM by inject()
     private val fs: Filesystem by inject()
     private val installedAppRepository: InstalledAppRepository by inject()
     private val rootInstaller: RootInstaller by inject()
 
-    data class Args(
+    class Args(
         val input: SelectedApp,
         val output: String,
         val selectedPatches: PatchSelection,
         val options: Options,
-        val logger: ManagerLogger,
-        val downloadProgress: MutableStateFlow<Pair<Float, Float>?>,
-        val patchesProgress: MutableStateFlow<Pair<Int, Int>>,
-        val setInputFile: (File) -> Unit,
-        val onProgress: (name: String?, state: State?, message: String?) -> Unit
+        val logger: Logger,
+        val onDownloadProgress: suspend (Pair<Long, Long?>?) -> Unit,
+        val onPatchCompleted: suspend () -> Unit,
+        val handleStartActivityRequest: suspend (LoadedDownloaderPlugin, Intent) -> ActivityResult,
+        val setInputFile: suspend (File) -> Unit,
+        val onProgress: ProgressEventHandler
     ) {
         val packageName get() = input.packageName
     }
@@ -111,7 +121,8 @@ class PatcherWorker(
 
         val wakeLock: PowerManager.WakeLock =
             (applicationContext.getSystemService(Context.POWER_SERVICE) as PowerManager)
-                .newWakeLock(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON, "$tag::Patcher").apply {
+                .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::Patcher")
+                .apply {
                     acquire(10 * 60 * 1000L)
                     Log.d(tag, "Acquired wakelock.")
                 }
@@ -133,97 +144,114 @@ class PatcherWorker(
         val patchedApk = fs.tempDir.resolve("patched.apk")
 
         return try {
-            val bundles = patchBundleRepository.bundles.first()
-
-            // TODO: consider passing all the classes directly now that the input no longer needs to be serializable.
-            val selectedBundles = args.selectedPatches.keys
-            val allPatches = bundles.filterKeys { selectedBundles.contains(it) }
-                .mapValues { (_, bundle) -> bundle.patchClasses(args.packageName) }
-
-            val selectedPatches = args.selectedPatches.flatMap { (bundle, selected) ->
-                allPatches[bundle]?.filter { selected.contains(it.name) }
-                    ?: throw IllegalArgumentException("Patch bundle $bundle does not exist")
-            }
-
-            val aaptPath = Aapt.binary(applicationContext)?.absolutePath
-                ?: throw FileNotFoundException("Could not resolve aapt.")
-
-            val frameworkPath =
-                applicationContext.cacheDir.resolve("framework").also { it.mkdirs() }.absolutePath
-
-            val integrations = bundles.mapNotNull { (_, bundle) -> bundle.integrations }
-
             if (args.input is SelectedApp.Installed) {
                 installedAppRepository.get(args.packageName)?.let {
-                    if (it.installType == InstallType.ROOT) {
+                    if (it.installType == InstallType.MOUNT) {
                         rootInstaller.unmount(args.packageName)
                     }
                 }
             }
 
-            // Set all patch options.
-            args.options.forEach { (bundle, bundlePatchOptions) ->
-                val patches = allPatches[bundle] ?: return@forEach
-                bundlePatchOptions.forEach { (patchName, configuredPatchOptions) ->
-                    val patchOptions = patches.single { it.name == patchName }.options
-                    configuredPatchOptions.forEach { (key, value) ->
-                        patchOptions[key] = value
-                    }
+            suspend fun download(plugin: LoadedDownloaderPlugin, data: Parcelable) =
+                downloadedAppRepository.download(
+                    plugin,
+                    data,
+                    args.packageName,
+                    args.input.version,
+                    onDownload = args.onDownloadProgress
+                ).also {
+                    args.setInputFile(it)
+                    updateProgress(state = State.COMPLETED) // Download APK
                 }
-            }
-
-            updateProgress(state = State.COMPLETED) // Loading patches
 
             val inputFile = when (val selectedApp = args.input) {
                 is SelectedApp.Download -> {
-                    downloadedAppRepository.download(
-                        selectedApp.app,
-                        prefs.preferSplits.get(),
-                        onDownload = { args.downloadProgress.emit(it) }
-                    ).also {
-                        args.setInputFile(it)
-                        updateProgress(state = State.COMPLETED) // Download APK
-                    }
+                    val (plugin, data) = downloaderPluginRepository.unwrapParceledData(selectedApp.data)
+
+                    download(plugin, data)
+                }
+
+                is SelectedApp.Search -> {
+                    downloaderPluginRepository.loadedPluginsFlow.first()
+                        .firstNotNullOfOrNull { plugin ->
+                            try {
+                                val getScope = object : GetScope {
+                                    override val pluginPackageName = plugin.packageName
+                                    override val hostPackageName = applicationContext.packageName
+                                    override suspend fun requestStartActivity(intent: Intent): Intent? {
+                                        val result = args.handleStartActivityRequest(plugin, intent)
+                                        return when (result.resultCode) {
+                                            Activity.RESULT_OK -> result.data
+                                            Activity.RESULT_CANCELED -> throw UserInteractionException.Activity.Cancelled()
+                                            else -> throw UserInteractionException.Activity.NotCompleted(
+                                                result.resultCode,
+                                                result.data
+                                            )
+                                        }
+                                    }
+                                }
+                                withContext(Dispatchers.IO) {
+                                    plugin.get(
+                                        getScope,
+                                        selectedApp.packageName,
+                                        selectedApp.version
+                                    )
+                                }?.takeIf { (_, version) -> selectedApp.version == null || version == selectedApp.version }
+                            } catch (e: UserInteractionException.Activity.NotCompleted) {
+                                throw e
+                            } catch (_: UserInteractionException) {
+                                null
+                            }?.let { (data, _) -> download(plugin, data) }
+                        } ?: throw Exception("App is not available.")
                 }
 
                 is SelectedApp.Local -> selectedApp.file.also { args.setInputFile(it) }
-                is SelectedApp.Installed -> File(pm.getPackageInfo(selectedApp.packageName)!!.applicationInfo.sourceDir)
+                is SelectedApp.Installed -> File(pm.getPackageInfo(selectedApp.packageName)!!.applicationInfo!!.sourceDir)
             }
 
-            Session(
-                fs.tempDir.absolutePath,
-                frameworkPath,
-                aaptPath,
-                prefs.multithreadingDexFileWriter.get(),
-                applicationContext,
-                args.logger,
-                inputFile,
-                args.patchesProgress,
-                args.onProgress
-            ).use { session ->
-                session.run(
-                    patchedApk,
-                    selectedPatches,
-                    integrations
-                )
+            val runtime = if (prefs.useProcessRuntime.get()) {
+                ProcessRuntime(applicationContext)
+            } else {
+                CoroutineRuntime(applicationContext)
             }
 
+            runtime.execute(
+                inputFile.absolutePath,
+                patchedApk.absolutePath,
+                args.packageName,
+                args.selectedPatches,
+                args.options,
+                args.logger,
+                args.onPatchCompleted,
+                args.onProgress
+            )
+
             keystoreManager.sign(patchedApk, File(args.output))
             updateProgress(state = State.COMPLETED) // Signing
 
             Log.i(tag, "Patching succeeded".logFmt())
             Result.success()
+        } catch (e: ProcessRuntime.RemoteFailureException) {
+            Log.e(
+                tag,
+                "An exception occurred in the remote process while patching. ${e.originalStackTrace}".logFmt()
+            )
+            updateProgress(state = State.FAILED, message = e.originalStackTrace)
+            Result.failure()
         } catch (e: Exception) {
-            Log.e(tag, "Exception while patching".logFmt(), e)
+            Log.e(tag, "An exception occurred while patching".logFmt(), e)
             updateProgress(state = State.FAILED, message = e.stackTraceToString())
             Result.failure()
         } finally {
             patchedApk.delete()
+            if (args.input is SelectedApp.Local && args.input.temporary) {
+                args.input.file.delete()
+            }
         }
     }
 
     companion object {
-        private const val logPrefix = "[Worker]:"
-        private fun String.logFmt() = "$logPrefix $this"
+        private const val LOG_PREFIX = "[Worker]"
+        private fun String.logFmt() = "$LOG_PREFIX $this"
     }
 }

app/src/main/java/app/revanced/manager/service/RootService.kt

@@ -1,8 +1,6 @@
 package app.revanced.manager.service
 
-import android.content.ComponentName
 import android.content.Intent
-import android.content.ServiceConnection
 import android.os.IBinder
 import app.revanced.manager.IRootSystemService
 import com.topjohnwu.superuser.ipc.RootService
@@ -14,23 +12,5 @@ class ManagerRootService : RootService() {
             FileSystemManager.getService()
     }
 
-    override fun onBind(intent: Intent): IBinder {
-        return RootSystemService()
-    }
-}
-
-class RootConnection : ServiceConnection {
-    var remoteFS: FileSystemManager? = null
-        private set
-
-    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
-        val ipc = IRootSystemService.Stub.asInterface(service)
-        val binder = ipc.fileSystemService
-
-        remoteFS = FileSystemManager.getRemote(binder)
-    }
-
-    override fun onServiceDisconnected(name: ComponentName?) {
-        remoteFS = null
-    }
+    override fun onBind(intent: Intent): IBinder = RootSystemService()
 }

app/src/main/java/app/revanced/manager/ui/component/AlertDialogExtended.kt

@@ -9,8 +9,8 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.AlertDialogDefaults
+import androidx.compose.material3.BasicAlertDialog
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.LocalContentColor
 import androidx.compose.material3.LocalTextStyle
@@ -44,9 +44,9 @@ fun AlertDialogExtended(
     titleContentColor: Color = AlertDialogDefaults.titleContentColor,
     textContentColor: Color = AlertDialogDefaults.textContentColor,
     tonalElevation: Dp = AlertDialogDefaults.TonalElevation,
-    textHorizontalPadding: PaddingValues = PaddingValues(horizontal = 24.dp)
+    textHorizontalPadding: PaddingValues = TextHorizontalPadding
 ) {
-    AlertDialog(onDismissRequest = onDismissRequest) {
+    BasicAlertDialog(onDismissRequest = onDismissRequest) {
         Surface(
             modifier = modifier,
             shape = shape,
@@ -55,7 +55,7 @@ fun AlertDialogExtended(
         ) {
             Column(modifier = Modifier.padding(vertical = 24.dp)) {
                 Column(
-                    modifier = Modifier.padding(horizontal = 24.dp)
+                    modifier = Modifier.padding(horizontal = 24.dp).fillMaxWidth()
                 ) {
                     icon?.let {
                         ContentStyle(color = iconContentColor) {
@@ -147,4 +147,6 @@ private fun ContentStyle(
             content()
         }
     }
-}
+}
+
+val TextHorizontalPadding = PaddingValues(horizontal = 24.dp)

app/src/main/java/app/revanced/manager/ui/component/AppIcon.kt

@@ -16,7 +16,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.ColorFilter
 import androidx.compose.ui.graphics.vector.rememberVectorPainter
 import coil.compose.AsyncImage
-import com.google.accompanist.placeholder.placeholder
+import io.github.fornewid.placeholder.material3.placeholder
 
 @Composable
 fun AppIcon(
@@ -33,11 +33,9 @@ fun AppIcon(
         Image(
             image,
             contentDescription,
-            Modifier.placeholder(visible = showPlaceHolder, color = MaterialTheme.colorScheme.inverseOnSurface, shape = RoundedCornerShape(100)).then(modifier),
+            modifier,
             colorFilter = colorFilter
         )
-
-        showPlaceHolder = false
     } else {
         AsyncImage(
             packageInfo,

app/src/main/java/app/revanced/manager/ui/component/AppLabel.kt

@@ -16,7 +16,7 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.TextStyle
 import app.revanced.manager.R
-import com.google.accompanist.placeholder.placeholder
+import io.github.fornewid.placeholder.material3.placeholder
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 

app/src/main/java/app/revanced/manager/ui/component/AppScaffold.kt

@@ -4,9 +4,20 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.RowScope
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
-import androidx.compose.material3.*
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.TopAppBarScrollBehavior
+import androidx.compose.material3.rememberTopAppBarState
+import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
@@ -44,9 +55,14 @@ fun AppTopBar(
         )
     },
     actions: @Composable (RowScope.() -> Unit) = {},
-    scrollBehavior: TopAppBarScrollBehavior? = null
+    scrollBehavior: TopAppBarScrollBehavior? = null,
+    applyContainerColor: Boolean = false
 ) {
-    val containerColor = MaterialTheme.colorScheme.surfaceColorAtElevation(3.0.dp)
+    val containerColor = if (applyContainerColor) {
+        MaterialTheme.colorScheme.surfaceColorAtElevation(3.0.dp)
+    } else {
+        Color.Unspecified
+    }
 
     TopAppBar(
         title = { Text(title) },
@@ -65,3 +81,41 @@ fun AppTopBar(
     )
 }
 
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AppTopBar(
+    title: @Composable () -> Unit,
+    onBackClick: (() -> Unit)? = null,
+    backIcon: @Composable (() -> Unit) = @Composable {
+        Icon(
+            imageVector = Icons.AutoMirrored.Filled.ArrowBack, contentDescription = stringResource(
+                R.string.back
+            )
+        )
+    },
+    actions: @Composable (RowScope.() -> Unit) = {},
+    scrollBehavior: TopAppBarScrollBehavior? = null,
+    applyContainerColor: Boolean = false
+) {
+    val containerColor = if (applyContainerColor) {
+        MaterialTheme.colorScheme.surfaceColorAtElevation(3.0.dp)
+    } else {
+        Color.Unspecified
+    }
+
+    TopAppBar(
+        title = title,
+        scrollBehavior = scrollBehavior,
+        navigationIcon = {
+            if (onBackClick != null) {
+                IconButton(onClick = onBackClick) {
+                    backIcon()
+                }
+            }
+        },
+        actions = actions,
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = containerColor
+        )
+    )
+}

app/src/main/java/app/revanced/manager/ui/component/ArrowButton.kt

@@ -13,10 +13,16 @@ import androidx.compose.ui.res.stringResource
 import app.revanced.manager.R
 
 @Composable
-fun ArrowButton(modifier: Modifier = Modifier, expanded: Boolean, onClick: (() -> Unit)?) {
+fun ArrowButton(
+    modifier: Modifier = Modifier,
+    expanded: Boolean,
+    onClick: (() -> Unit)?,
+    rotationInitial: Float = 0f,
+    rotationFinal: Float = 180f
+) {
     val description = if (expanded) R.string.collapse_content else R.string.expand_content
     val rotation by animateFloatAsState(
-        targetValue = if (expanded) 0f else 180f,
+        targetValue = if (expanded) rotationInitial else rotationFinal,
         label = "rotation"
     )
 

app/src/main/java/app/revanced/manager/ui/component/AutoUpdatesDialog.kt

@@ -4,16 +4,13 @@ import androidx.annotation.StringRes
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Source
 import androidx.compose.material.icons.outlined.Update
 import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Checkbox
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.ListItem
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
@@ -21,13 +18,13 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import app.revanced.manager.R
+import app.revanced.manager.ui.component.haptics.HapticCheckbox
+import app.revanced.manager.util.transparentListItemColors
 
 @Composable
 fun AutoUpdatesDialog(onSubmit: (Boolean, Boolean) -> Unit) {
@@ -37,52 +34,35 @@ fun AutoUpdatesDialog(onSubmit: (Boolean, Boolean) -> Unit) {
     AlertDialog(
         onDismissRequest = {},
         confirmButton = {
-            TextButton(
-                onClick = { onSubmit(managerEnabled, patchesEnabled) }
-            ) {
+            TextButton(onClick = { onSubmit(managerEnabled, patchesEnabled) }) {
                 Text(stringResource(R.string.save))
             }
         },
-        icon = {
-            Icon(Icons.Outlined.Update, null)
-        },
-        title = {
-            Text(
-                text = stringResource(R.string.auto_updates_dialog_title),
-                style = MaterialTheme.typography.headlineSmall.copy(textAlign = TextAlign.Center),
-                color = MaterialTheme.colorScheme.onSurface,
-            )
-        },
+        icon = { Icon(Icons.Outlined.Update, null) },
+        title = { Text(text = stringResource(R.string.auto_updates_dialog_title)) },
         text = {
             Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.spacedBy(16.dp),
+                verticalArrangement = Arrangement.spacedBy(8.dp),
             ) {
-                Text(
-                    text = stringResource(R.string.auto_updates_dialog_description),
-                    style = MaterialTheme.typography.bodyMedium,
-                )
+                Text(text = stringResource(R.string.auto_updates_dialog_description))
 
-                AutoUpdatesItem(
-                    headline = R.string.auto_updates_dialog_manager,
-                    icon = Icons.Outlined.Update,
-                    checked = managerEnabled,
-                    onCheckedChange = { managerEnabled = it }
-                )
-                HorizontalDivider()
-                AutoUpdatesItem(
-                    headline = R.string.auto_updates_dialog_patches,
-                    icon = Icons.Outlined.Source,
-                    checked = patchesEnabled,
-                    onCheckedChange = { patchesEnabled = it }
-                )
+                Column {
+                    AutoUpdatesItem(
+                        headline = R.string.auto_updates_dialog_manager,
+                        icon = Icons.Outlined.Update,
+                        checked = managerEnabled,
+                        onCheckedChange = { managerEnabled = it }
+                    )
+                    HorizontalDivider()
+                    AutoUpdatesItem(
+                        headline = R.string.auto_updates_dialog_patches,
+                        icon = Icons.Outlined.Source,
+                        checked = patchesEnabled,
+                        onCheckedChange = { patchesEnabled = it }
+                    )
+                }
 
-                Text(
-                    text = stringResource(R.string.auto_updates_dialog_note),
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    modifier = Modifier.fillMaxWidth()
-                )
+                Text(text = stringResource(R.string.auto_updates_dialog_note))
             }
         }
     )
@@ -94,22 +74,10 @@ private fun AutoUpdatesItem(
     icon: ImageVector,
     checked: Boolean,
     onCheckedChange: (Boolean) -> Unit
-) {
-    ListItem(
-        leadingContent = { Icon(icon, null, tint = MaterialTheme.colorScheme.onSurface) },
-        headlineContent = {
-            Text(
-                text = stringResource(headline),
-                style = MaterialTheme.typography.bodyLarge,
-                color = MaterialTheme.colorScheme.onSurface
-            )
-        },
-        trailingContent = {
-            Checkbox(
-                checked = checked,
-                onCheckedChange = onCheckedChange
-            )
-        },
-        modifier = Modifier.clickable { onCheckedChange(!checked) }
-    )
-}
+) = ListItem(
+    leadingContent = { Icon(icon, null) },
+    headlineContent = { Text(stringResource(headline)) },
+    trailingContent = { HapticCheckbox(checked = checked, onCheckedChange = null) },
+    modifier = Modifier.clickable { onCheckedChange(!checked) },
+    colors = transparentListItemColors
+)

app/src/main/java/app/revanced/manager/ui/component/AvailableUpdateDialog.kt

@@ -0,0 +1,84 @@
+package app.revanced.manager.ui.component
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Update
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import app.revanced.manager.R
+import app.revanced.manager.ui.component.haptics.HapticCheckbox
+import app.revanced.manager.util.transparentListItemColors
+
+@Composable
+fun AvailableUpdateDialog(
+    onDismiss: () -> Unit,
+    onConfirm: () -> Unit,
+    setShowManagerUpdateDialogOnLaunch: (Boolean) -> Unit,
+    newVersion: String
+) {
+    var dontShowAgain by rememberSaveable { mutableStateOf(false) }
+    val dismissDialog = {
+        setShowManagerUpdateDialogOnLaunch(!dontShowAgain)
+        onDismiss()
+    }
+
+    AlertDialogExtended(
+        onDismissRequest = dismissDialog,
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    dismissDialog()
+                    onConfirm()
+                }
+            ) {
+                Text(stringResource(R.string.show))
+            }
+        },
+        dismissButton = {
+            TextButton(
+                onClick = dismissDialog
+            ) {
+                Text(stringResource(R.string.dismiss))
+            }
+        },
+        icon = {
+            Icon(imageVector = Icons.Outlined.Update, contentDescription = null)
+        },
+        title = {
+            Text(stringResource(R.string.update_available))
+        },
+        text = {
+            Column(
+                modifier = Modifier.padding(horizontal = 8.dp),
+                verticalArrangement = Arrangement.spacedBy(4.dp),
+            ) {
+                Text(
+                    modifier = Modifier.padding(horizontal = 16.dp),
+                    text = stringResource(R.string.update_available_dialog_description, newVersion)
+                )
+                ListItem(
+                    modifier = Modifier.clickable { dontShowAgain = !dontShowAgain },
+                    headlineContent = {
+                        Text(stringResource(R.string.never_show_again))
+                    },
+                    leadingContent = {
+                        CompositionLocalProvider(LocalMinimumInteractiveComponentSize provides Dp.Unspecified) {
+                            HapticCheckbox(checked = dontShowAgain, onCheckedChange = { dontShowAgain = it })
+                        }
+                    },
+                    colors = transparentListItemColors
+                )
+            }
+        },
+        textHorizontalPadding = PaddingValues(0.dp)
+    )
+}

app/src/main/java/app/revanced/manager/ui/component/CheckedFilterChip.kt

@@ -0,0 +1,61 @@
+package app.revanced.manager.ui.component
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandIn
+import androidx.compose.animation.shrinkOut
+import androidx.compose.foundation.BorderStroke
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Done
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.FilterChipDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.SelectableChipColors
+import androidx.compose.material3.SelectableChipElevation
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Shape
+
+@Composable
+fun CheckedFilterChip(
+    selected: Boolean,
+    onClick: () -> Unit,
+    label: @Composable () -> Unit,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+    trailingIcon: @Composable (() -> Unit)? = null,
+    shape: Shape = FilterChipDefaults.shape,
+    colors: SelectableChipColors = FilterChipDefaults.filterChipColors(),
+    elevation: SelectableChipElevation? = FilterChipDefaults.filterChipElevation(),
+    border: BorderStroke? = FilterChipDefaults.filterChipBorder(enabled, selected),
+    interactionSource: MutableInteractionSource? = null
+) {
+    FilterChip(
+        selected = selected,
+        onClick = onClick,
+        label = label,
+        modifier = modifier,
+        enabled = enabled,
+        leadingIcon = {
+            AnimatedVisibility(
+                visible = selected,
+                enter = expandIn(expandFrom = Alignment.CenterStart),
+                exit = shrinkOut(shrinkTowards = Alignment.CenterStart)
+            ) {
+                Icon(
+                    modifier = Modifier.size(FilterChipDefaults.IconSize),
+                    imageVector = Icons.Filled.Done,
+                    contentDescription = null,
+                )
+            }
+        },
+        trailingIcon = trailingIcon,
+        shape = shape,
+        colors = colors,
+        elevation = elevation,
+        border = border,
+        interactionSource = interactionSource
+    )
+}

app/src/main/java/app/revanced/manager/ui/component/ConfirmDialog.kt

@@ -0,0 +1,41 @@
+package app.revanced.manager.ui.component
+
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
+import app.revanced.manager.R
+
+@Composable
+fun ConfirmDialog(
+    onDismiss: () -> Unit,
+    onConfirm: () -> Unit,
+    title: String,
+    description: String,
+    icon: ImageVector
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        dismissButton = {
+            TextButton(onDismiss) {
+                Text(stringResource(R.string.cancel))
+            }
+        },
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    onConfirm()
+                    onDismiss()
+                }
+            ) {
+                Text(stringResource(R.string.confirm))
+            }
+        },
+        title = { Text(title) },
+        icon = { Icon(icon, null) },
+        text = { Text(description) }
+    )
+}

app/src/main/java/app/revanced/manager/ui/component/Countdown.kt

@@ -1,26 +0,0 @@
-package app.revanced.manager.ui.component
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import kotlinx.coroutines.delay
-
-@Composable
-fun Countdown(start: Int, content: @Composable (Int) -> Unit) {
-    var timer by rememberSaveable(start) {
-        mutableStateOf(start)
-    }
-    LaunchedEffect(timer) {
-        if (timer == 0) {
-            return@LaunchedEffect
-        }
-
-        delay(1000L)
-        timer -= 1
-    }
-
-    content(timer)
-}

app/src/main/java/app/revanced/manager/ui/component/ExceptionViewerDialog.kt

@@ -0,0 +1,73 @@
+package app.revanced.manager.ui.component
+
+import android.content.Intent
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.outlined.Share
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import app.revanced.manager.R
+import app.revanced.manager.ui.component.bundle.BundleTopBar
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun ExceptionViewerDialog(text: String, onDismiss: () -> Unit) {
+    val context = LocalContext.current
+
+    FullscreenDialog(
+        onDismissRequest = onDismiss,
+    ) {
+        Scaffold(
+            topBar = {
+                BundleTopBar(
+                    title = stringResource(R.string.bundle_error),
+                    onBackClick = onDismiss,
+                    backIcon = {
+                        Icon(
+                            Icons.AutoMirrored.Filled.ArrowBack,
+                            stringResource(R.string.back)
+                        )
+                    },
+                    actions = {
+                        IconButton(
+                            onClick = {
+                                val sendIntent: Intent = Intent().apply {
+                                    action = Intent.ACTION_SEND
+                                    putExtra(
+                                        Intent.EXTRA_TEXT,
+                                        text
+                                    )
+                                    type = "text/plain"
+                                }
+
+                                val shareIntent = Intent.createChooser(sendIntent, null)
+                                context.startActivity(shareIntent)
+                            }
+                        ) {
+                            Icon(
+                                Icons.Outlined.Share,
+                                contentDescription = stringResource(R.string.share)
+                            )
+                        }
+                    }
+                )
+            }
+        ) { paddingValues ->
+            ColumnWithScrollbar(
+                modifier = Modifier.padding(paddingValues)
+            ) {
+                Text(text, modifier = Modifier.horizontalScroll(rememberScrollState()))
+            }
+        }
+    }
+}

app/src/main/java/app/revanced/manager/ui/component/FullscreenDialog.kt

@@ -0,0 +1,34 @@
+package app.revanced.manager.ui.component
+
+import android.view.WindowManager
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import androidx.compose.ui.window.DialogWindowProvider
+
+private val properties = DialogProperties(
+    usePlatformDefaultWidth = false,
+    dismissOnBackPress = true,
+    decorFitsSystemWindows = false,
+)
+
+@Composable
+fun FullscreenDialog(onDismissRequest: () -> Unit, content: @Composable () -> Unit) {
+    Dialog(
+        onDismissRequest = onDismissRequest,
+        properties = properties
+    ) {
+        val window = (LocalView.current.parent as DialogWindowProvider).window
+        LaunchedEffect(Unit) {
+            window.statusBarColor = Color.Transparent.toArgb()
+            window.navigationBarColor = Color.Transparent.toArgb()
+            window.addFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS)
+        }
+
+        content()
+    }
+}

app/src/main/java/app/revanced/manager/ui/component/InstallerStatusDialog.kt

@@ -0,0 +1,149 @@
+package app.revanced.manager.ui.component
+
+import android.content.pm.PackageInstaller
+import androidx.annotation.RequiresApi
+import androidx.annotation.StringRes
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.ErrorOutline
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import app.revanced.manager.R
+import app.revanced.manager.ui.model.InstallerModel
+import com.github.materiiapps.enumutil.FromValue
+
+private typealias InstallerStatusDialogButtonHandler = ((model: InstallerModel) -> Unit)
+private typealias InstallerStatusDialogButton = @Composable (model: InstallerModel, dismiss: () -> Unit) -> Unit
+
+@Composable
+fun InstallerStatusDialog(installerStatus: Int, model: InstallerModel, onDismiss: () -> Unit) {
+    val dialogKind = remember {
+        DialogKind.fromValue(installerStatus) ?: DialogKind.FAILURE
+    }
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        confirmButton = {
+            dialogKind.confirmButton(model, onDismiss)
+        },
+        dismissButton = {
+            dialogKind.dismissButton?.invoke(model, onDismiss)
+        },
+        icon = {
+            Icon(dialogKind.icon, null)
+        },
+        title = {
+            Text(
+                text = stringResource(dialogKind.title),
+                style = MaterialTheme.typography.headlineSmall.copy(textAlign = TextAlign.Center),
+                color = MaterialTheme.colorScheme.onSurface,
+            )
+        },
+        text = {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(16.dp),
+            ) {
+                Text(stringResource(dialogKind.contentStringResId))
+            }
+        }
+    )
+}
+
+private fun installerStatusDialogButton(
+    @StringRes buttonStringResId: Int,
+    buttonHandler: InstallerStatusDialogButtonHandler = { },
+): InstallerStatusDialogButton = { model, dismiss ->
+    TextButton(
+        onClick = {
+            dismiss()
+            buttonHandler(model)
+        }
+    ) {
+        Text(stringResource(buttonStringResId))
+    }
+}
+
+@FromValue("flag")
+enum class DialogKind(
+    val flag: Int,
+    val title: Int,
+    @StringRes val contentStringResId: Int,
+    val icon: ImageVector = Icons.Outlined.ErrorOutline,
+    val confirmButton: InstallerStatusDialogButton = installerStatusDialogButton(R.string.ok),
+    val dismissButton: InstallerStatusDialogButton? = null,
+) {
+    FAILURE(
+        flag = PackageInstaller.STATUS_FAILURE,
+        title = R.string.installation_failed_dialog_title,
+        contentStringResId = R.string.installation_failed_description,
+        confirmButton = installerStatusDialogButton(R.string.install_app) { model ->
+            model.install()
+        }
+    ),
+    FAILURE_ABORTED(
+        flag = PackageInstaller.STATUS_FAILURE_ABORTED,
+        title = R.string.installation_cancelled_dialog_title,
+        contentStringResId = R.string.installation_aborted_description,
+        confirmButton = installerStatusDialogButton(R.string.install_app) { model ->
+            model.install()
+        }
+    ),
+    FAILURE_BLOCKED(
+        flag = PackageInstaller.STATUS_FAILURE_BLOCKED,
+        title = R.string.installation_blocked_dialog_title,
+        contentStringResId = R.string.installation_blocked_description,
+    ),
+    FAILURE_CONFLICT(
+        flag = PackageInstaller.STATUS_FAILURE_CONFLICT,
+        title = R.string.installation_conflict_dialog_title,
+        contentStringResId = R.string.installation_conflict_description,
+        confirmButton = installerStatusDialogButton(R.string.reinstall) { model ->
+            model.reinstall()
+        },
+        dismissButton = installerStatusDialogButton(R.string.cancel),
+    ),
+    FAILURE_INCOMPATIBLE(
+        flag = PackageInstaller.STATUS_FAILURE_INCOMPATIBLE,
+        title = R.string.installation_incompatible_dialog_title,
+        contentStringResId = R.string.installation_incompatible_description,
+    ),
+    FAILURE_INVALID(
+        flag = PackageInstaller.STATUS_FAILURE_INVALID,
+        title = R.string.installation_invalid_dialog_title,
+        contentStringResId = R.string.installation_invalid_description,
+        confirmButton = installerStatusDialogButton(R.string.reinstall) { model ->
+            model.reinstall()
+        },
+        dismissButton = installerStatusDialogButton(R.string.cancel),
+    ),
+    FAILURE_STORAGE(
+        flag = PackageInstaller.STATUS_FAILURE_STORAGE,
+        title = R.string.installation_storage_issue_dialog_title,
+        contentStringResId = R.string.installation_storage_issue_description,
+    ),
+
+    @RequiresApi(34)
+    FAILURE_TIMEOUT(
+        flag = PackageInstaller.STATUS_FAILURE_TIMEOUT,
+        title = R.string.installation_timeout_dialog_title,
+        contentStringResId = R.string.installation_timeout_description,
+        confirmButton = installerStatusDialogButton(R.string.install_app) { model ->
+            model.install()
+        },
+    );
+
+    // Needed due to the @FromValue annotation.
+    companion object
+}

app/src/main/java/app/revanced/manager/ui/component/Markdown.kt

@@ -3,10 +3,9 @@ package app.revanced.manager.ui.component
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.sp
 import com.mikepenz.markdown.compose.Markdown
-import com.mikepenz.markdown.model.markdownColor
-import com.mikepenz.markdown.model.markdownTypography
+import com.mikepenz.markdown.m3.markdownColor
+import com.mikepenz.markdown.m3.markdownTypography
 
 @Composable
 fun Markdown(
@@ -19,7 +18,8 @@ fun Markdown(
         colors = markdownColor(
             text = MaterialTheme.colorScheme.onSurfaceVariant,
             codeBackground = MaterialTheme.colorScheme.secondaryContainer,
-            codeText = MaterialTheme.colorScheme.onSecondaryContainer
+            codeText = MaterialTheme.colorScheme.onSecondaryContainer,
+            linkText = MaterialTheme.colorScheme.primary
         ),
         typography = markdownTypography(
             h1 = MaterialTheme.typography.headlineSmall.copy(fontWeight = FontWeight.Bold),

app/src/main/java/app/revanced/manager/ui/component/NotificationCard.kt

@@ -1,8 +1,10 @@
 package app.revanced.manager.ui.component
 
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
@@ -11,7 +13,6 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Close
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -27,74 +28,73 @@ import app.revanced.manager.R
 
 @Composable
 fun NotificationCard(
-    isWarning: Boolean = false,
-    title: String? = null,
     text: String,
     icon: ImageVector,
-    actions: (@Composable () -> Unit)?
+    modifier: Modifier = Modifier,
+    actions: (@Composable RowScope.() -> Unit)? = null,
+    title: String? = null,
+    isWarning: Boolean = false
 ) {
     val color =
         if (isWarning) MaterialTheme.colorScheme.onError else MaterialTheme.colorScheme.onPrimaryContainer
 
-    NotificationCardInstance(isWarning = isWarning) {
-        Column(
-            modifier = Modifier.padding(if (title != null) 20.dp else 16.dp),
-            verticalArrangement = Arrangement.spacedBy(16.dp)
+    NotificationCardInstance(modifier = modifier, isWarning = isWarning) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            horizontalArrangement = Arrangement.spacedBy(16.dp)
         ) {
-            if (title != null) {
+            Box(
+                modifier = Modifier.size(28.dp),
+                contentAlignment = Alignment.Center
+            ) {
                 Icon(
-                    modifier = Modifier.size(36.dp),
+                    modifier = Modifier.size(24.dp),
                     imageVector = icon,
                     contentDescription = null,
                     tint = color,
                 )
-                Column(
-                    verticalArrangement = Arrangement.spacedBy(6.dp)
-                ) {
+            }
+
+            Column(
+                verticalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                title?.let {
                     Text(
-                        text = title,
+                        text = it,
                         style = MaterialTheme.typography.titleLarge,
                         color = color,
                     )
-                    Text(
-                        text = text,
-                        style = MaterialTheme.typography.bodyMedium,
-                        color = color,
-                    )
                 }
-            } else {
-                Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) {
-                    Icon(
-                        modifier = Modifier.size(24.dp),
-                        imageVector = icon,
-                        contentDescription = null,
-                        tint = color,
-                    )
-                    Text(
-                        text = text,
-                        style = MaterialTheme.typography.bodyMedium,
-                        color = color,
-                    )
+                Text(
+                    text = text,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = color,
+                )
+                Row(
+                    horizontalArrangement = Arrangement.End,
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    actions?.invoke(this)
                 }
             }
-            actions?.invoke()
         }
     }
 }
 
 @Composable
 fun NotificationCard(
-    isWarning: Boolean = false,
-    title: String? = null,
     text: String,
     icon: ImageVector,
+    modifier: Modifier = Modifier,
+    title: String? = null,
+    isWarning: Boolean = false,
     onDismiss: (() -> Unit)? = null,
-    primaryAction: (() -> Unit)? = null
+    onClick: (() -> Unit)? = null
 ) {
     val color =
         if (isWarning) MaterialTheme.colorScheme.onError else MaterialTheme.colorScheme.onPrimaryContainer
 
-    NotificationCardInstance(isWarning = isWarning, onClick = primaryAction) {
+    NotificationCardInstance(modifier = modifier, isWarning = isWarning, onClick = onClick) {
         Row(
             modifier = Modifier
                 .fillMaxWidth()
@@ -102,12 +102,17 @@ fun NotificationCard(
             verticalAlignment = Alignment.CenterVertically,
             horizontalArrangement = Arrangement.spacedBy(16.dp),
         ) {
-            Icon(
-                modifier = Modifier.size(if (title != null) 36.dp else 24.dp),
-                imageVector = icon,
-                contentDescription = null,
-                tint = color,
-            )
+            Box(
+                modifier = Modifier.size(28.dp),
+                contentAlignment = Alignment.Center
+            ) {
+                Icon(
+                    modifier = Modifier.size(24.dp),
+                    imageVector = icon,
+                    contentDescription = null,
+                    tint = color,
+                )
+            }
             if (title != null) {
                 Column(
                     modifier = Modifier.weight(1f),
@@ -145,32 +150,31 @@ fun NotificationCard(
     }
 }
 
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 private fun NotificationCardInstance(
+    modifier: Modifier = Modifier,
     isWarning: Boolean = false,
     onClick: (() -> Unit)? = null,
     content: @Composable () -> Unit,
 ) {
     val colors =
         CardDefaults.cardColors(containerColor = if (isWarning) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.primaryContainer)
-    val modifier = Modifier
+    val defaultModifier = Modifier
         .fillMaxWidth()
-        .padding(16.dp)
         .clip(RoundedCornerShape(24.dp))
 
     if (onClick != null) {
         Card(
             onClick = onClick,
             colors = colors,
-            modifier = modifier
+            modifier = modifier.then(defaultModifier)
         ) {
             content()
         }
     } else {
         Card(
             colors = colors,
-            modifier = modifier,
+            modifier = modifier.then(defaultModifier)
         ) {
             content()
         }