chore: Release v5.7.1-dev.3 [skip ci]

## [5.7.1-dev.3](https://github.com/ReVanced/revanced-patches/compare/v5.7.1-dev.2...v5.7.1-dev.3) (2024-12-22)

### Bug Fixes

* **YouTube - SponsorBlock:** Show a toast and not a dialog if segment submitted successfully ([838edb4](838edb48e7))

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -70,7 +70,7 @@ body:
 
         Before creating a new bug report, please keep the following in mind:
 
-        - **Do not submit a duplicate bug report**: You can review existing bug reports [here](https://github.com/ReVanced/revanced-patches/labels/Bug%20report).
+        - **Do not submit a duplicate bug report**: Search for existing bug reports [here](https://github.com/ReVanced/revanced-patches/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-patches/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
@@ -102,7 +102,7 @@ body:
       label: Acknowledgements
       description: Your bug report will be closed if you don't follow the checklist below.
       options:
-        - label: This issue is not a duplicate of an existing bug report.
+        - 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

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -70,7 +70,7 @@ body:
 
         Before creating a new feature request, please keep the following in mind:
 
-        - **Do not submit a duplicate feature request**: You can review existing feature requests [here](https://github.com/ReVanced/revanced-patches/labels/Feature%20request).
+        - **Do not submit a duplicate feature request**: Search for existing feature requests [here](https://github.com/ReVanced/revanced-patches/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-patches/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
@@ -98,7 +98,7 @@ body:
       label: Acknowledgements
       description: Your feature request will be closed if you don't follow the checklist below.
       options:
-        - label: This issue is not a duplicate of an existing feature request.
+        - 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

.github/workflows/build_pull_request.yml

@@ -16,10 +16,22 @@ jobs:
         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 build --no-daemon
+        run: ./gradlew :patches:buildAndroid --no-daemon
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: revanced-patches
+          path: patches/build/libs

.github/workflows/open_pull_request.yml

@@ -20,12 +20,12 @@ jobs:
       - name: Open pull request
         uses: repo-sync/pull-request@v2
         with:
-          destination_branch: 'main'
+          destination_branch: main
           pr_title: 'chore: ${{ env.MESSAGE }}'
           pr_body: |
             This pull request will ${{ env.MESSAGE }}.
-          
-            ## Dependencies before merge
 
-            - [ ] https://github.com/revanced/revanced-integrations
+            ## Before merging this PR
+
+            - [ ] Pull translations from Crowdin
           pr_draft: true

.github/workflows/pull_strings.yml

@@ -1,34 +1,42 @@
 name: Pull strings
 
 on:
-    workflow_dispatch:
-    schedule:
-        - cron: 0 0 1 * *
+  schedule:
+    - cron: "0 */8 * * *"
+  workflow_dispatch:
 
 jobs:
-    pull:
-        name: Pull strings
-        runs-on: ubuntu-latest
-        steps:
-            - name: Checkout
-              uses: actions/checkout@v4
-              with:
-                  fetch-depth: 0
+  pull:
+    name: Pull strings
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: dev
 
-            - name: Pull strings
-              uses: crowdin/github-action@v1
-              with:
-                  config: crowdin.yml
-                  download_translations: true
-                  localization_branch_name: feat/translations
-                  create_pull_request: true
-                  pull_request_title: "chore: Sync translations"
-                  pull_request_body: "Sync translations from [crowdin.com/project/revanced](https://crowdin.com/project/revanced)"
-                  pull_request_base_branch_name: "dev"
-                  commit_message: "chore: Sync translations"
-                  github_user_name: revanced-bot
-                  github_user_email: github@revanced.app
-              env:
-                  GITHUB_TOKEN: ${{ secrets.REPOSITORY_PUSH_ACCESS }}
-                  CROWDIN_PROJECT_ID: ${{ secrets.CROWDIN_PROJECT_ID }}
-                  CROWDIN_PERSONAL_TOKEN: ${{ secrets.CROWDIN_PERSONAL_TOKEN }}
+      - name: Pull strings
+        uses: crowdin/github-action@v2
+        with:
+          config: crowdin.yml
+          upload_sources: false
+          download_translations: true
+          localization_branch_name: feat/translations
+          create_pull_request: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CROWDIN_PROJECT_ID: ${{ secrets.CROWDIN_PROJECT_ID }}
+          CROWDIN_PERSONAL_TOKEN: ${{ secrets.CROWDIN_PERSONAL_TOKEN }}
+
+      - name: Open pull request
+        if: github.event_name == 'workflow_dispatch'
+        uses: repo-sync/pull-request@v2
+        with:
+          source_branch: feat/translations
+          destination_branch: dev
+          pr_title: "chore: Sync translations"
+          pr_body: "Sync translations from [crowdin.com/project/revanced](https://crowdin.com/project/revanced)"

.github/workflows/push_strings.yml

@@ -1,27 +1,28 @@
 name: Push strings
 
 on:
-    workflow_dispatch:
-    push:
-        paths:
-            - /src/main/resources/addresources/values/strings.xml
+  workflow_dispatch:
+  push:
+    branches:
+      - dev
+    paths:
+      - patches/src/main/resources/addresources/values/strings.xml
 
 jobs:
-    push:
-        name: Push strings
-        runs-on: ubuntu-latest
-        steps:
-            - name: Checkout
-              uses: actions/checkout@v4
-              with:
-                  fetch-depth: 0
+  push:
+    name: Push strings
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
-            - name: Push strings
-              uses: crowdin/github-action@v1
-              with:
-                  config: crowdin.yml
-                  upload_sources: true
-              env:
-                  GITHUB_TOKEN: ${{ secrets.REPOSITORY_PUSH_ACCESS }}
-                  CROWDIN_PROJECT_ID: ${{ secrets.CROWDIN_PROJECT_ID }}
-                  CROWDIN_PERSONAL_TOKEN: ${{ secrets.CROWDIN_PERSONAL_TOKEN }}
+      - name: Push strings
+        uses: crowdin/github-action@v2
+        with:
+          config: crowdin.yml
+          upload_sources: true
+        env:
+          CROWDIN_PROJECT_ID: ${{ secrets.CROWDIN_PROJECT_ID }}
+          CROWDIN_PERSONAL_TOKEN: ${{ secrets.CROWDIN_PERSONAL_TOKEN }}

.github/workflows/release.yml

@@ -10,6 +10,9 @@ on:
 jobs:
   release:
     name: Release
+    permissions:
+      contents: write
+      packages: write
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -20,13 +23,19 @@ jobs:
           persist-credentials: false
           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 generateMeta clean
+        run: ./gradlew :patches:buildAndroid clean
 
       - name: Setup Node.js
         uses: actions/setup-node@v4
@@ -42,9 +51,9 @@ jobs:
         with:
           gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
           passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          fingerprint: ${{ env.GPG_FINGERPRINT }}
+          fingerprint: ${{ vars.GPG_FINGERPRINT }}
 
       - name: Release
         env:
-          GITHUB_TOKEN: ${{ secrets.REPOSITORY_PUSH_ACCESS }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: npm exec semantic-release

.gitignore

@@ -122,5 +122,8 @@ gradle-app.setting
 # Dependency directories
 node_modules/
 
-# gradle properties, due to Github token
+# Gradle properties, due to Github token
 ./gradle.properties
+
+# One package is called the same as the Gradle build folder
+!**/src/**/build/

.idea/misc.xml

@@ -4,5 +4,5 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="azul-17" project-jdk-type="JavaSDK" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="azul-17" project-jdk-type="JavaSDK" />
 </project>

.releaserc

@@ -21,11 +21,10 @@
       "@semantic-release/git",
       {
         "assets": [
-          "README.md",
           "CHANGELOG.md",
           "gradle.properties",
-          "patches.json"
-        ]
+        ],
+        "message": "chore: Release v${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
       }
     ],
     [
@@ -33,11 +32,8 @@
       {
         "assets": [
           {
-            "path": "build/libs/revanced-patches*"
+            "path": "patches/build/libs/patches-!(*sources*|*javadoc*).rvp?(.asc)"
           },
-          {
-            "path": "patches.json"
-          }
         ],
         successComment: false
       }

CONTRIBUTING.md

@@ -64,7 +64,7 @@ This document describes how to contribute to ReVanced Patches.
 
 ## 📖 Resources to help you get started
 
-* The [documentation](https://github.com/ReVanced/revanced-patcher/tree/docs/docs) contains the fundamentals
+* The [documentation](https://github.com/ReVanced/revanced-patcher/tree/main/docs) contains the fundamentals
 of ReVanced Patcher and how to use ReVanced Patcher to create patches
 * [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-patches/issues) are where we keep track of bugs and feature requests
@@ -83,6 +83,10 @@ Features can be requested by opening an issue using the
 If you encounter a bug while using ReVanced Patches, open an issue using the
 [Bug report issue template](https://github.com/ReVanced/revanced-patches/issues/new?assignees=&labels=Bug+report&projects=&template=bug_report.yml&title=bug%3A+).
 
+## 🌐 Submitting translations
+
+ You can contribute translations at [translate.revanced.app](https://translate.revanced.app).
+
 ## 🧑‍⚖️ Guidelines for requesting or contributing patches
 
 To maintain a high-quality and ethical collection of patches, the following guidelines for requesting
@@ -107,7 +111,6 @@ are unaffected by this change.
 * Payment circumvention: We do not accept patches that exist solely to bypass payment for the app or any of its features
 * Malicious patches: Patches that are malicious in nature are not allowed
 
-
 ## 📝 How to contribute
 
 1. Before contributing, it is recommended to open an issue to discuss your change
@@ -115,11 +118,11 @@ with the maintainers of ReVanced Patches. This will help you determine whether y
 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. In case you are contributing a new patch, make sure to follow the conventions for patches
-described in the [documentation](https://github.com/ReVanced/revanced-patches/tree/docs/docs)
+described in the [ReVanced Patcher documentation](https://github.com/ReVanced/revanced-patcher/tree/main/docs)
 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 Patches
-
+ 
 ❤️ Thank you for considering contributing to ReVanced Patches,
 ReVanced

build.gradle.kts

@@ -1,153 +0,0 @@
-import org.gradle.kotlin.dsl.support.listFilesOrdered
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-
-plugins {
-    alias(libs.plugins.kotlin)
-    alias(libs.plugins.binary.compatibility.validator)
-    `maven-publish`
-    signing
-}
-
-group = "app.revanced"
-
-repositories {
-    mavenCentral()
-    mavenLocal()
-    google()
-    maven {
-        // A repository must be specified for some reason. "registry" is a dummy.
-        url = uri("https://maven.pkg.github.com/revanced/registry")
-        credentials {
-            username = project.findProperty("gpr.user") as String? ?: System.getenv("GITHUB_ACTOR")
-            password = project.findProperty("gpr.key") as String? ?: System.getenv("GITHUB_TOKEN")
-        }
-    }
-}
-
-dependencies {
-    implementation(libs.revanced.patcher)
-    implementation(libs.smali)
-    // TODO: Required because build fails without it. Find a way to remove this dependency.
-    implementation(libs.guava)
-    // Used in JsonGenerator.
-    implementation(libs.gson)
-}
-
-kotlin {
-    compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_11)
-    }
-}
-
-java {
-    targetCompatibility = JavaVersion.VERSION_11
-}
-
-tasks {
-    withType(Jar::class) {
-        exclude("app/revanced/meta")
-
-        manifest {
-            attributes["Name"] = "ReVanced Patches"
-            attributes["Description"] = "Patches for ReVanced."
-            attributes["Version"] = version
-            attributes["Timestamp"] = System.currentTimeMillis().toString()
-            attributes["Source"] = "git@github.com:revanced/revanced-patches.git"
-            attributes["Author"] = "ReVanced"
-            attributes["Contact"] = "contact@revanced.app"
-            attributes["Origin"] = "https://revanced.app"
-            attributes["License"] = "GNU General Public License v3.0"
-        }
-    }
-
-    register("buildDexJar") {
-        description = "Build and add a DEX to the JAR file"
-        group = "build"
-
-        dependsOn(build)
-
-        doLast {
-            val d8 = File(System.getenv("ANDROID_HOME")).resolve("build-tools")
-                .listFilesOrdered().last().resolve("d8").absolutePath
-
-            val patchesJar = configurations.archives.get().allArtifacts.files.files.first().absolutePath
-            val workingDirectory = layout.buildDirectory.dir("libs").get().asFile
-
-            exec {
-                workingDir = workingDirectory
-                commandLine = listOf(d8, "--release", patchesJar)
-            }
-
-            exec {
-                workingDir = workingDirectory
-                commandLine = listOf("zip", "-u", patchesJar, "classes.dex")
-            }
-        }
-    }
-
-    register<JavaExec>("generatePatchesFiles") {
-        description = "Generate patches files"
-
-        dependsOn(build)
-
-        classpath = sourceSets["main"].runtimeClasspath
-        mainClass.set("app.revanced.generator.MainKt")
-    }
-
-    // Needed by gradle-semantic-release-plugin.
-    // Tracking: https://github.com/KengoTODA/gradle-semantic-release-plugin/issues/435
-    publish {
-        dependsOn("buildDexJar")
-        dependsOn("generatePatchesFiles")
-    }
-}
-
-publishing {
-    repositories {
-        maven {
-            name = "GitHubPackages"
-            url = uri("https://maven.pkg.github.com/revanced/revanced-patches")
-            credentials {
-                username = System.getenv("GITHUB_ACTOR")
-                password = System.getenv("GITHUB_TOKEN")
-            }
-        }
-    }
-
-    publications {
-        create<MavenPublication>("revanced-patches-publication") {
-            from(components["java"])
-
-            pom {
-                name = "ReVanced Patches"
-                description = "Patches for ReVanced."
-                url = "https://revanced.app"
-
-                licenses {
-                    license {
-                        name = "GNU General Public License v3.0"
-                        url = "https://www.gnu.org/licenses/gpl-3.0.en.html"
-                    }
-                }
-                developers {
-                    developer {
-                        id = "ReVanced"
-                        name = "ReVanced"
-                        email = "contact@revanced.app"
-                    }
-                }
-                scm {
-                    connection = "scm:git:git://github.com/revanced/revanced-patches.git"
-                    developerConnection = "scm:git:git@github.com:revanced/revanced-patches.git"
-                    url = "https://github.com/revanced/revanced-patches"
-                }
-            }
-        }
-    }
-}
-
-signing {
-    useGpgCmd()
-
-    sign(publishing.publications["revanced-patches-publication"])
-}

crowdin.yml

@@ -3,6 +3,6 @@ api_token_env: "CROWDIN_PERSONAL_TOKEN"
 
 preserve_hierarchy: false
 files:
-    - source: src/main/resources/addresources/values/strings.xml
-      translation: src/main/resources/addresources/values-%android_code%/strings.xml
+    - source: patches/src/main/resources/addresources/values/strings.xml
+      translation: patches/src/main/resources/addresources/values-%android_code%/strings.xml
       skip_untranslated_strings: true

extensions/all/misc/connectivity/wifi/spoof/spoof-wifi/build.gradle.kts

@@ -0,0 +1,5 @@
+android.namespace = "app.revanced.extension"
+
+dependencies {
+    compileOnly(libs.annotation)
+}

extensions/all/misc/connectivity/wifi/spoof/spoof-wifi/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+</manifest>

extensions/all/misc/connectivity/wifi/spoof/spoof-wifi/src/main/java/app/revanced/extension/all/connectivity/wifi/spoof/SpoofWifiPatch.java

@@ -0,0 +1,424 @@
+package app.revanced.extension.all.connectivity.wifi.spoof;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import android.net.NetworkRequest;
+import android.os.Build;
+import android.os.Handler;
+
+import androidx.annotation.RequiresApi;
+
+/** @noinspection deprecation, unused */
+public class SpoofWifiPatch {
+
+    // Used to check what the (real or fake) active network is (take a look at `hasTransport`).
+    private static ConnectivityManager CONNECTIVITY_MANAGER;
+
+    // If Wifi is not enabled, these are types that would pretend to be Wifi for android.net.Network (lower index = higher priority).
+    // This does not apply to android.net.NetworkInfo, because we can pretend that Wifi is always active there.
+    //
+    // VPN should be a fallback, because Reverse Tethering uses VPN.
+    private static final int[] FAKE_FALLBACK_NETWORKS = { NetworkCapabilities.TRANSPORT_ETHERNET, NetworkCapabilities.TRANSPORT_VPN };
+
+    // In order to initialize our own ConnectivityManager, if it isn't initialized yet.
+    public static Object getSystemService(Context context, String name) {
+        Object result = context.getSystemService(name);
+        if (CONNECTIVITY_MANAGER == null) {
+            if (Context.CONNECTIVITY_SERVICE.equals(name)) {
+                CONNECTIVITY_MANAGER = (ConnectivityManager) result;
+            } else {
+                CONNECTIVITY_MANAGER = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+            }
+        }
+        return result;
+    }
+
+    // In order to initialize our own ConnectivityManager, if it isn't initialized yet.
+    public static Object getSystemService(Context context, Class<?> serviceClass) {
+        Object result = context.getSystemService(serviceClass);
+        if (CONNECTIVITY_MANAGER == null) {
+            if (serviceClass == ConnectivityManager.class) {
+                CONNECTIVITY_MANAGER = (ConnectivityManager) result;
+            } else {
+                CONNECTIVITY_MANAGER = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+            }
+        }
+        return result;
+    }
+
+    // Simply always return Wifi as active network.
+    public static NetworkInfo getActiveNetworkInfo(ConnectivityManager connectivityManager) {
+        for (NetworkInfo networkInfo : connectivityManager.getAllNetworkInfo()) {
+            if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
+                return networkInfo;
+            }
+        }
+        return connectivityManager.getActiveNetworkInfo();
+    }
+
+    // Pretend Wifi is always connected.
+    public static boolean isConnected(NetworkInfo networkInfo) {
+        if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
+            return true;
+        }
+        return networkInfo.isConnected();
+    }
+
+    // Pretend Wifi is always connected.
+    public static boolean isConnectedOrConnecting(NetworkInfo networkInfo) {
+        if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
+            return true;
+        }
+        return networkInfo.isConnectedOrConnecting();
+    }
+
+    // Pretend Wifi is always available.
+    public static boolean isAvailable(NetworkInfo networkInfo) {
+        if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
+            return true;
+        }
+        return networkInfo.isAvailable();
+    }
+
+    // Pretend Wifi is always connected.
+    public static NetworkInfo.State getState(NetworkInfo networkInfo) {
+        if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
+            return NetworkInfo.State.CONNECTED;
+        }
+        return networkInfo.getState();
+    }
+
+    // Pretend Wifi is always connected.
+    public static NetworkInfo.DetailedState getDetailedState(NetworkInfo networkInfo) {
+        if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
+            return NetworkInfo.DetailedState.CONNECTED;
+        }
+        return networkInfo.getDetailedState();
+    }
+
+    // Pretend Wifi is enabled, so connection isn't metered.
+    public static boolean isActiveNetworkMetered(ConnectivityManager connectivityManager) {
+        return false;
+    }
+
+    // Returns the Wifi network, if Wifi is enabled.
+    // Otherwise if one of our fallbacks has a connection, return them.
+    // And as a last resort, return the default active network.
+    public static Network getActiveNetwork(ConnectivityManager connectivityManager) {
+        Network[] prioritizedNetworks = new Network[FAKE_FALLBACK_NETWORKS.length];
+        for (Network network : connectivityManager.getAllNetworks()) {
+            NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
+            if (networkCapabilities == null) {
+                continue;
+            }
+            if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+                return network;
+            }
+            if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) {
+                for (int i = 0; i < FAKE_FALLBACK_NETWORKS.length; i++) {
+                    int transportType = FAKE_FALLBACK_NETWORKS[i];
+                    if (networkCapabilities.hasTransport(transportType)) {
+                        prioritizedNetworks[i] = network;
+                        break;
+                    }
+                }
+            }
+        }
+        for (Network network : prioritizedNetworks) {
+            if (network != null) {
+                return network;
+            }
+        }
+        return connectivityManager.getActiveNetwork();
+    }
+
+    // If the given network is a real or fake Wifi connection, return a Wifi network.
+    // Otherwise fallback to default implementation.
+    public static NetworkInfo getNetworkInfo(ConnectivityManager connectivityManager, Network network) {
+        NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
+        if (networkCapabilities != null && hasTransport(networkCapabilities, NetworkCapabilities.TRANSPORT_WIFI)) {
+            for (NetworkInfo networkInfo : connectivityManager.getAllNetworkInfo()) {
+                if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
+                    return networkInfo;
+                }
+            }
+        }
+        return connectivityManager.getNetworkInfo(network);
+    }
+
+    // If we are checking if the NetworkCapabilities use Wifi, return yes if
+    //  - it is a real Wifi connection,
+    //  - or the NetworkCapabilities are from a network pretending being a Wifi network.
+    // Otherwise fallback to default implementation.
+    public static boolean hasTransport(NetworkCapabilities networkCapabilities, int transportType) {
+        if (transportType == NetworkCapabilities.TRANSPORT_WIFI) {
+            if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+                return true;
+            }
+            if (CONNECTIVITY_MANAGER != null) {
+                Network activeNetwork = getActiveNetwork(CONNECTIVITY_MANAGER);
+                NetworkCapabilities activeNetworkCapabilities = CONNECTIVITY_MANAGER.getNetworkCapabilities(activeNetwork);
+                if (activeNetworkCapabilities != null) {
+                    for (int fallbackTransportType : FAKE_FALLBACK_NETWORKS) {
+                        if (activeNetworkCapabilities.hasTransport(fallbackTransportType) && networkCapabilities.hasTransport(fallbackTransportType)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return networkCapabilities.hasTransport(transportType);
+    }
+
+    // If the given network is a real or fake Wifi connection, pretend it has a connection (and some other things).
+    public static boolean hasCapability(NetworkCapabilities networkCapabilities, int capability) {
+        if (hasTransport(networkCapabilities, NetworkCapabilities.TRANSPORT_WIFI) && (
+                capability == NetworkCapabilities.NET_CAPABILITY_INTERNET
+                        || capability == NetworkCapabilities.NET_CAPABILITY_FOREGROUND
+                        || capability == NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED
+                        || capability == NetworkCapabilities.NET_CAPABILITY_NOT_METERED
+                        || capability == NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED
+                        || capability == NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING
+                        || capability == NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED
+                        || capability == NetworkCapabilities.NET_CAPABILITY_NOT_VPN
+                        || capability == NetworkCapabilities.NET_CAPABILITY_TRUSTED
+                        || capability == NetworkCapabilities.NET_CAPABILITY_VALIDATED)) {
+            return true;
+        }
+        return networkCapabilities.hasCapability(capability);
+    }
+
+    // If it waits for Wifi connectivity, pretend it is fulfilled immediately if we have an active network.
+    @RequiresApi(api = Build.VERSION_CODES.S)
+    public static void registerBestMatchingNetworkCallback(ConnectivityManager connectivityManager, NetworkRequest request, ConnectivityManager.NetworkCallback networkCallback, Handler handler) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.of(request),
+                Utils.Option.of(networkCallback),
+                Utils.Option.empty(),
+                Utils.Option.of(handler),
+                () -> connectivityManager.registerBestMatchingNetworkCallback(request, networkCallback, handler)
+        );
+    }
+
+    // If it waits for Wifi connectivity, pretend it is fulfilled immediately if we have an active network.
+    @RequiresApi(api = Build.VERSION_CODES.N)
+    public static void registerDefaultNetworkCallback(ConnectivityManager connectivityManager, ConnectivityManager.NetworkCallback networkCallback) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.empty(),
+                Utils.Option.of(networkCallback),
+                Utils.Option.empty(),
+                Utils.Option.empty(),
+                () -> connectivityManager.registerDefaultNetworkCallback(networkCallback)
+        );
+    }
+
+    // If it waits for Wifi connectivity, pretend it is fulfilled immediately if we have an active network.
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static void registerDefaultNetworkCallback(ConnectivityManager connectivityManager, ConnectivityManager.NetworkCallback networkCallback, Handler handler) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.empty(),
+                Utils.Option.of(networkCallback),
+                Utils.Option.empty(),
+                Utils.Option.of(handler),
+                () -> connectivityManager.registerDefaultNetworkCallback(networkCallback, handler)
+        );
+    }
+
+    // If it waits for Wifi connectivity, pretend it is fulfilled immediately if we have an active network.
+    public static void registerNetworkCallback(ConnectivityManager connectivityManager, NetworkRequest request, ConnectivityManager.NetworkCallback networkCallback) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.of(request),
+                Utils.Option.of(networkCallback),
+                Utils.Option.empty(),
+                Utils.Option.empty(),
+                () -> connectivityManager.registerNetworkCallback(request, networkCallback)
+        );
+    }
+
+    // If it waits for Wifi connectivity, pretend it is fulfilled immediately.
+    public static void registerNetworkCallback(ConnectivityManager connectivityManager, NetworkRequest request, PendingIntent operation) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.of(request),
+                Utils.Option.empty(),
+                Utils.Option.of(operation),
+                Utils.Option.empty(),
+                () -> connectivityManager.registerNetworkCallback(request, operation)
+        );
+    }
+
+    // If it waits for Wifi connectivity, pretend it is fulfilled immediately if we have an active network.
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static void registerNetworkCallback(ConnectivityManager connectivityManager, NetworkRequest request, ConnectivityManager.NetworkCallback networkCallback, Handler handler) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.of(request),
+                Utils.Option.of(networkCallback),
+                Utils.Option.empty(),
+                Utils.Option.of(handler),
+                () -> connectivityManager.registerNetworkCallback(request, networkCallback, handler)
+        );
+    }
+
+    // If it requests Wifi connectivity, pretend it is fulfilled immediately if we have an active network.
+    public static void requestNetwork(ConnectivityManager connectivityManager, NetworkRequest request, ConnectivityManager.NetworkCallback networkCallback) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.of(request),
+                Utils.Option.of(networkCallback),
+                Utils.Option.empty(),
+                Utils.Option.empty(),
+                () -> connectivityManager.requestNetwork(request, networkCallback)
+        );
+    }
+
+    // If it requests Wifi connectivity, pretend it is fulfilled immediately if we have an active network.
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static void requestNetwork(ConnectivityManager connectivityManager, NetworkRequest request, ConnectivityManager.NetworkCallback networkCallback, int timeoutMs) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.of(request),
+                Utils.Option.of(networkCallback),
+                Utils.Option.empty(),
+                Utils.Option.empty(),
+                () -> connectivityManager.requestNetwork(request, networkCallback, timeoutMs)
+        );
+    }
+
+    // If it requests Wifi connectivity, pretend it is fulfilled immediately if we have an active network.
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static void requestNetwork(ConnectivityManager connectivityManager, NetworkRequest request, ConnectivityManager.NetworkCallback networkCallback, Handler handler) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.of(request),
+                Utils.Option.of(networkCallback),
+                Utils.Option.empty(),
+                Utils.Option.of(handler),
+                () -> connectivityManager.requestNetwork(request, networkCallback, handler)
+        );
+    }
+
+    // If it requests Wifi connectivity, pretend it is fulfilled immediately.
+    public static void requestNetwork(ConnectivityManager connectivityManager, NetworkRequest request, PendingIntent operation) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.of(request),
+                Utils.Option.empty(),
+                Utils.Option.of(operation),
+                Utils.Option.empty(),
+                () -> connectivityManager.requestNetwork(request, operation)
+        );
+    }
+
+    // If it requests Wifi connectivity, pretend it is fulfilled immediately if we have an active network.
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static void requestNetwork(ConnectivityManager connectivityManager, NetworkRequest request, ConnectivityManager.NetworkCallback networkCallback, Handler handler, int timeoutMs) {
+        Utils.networkCallback(
+                connectivityManager,
+                Utils.Option.of(request),
+                Utils.Option.of(networkCallback),
+                Utils.Option.empty(),
+                Utils.Option.of(handler),
+                () -> connectivityManager.requestNetwork(request, networkCallback, handler, timeoutMs)
+        );
+    }
+
+    public static void unregisterNetworkCallback(ConnectivityManager connectivityManager, ConnectivityManager.NetworkCallback networkCallback) {
+        try {
+            connectivityManager.unregisterNetworkCallback(networkCallback);
+        } catch (IllegalArgumentException ignore) {
+            // ignore: NetworkCallback was not registered
+        }
+    }
+
+    public static void unregisterNetworkCallback(ConnectivityManager connectivityManager, PendingIntent operation) {
+        try {
+            connectivityManager.unregisterNetworkCallback(operation);
+        } catch (IllegalArgumentException ignore) {
+            // ignore: PendingIntent was not registered
+        }
+    }
+
+    private static class Utils {
+        private static class Option<T> {
+            private final T value;
+            private final boolean isPresent;
+
+            private Option(T value, boolean isPresent) {
+                this.value = value;
+                this.isPresent = isPresent;
+            }
+
+            private static <T> Option<T> of(T value) {
+                return new Option<>(value, true);
+            }
+
+            private static <T> Option<T> empty() {
+                return new Option<>(null, false);
+            }
+        }
+
+        private static void networkCallback(
+                ConnectivityManager connectivityManager,
+                Option<NetworkRequest> request,
+                Option<ConnectivityManager.NetworkCallback> networkCallback,
+                Option<PendingIntent> operation,
+                Option<Handler> handler,
+                Runnable fallback
+        ) {
+            if(!request.isPresent || (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && request.value != null && requestsWifiNetwork(request.value))) {
+                Runnable runnable = null;
+                if (networkCallback.isPresent && networkCallback.value != null) {
+                    Network network = activeWifiNetwork(connectivityManager);
+                    if (network != null) {
+                        runnable = () -> networkCallback.value.onAvailable(network);
+                    }
+                } else if (operation.isPresent && operation.value != null) {
+                    runnable = () -> {
+                        try {
+                            operation.value.send();
+                        } catch (PendingIntent.CanceledException ignore) {}
+                    };
+                }
+                if (runnable != null) {
+                    if (handler.isPresent) {
+                        if (handler.value != null) {
+                            handler.value.post(runnable);
+                            return;
+                        }
+                    } else {
+                        runnable.run();
+                        return;
+                    }
+                }
+            }
+            fallback.run();
+        }
+
+        // Returns an active (maybe fake) Wifi network if there is one, otherwise null.
+        private static Network activeWifiNetwork(ConnectivityManager connectivityManager) {
+            Network network = getActiveNetwork(connectivityManager);
+            NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
+            if (networkCapabilities != null && hasTransport(networkCapabilities, NetworkCapabilities.TRANSPORT_WIFI)) {
+                return network;
+            }
+            return null;
+        }
+
+        // Whether a Wifi network with connection is requested.
+        @RequiresApi(api = Build.VERSION_CODES.P)
+        private static boolean requestsWifiNetwork(NetworkRequest request) {
+            return request.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
+                    && (request.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                        || request.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED));
+        }
+    }
+}

extensions/all/misc/directory/documentsprovider/export-internal-data-documents-provider/build.gradle.kts

@@ -0,0 +1,3 @@
+dependencies {
+    compileOnly(libs.annotation)
+}

extensions/all/misc/directory/documentsprovider/export-internal-data-documents-provider/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/all/misc/directory/documentsprovider/export-internal-data-documents-provider/src/main/java/app/revanced/extension/all/misc/directory/documentsprovider/InternalDataDocumentsProvider.java

@@ -0,0 +1,334 @@
+package app.revanced.extension.all.misc.directory.documentsprovider;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.ProviderInfo;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.os.CancellationSignal;
+import android.os.ParcelFileDescriptor;
+import android.provider.DocumentsContract;
+import android.provider.DocumentsProvider;
+import android.system.ErrnoException;
+import android.system.Os;
+import android.system.StructStat;
+import android.util.Log;
+import android.webkit.MimeTypeMap;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * A DocumentsProvider that allows access to the app's internal data directory.
+ */
+public class InternalDataDocumentsProvider extends DocumentsProvider {
+    private static final String[] rootColumns =
+            {"root_id", "mime_types", "flags", "icon", "title", "summary", "document_id"};
+    private static final String[] directoryColumns =
+            {"document_id", "mime_type", "_display_name", "last_modified", "flags",
+                    "_size", "full_path", "lstat_info"};
+    private static final int S_IFLNK = 0x8000;
+
+    private String packageName;
+    private File dataDirectory;
+
+    /**
+     * Recursively delete a file or directory and all its children.
+     *
+     * @param root The file or directory to delete.
+     * @return True if the file or directory and all its children were successfully deleted.
+     */
+    private static boolean deleteRecursively(File root) {
+        // If root is a directory, delete all children first
+        if (root.isDirectory()) {
+            try {
+                // Only delete recursively if the directory is not a symlink
+                if ((Os.lstat(root.getPath()).st_mode & S_IFLNK) != S_IFLNK) {
+                    File[] files = root.listFiles();
+                    if (files != null) {
+                        for (File file : files) {
+                            if (!deleteRecursively(file)) {
+                                return false;
+                            }
+                        }
+                    }
+                }
+            } catch (ErrnoException e) {
+                Log.e("InternalDocumentsProvider", "Failed to lstat " + root.getPath(), e);
+            }
+        }
+
+        // Delete file or empty directory
+        return root.delete();
+    }
+
+    /**
+     * Resolve the MIME type of a file based on its extension.
+     *
+     * @param file The file to resolve the MIME type for.
+     * @return The MIME type of the file.
+     */
+    private static String resolveMimeType(File file) {
+        if (file.isDirectory()) {
+            return DocumentsContract.Document.MIME_TYPE_DIR;
+        }
+
+        String name = file.getName();
+        int indexOfExtDot = name.lastIndexOf('.');
+        if (indexOfExtDot < 0) {
+            // No extension
+            return "application/octet-stream";
+        }
+
+        String extension = name.substring(indexOfExtDot + 1).toLowerCase();
+        String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
+        return mimeType != null ? mimeType : "application/octet-stream";
+    }
+
+    @Override
+    public final boolean onCreate() {
+        return true;
+    }
+
+    @Override
+    public final void attachInfo(Context context, ProviderInfo providerInfo) {
+        super.attachInfo(context, providerInfo);
+
+        this.packageName = context.getPackageName();
+        this.dataDirectory = context.getFilesDir().getParentFile();
+    }
+
+    @Override
+    public final String createDocument(String parentDocumentId, String mimeType, String displayName) throws FileNotFoundException {
+        File directory = resolveDocumentId(parentDocumentId);
+        File file = new File(directory, displayName);
+
+        // If file already exists, append a number to the name
+        int i = 2;
+        while (file.exists()) {
+            file = new File(directory, displayName + " (" + i + ")");
+            i++;
+        }
+
+        try {
+            // Create the file or directory
+            if (mimeType.equals(DocumentsContract.Document.MIME_TYPE_DIR) ? file.mkdir() : file.createNewFile()) {
+                // Return the document ID of the new entity
+                if (!parentDocumentId.endsWith("/")) {
+                    parentDocumentId = parentDocumentId + "/";
+                }
+                return parentDocumentId + file.getName();
+            }
+        } catch (IOException e) {
+            // Do nothing. We are throwing a FileNotFoundException later if the file could not be created.
+        }
+        throw new FileNotFoundException("Failed to create document in " + parentDocumentId + " with name " + displayName);
+    }
+
+    @Override
+    public final void deleteDocument(String documentId) throws FileNotFoundException {
+        File file = resolveDocumentId(documentId);
+        if (!deleteRecursively(file)) {
+            throw new FileNotFoundException("Failed to delete document " + documentId);
+        }
+    }
+
+    @Override
+    public final String getDocumentType(String documentId) throws FileNotFoundException {
+        return resolveMimeType(resolveDocumentId(documentId));
+    }
+
+    @Override
+    public final boolean isChildDocument(String parentDocumentId, String documentId) {
+        return documentId.startsWith(parentDocumentId);
+    }
+
+    @Override
+    public final String moveDocument(String sourceDocumentId, String sourceParentDocumentId, String targetParentDocumentId) throws FileNotFoundException {
+        File source = resolveDocumentId(sourceDocumentId);
+        File dest = resolveDocumentId(targetParentDocumentId);
+
+        File file = new File(dest, source.getName());
+        if (!file.exists() && source.renameTo(file)) {
+            // Return the new document ID
+            if (targetParentDocumentId.endsWith("/")) {
+                return targetParentDocumentId + file.getName();
+            }
+            return targetParentDocumentId + "/" + file.getName();
+        }
+
+        throw new FileNotFoundException("Failed to move document from " + sourceDocumentId + " to " + targetParentDocumentId);
+    }
+
+    @Override
+    public final ParcelFileDescriptor openDocument(String documentId, String mode, CancellationSignal signal) throws FileNotFoundException {
+        File file = resolveDocumentId(documentId);
+        return ParcelFileDescriptor.open(file, ParcelFileDescriptor.parseMode(mode));
+    }
+
+    @Override
+    public final Cursor queryChildDocuments(String parentDocumentId, String[] projection, String sortOrder) throws FileNotFoundException {
+        if (parentDocumentId.endsWith("/")) {
+            parentDocumentId = parentDocumentId.substring(0, parentDocumentId.length() - 1);
+        }
+
+        if (projection == null) {
+            projection = directoryColumns;
+        }
+
+        MatrixCursor cursor = new MatrixCursor(projection);
+        File children = resolveDocumentId(parentDocumentId);
+
+        // Collect all children
+        File[] files = children.listFiles();
+        if (files != null) {
+            for (File file : files) {
+                addRowForDocument(cursor, parentDocumentId + "/" + file.getName(), file);
+            }
+        }
+        return cursor;
+    }
+
+    @Override
+    public final Cursor queryDocument(String documentId, String[] projection) throws FileNotFoundException {
+        if (projection == null) {
+            projection = directoryColumns;
+        }
+
+        MatrixCursor cursor = new MatrixCursor(projection);
+        addRowForDocument(cursor, documentId, null);
+        return cursor;
+    }
+
+    @Override
+    public final Cursor queryRoots(String[] projection) {
+        ApplicationInfo info = Objects.requireNonNull(getContext()).getApplicationInfo();
+        String appName = info.loadLabel(getContext().getPackageManager()).toString();
+
+        if (projection == null) {
+            projection = rootColumns;
+        }
+
+        MatrixCursor cursor = new MatrixCursor(projection);
+        MatrixCursor.RowBuilder row = cursor.newRow();
+        row.add(DocumentsContract.Root.COLUMN_ROOT_ID, this.packageName);
+        row.add(DocumentsContract.Root.COLUMN_DOCUMENT_ID, this.packageName);
+        row.add(DocumentsContract.Root.COLUMN_SUMMARY, this.packageName);
+        row.add(DocumentsContract.Root.COLUMN_FLAGS,
+                DocumentsContract.Root.FLAG_LOCAL_ONLY |
+                        DocumentsContract.Root.FLAG_SUPPORTS_IS_CHILD);
+        row.add(DocumentsContract.Root.COLUMN_TITLE, appName);
+        row.add(DocumentsContract.Root.COLUMN_MIME_TYPES, "*/*");
+        row.add(DocumentsContract.Root.COLUMN_ICON, info.icon);
+        return cursor;
+    }
+
+    @Override
+    public final void removeDocument(String documentId, String parentDocumentId) throws FileNotFoundException {
+        deleteDocument(documentId);
+    }
+
+    @Override
+    public final String renameDocument(String documentId, String displayName) throws FileNotFoundException {
+        File file = resolveDocumentId(documentId);
+        if (!file.renameTo(new File(file.getParentFile(), displayName))) {
+            throw new FileNotFoundException("Failed to rename document from " + documentId + " to " + displayName);
+        }
+
+        // Return the new document ID
+        return documentId.substring(0, documentId.lastIndexOf('/', documentId.length() - 2)) + "/" + displayName;
+    }
+
+    /**
+     * Resolve a file instance for a given document ID.
+     *
+     * @param fullContentPath The document ID to resolve.
+     * @return File object for the given document ID.
+     * @throws FileNotFoundException If the document ID is invalid or the file does not exist.
+     */
+    private File resolveDocumentId(String fullContentPath) throws FileNotFoundException {
+        if (!fullContentPath.startsWith(this.packageName)) {
+            throw new FileNotFoundException(fullContentPath + " not found");
+        }
+        String path = fullContentPath.substring(this.packageName.length());
+
+        // Resolve the relative path within /data/data/{PKG}
+        File file;
+        if (path.equals("/") || path.isEmpty()) {
+            file = this.dataDirectory;
+        } else {
+            // Remove leading slash
+            String relativePath = path.substring(1);
+            file = new File(this.dataDirectory, relativePath);
+        }
+
+        if (!file.exists()) {
+            throw new FileNotFoundException(fullContentPath + " not found");
+        }
+        return file;
+    }
+
+    /**
+     * Add a row containing all file properties to a MatrixCursor for a given document ID.
+     *
+     * @param cursor     The cursor to add the row to.
+     * @param documentId The document ID to add the row for.
+     * @param file       The file to add the row for. If null, the file will be resolved from the document ID.
+     * @throws FileNotFoundException If the file does not exist.
+     */
+    private void addRowForDocument(MatrixCursor cursor, String documentId, File file) throws FileNotFoundException {
+        if (file == null) {
+            file = resolveDocumentId(documentId);
+        }
+
+        int flags = 0;
+        if (file.isDirectory()) {
+            // Prefer list view for directories
+            flags = flags | DocumentsContract.Document.FLAG_DIR_PREFERS_LAST_MODIFIED;
+        }
+
+        if (file.canWrite()) {
+            if (file.isDirectory()) {
+                flags = flags | DocumentsContract.Document.FLAG_DIR_SUPPORTS_CREATE;
+            }
+
+            flags = flags | DocumentsContract.Document.FLAG_SUPPORTS_WRITE |
+                    DocumentsContract.Document.FLAG_SUPPORTS_DELETE |
+                    DocumentsContract.Document.FLAG_SUPPORTS_RENAME |
+                    DocumentsContract.Document.FLAG_SUPPORTS_MOVE;
+        }
+
+        MatrixCursor.RowBuilder row = cursor.newRow();
+        row.add(DocumentsContract.Document.COLUMN_DOCUMENT_ID, documentId);
+        row.add(DocumentsContract.Document.COLUMN_DISPLAY_NAME, file.getName());
+        row.add(DocumentsContract.Document.COLUMN_SIZE, file.length());
+        row.add(DocumentsContract.Document.COLUMN_MIME_TYPE, resolveMimeType(file));
+        row.add(DocumentsContract.Document.COLUMN_LAST_MODIFIED, file.lastModified());
+        row.add(DocumentsContract.Document.COLUMN_FLAGS, flags);
+
+        // Custom columns
+        row.add("full_path", file.getAbsolutePath());
+
+        // Add lstat column
+        String path = file.getPath();
+        try {
+            StringBuilder sb = new StringBuilder();
+            StructStat lstat = Os.lstat(path);
+            sb.append(lstat.st_mode);
+            sb.append(";");
+            sb.append(lstat.st_uid);
+            sb.append(";");
+            sb.append(lstat.st_gid);
+            // Append symlink target if it is a symlink
+            if ((lstat.st_mode & S_IFLNK) == S_IFLNK) {
+                sb.append(";");
+                sb.append(Os.readlink(path));
+            }
+            row.add("lstat_info", sb.toString());
+        } catch (Exception ex) {
+            Log.e("InternalDocumentsProvider", "Failed to get lstat info for " + path, ex);
+        }
+    }
+}

extensions/all/misc/screencapture/remove-screen-capture-restriction/build.gradle.kts

@@ -0,0 +1,5 @@
+android.namespace = "app.revanced.extension"
+
+dependencies {
+    compileOnly(libs.annotation)
+}

extensions/all/misc/screencapture/remove-screen-capture-restriction/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/all/misc/screencapture/remove-screen-capture-restriction/src/main/java/app/revanced/extension/all/screencapture/removerestriction/RemoveScreencaptureRestrictionPatch.java

@@ -0,0 +1,21 @@
+package app.revanced.extension.all.screencapture.removerestriction;
+
+import android.media.AudioAttributes;
+import android.os.Build;
+
+import androidx.annotation.RequiresApi;
+
+public final class RemoveScreencaptureRestrictionPatch {
+    // Member of AudioAttributes.Builder
+    @RequiresApi(api = Build.VERSION_CODES.Q)
+    public static AudioAttributes.Builder setAllowedCapturePolicy(final AudioAttributes.Builder builder, final int capturePolicy) {
+        builder.setAllowedCapturePolicy(AudioAttributes.ALLOW_CAPTURE_BY_ALL);
+
+        return builder;
+    }
+
+    // Member of AudioManager static class
+    public static void setAllowedCapturePolicy(final int capturePolicy) {
+        // Ignore request
+    }
+}

extensions/all/misc/screenshot/remove-screenshot-restriction/build.gradle.kts

@@ -0,0 +1 @@
+android.namespace = "app.revanced.extension"

extensions/all/misc/screenshot/remove-screenshot-restriction/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/all/misc/screenshot/remove-screenshot-restriction/src/main/java/app/revanced/extension/all/screenshot/removerestriction/RemoveScreenshotRestrictionPatch.java

@@ -0,0 +1,15 @@
+package app.revanced.extension.all.screenshot.removerestriction;
+
+import android.view.Window;
+import android.view.WindowManager;
+
+public class RemoveScreenshotRestrictionPatch {
+
+    public static void addFlags(Window window, int flags) {
+        window.addFlags(flags & ~WindowManager.LayoutParams.FLAG_SECURE);
+    }
+
+    public static void setFlags(Window window, int flags, int mask) {
+        window.setFlags(flags & ~WindowManager.LayoutParams.FLAG_SECURE, mask & ~WindowManager.LayoutParams.FLAG_SECURE);
+    }
+}

extensions/boostforreddit/build.gradle.kts

@@ -0,0 +1,4 @@
+dependencies {
+    compileOnly(project(":extensions:shared:library"))
+    compileOnly(project(":extensions:boostforreddit:stub"))
+}

extensions/boostforreddit/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/boostforreddit/src/main/java/app/revanced/extension/boostforreddit/FixSLinksPatch.java

@@ -0,0 +1,26 @@
+package app.revanced.extension.boostforreddit;
+
+import com.rubenmayayo.reddit.ui.activities.WebViewActivity;
+
+import app.revanced.extension.shared.fixes.slink.BaseFixSLinksPatch;
+
+/**
+ * @noinspection unused
+ */
+public class FixSLinksPatch extends BaseFixSLinksPatch {
+    static {
+        INSTANCE = new FixSLinksPatch();
+    }
+
+    private FixSLinksPatch() {
+        webViewActivityClass = WebViewActivity.class;
+    }
+
+    public static boolean patchResolveSLink(String link) {
+        return INSTANCE.resolveSLink(link);
+    }
+
+    public static void patchSetAccessToken(String accessToken) {
+        INSTANCE.setAccessToken(accessToken);
+    }
+}

extensions/boostforreddit/stub/build.gradle.kts

@@ -0,0 +1,17 @@
+plugins {
+    id(libs.plugins.android.library.get().pluginId)
+}
+
+android {
+    namespace = "app.revanced.extension"
+    compileSdk = 33
+
+    defaultConfig {
+        minSdk = 24
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+}

extensions/boostforreddit/stub/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/boostforreddit/stub/src/main/java/com/rubenmayayo/reddit/ui/activities/WebViewActivity.java

@@ -0,0 +1,6 @@
+package com.rubenmayayo.reddit.ui.activities;
+
+import android.app.Activity;
+
+public class WebViewActivity extends Activity {
+}

extensions/music/build.gradle.kts

@@ -0,0 +1 @@
+// Do not remove. Necessary for the extension plugin to be applied to the project.

extensions/music/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/music/src/main/java/app/revanced/extension/music/spoof/SpoofClientPatch.java

@@ -0,0 +1,27 @@
+package app.revanced.extension.music.spoof;
+
+/**
+ * @noinspection unused
+ */
+public class SpoofClientPatch {
+    private static final int CLIENT_TYPE_ID = 26;
+    private static final String CLIENT_VERSION = "6.21";
+    private static final String DEVICE_MODEL = "iPhone16,2";
+    private static final String OS_VERSION = "17.7.2.21H221";
+
+    public static int getClientId() {
+        return CLIENT_TYPE_ID;
+    }
+
+    public static String getClientVersion() {
+        return CLIENT_VERSION;
+    }
+
+    public static String getClientModel() {
+        return DEVICE_MODEL;
+    }
+
+    public static String getOsVersion() {
+        return OS_VERSION;
+    }
+}

extensions/proguard-rules.pro

@@ -0,0 +1,9 @@
+-dontobfuscate
+-dontoptimize
+-keepattributes *
+-keep class app.revanced.** {
+  *;
+}
+-keep class com.google.** {
+  *;
+}

extensions/reddit/build.gradle.kts

@@ -0,0 +1,3 @@
+dependencies {
+    compileOnly(project(":extensions:reddit:stub"))
+}

extensions/reddit/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/reddit/src/main/java/app/revanced/extension/reddit/patches/FilterPromotedLinksPatch.java

@@ -0,0 +1,27 @@
+package app.revanced.extension.reddit.patches;
+
+import com.reddit.domain.model.ILink;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@SuppressWarnings("unused")
+public final class FilterPromotedLinksPatch {
+
+    /**
+     * Injection point.
+     *
+     * Filters list from promoted links.
+     **/
+    public static List<?> filterChildren(final Iterable<?> links) {
+        final List<Object> filteredList = new ArrayList<>();
+
+        for (Object item : links) {
+            if (item instanceof ILink && ((ILink) item).getPromoted()) continue;
+
+            filteredList.add(item);
+        }
+
+        return filteredList;
+    }
+}

extensions/reddit/stub/build.gradle.kts

@@ -0,0 +1,17 @@
+plugins {
+    id(libs.plugins.android.library.get().pluginId)
+}
+
+android {
+    namespace = "app.revanced.extension"
+    compileSdk = 33
+
+    defaultConfig {
+        minSdk = 24
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+}

extensions/reddit/stub/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/reddit/stub/src/main/java/com/reddit/domain/model/ILink.java

@@ -0,0 +1,7 @@
+package com.reddit.domain.model;
+
+public class ILink {
+    public boolean getPromoted() {
+        throw new UnsupportedOperationException("Stub");
+    }
+}

extensions/shared/build.gradle.kts

@@ -0,0 +1,3 @@
+dependencies {
+    implementation(project(":extensions:shared:library"))
+}

extensions/shared/library/build.gradle.kts

@@ -0,0 +1,21 @@
+plugins {
+    id("com.android.library")
+}
+
+android {
+    namespace = "app.revanced.extension"
+    compileSdk = 34
+
+    defaultConfig {
+        minSdk = 23
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+}
+
+dependencies {
+    compileOnly(libs.annotation)
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/GmsCoreSupport.java

@@ -0,0 +1,163 @@
+package app.revanced.extension.shared;
+
+import static app.revanced.extension.shared.StringRef.str;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.SearchManager;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.PowerManager;
+import android.provider.Settings;
+
+import androidx.annotation.RequiresApi;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/**
+ * @noinspection unused
+ */
+public class GmsCoreSupport {
+    private static final String PACKAGE_NAME_YOUTUBE = "com.google.android.youtube";
+    private static final String PACKAGE_NAME_YOUTUBE_MUSIC = "com.google.android.apps.youtube.music";
+
+    private static final String GMS_CORE_PACKAGE_NAME
+            = getGmsCoreVendorGroupId() + ".android.gms";
+    private static final Uri GMS_CORE_PROVIDER
+            = Uri.parse("content://" + getGmsCoreVendorGroupId() + ".android.gsf.gservices/prefix");
+    private static final String DONT_KILL_MY_APP_LINK
+            = "https://dontkillmyapp.com";
+
+    private static void open(String queryOrLink) {
+        Intent intent;
+        try {
+            // Check if queryOrLink is a valid URL.
+            new URL(queryOrLink);
+
+            intent = new Intent(Intent.ACTION_VIEW, Uri.parse(queryOrLink));
+        } catch (MalformedURLException e) {
+            intent = new Intent(Intent.ACTION_WEB_SEARCH);
+            intent.putExtra(SearchManager.QUERY, queryOrLink);
+        }
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        Utils.getContext().startActivity(intent);
+
+        // Gracefully exit, otherwise the broken app will continue to run.
+        System.exit(0);
+    }
+
+    private static void showBatteryOptimizationDialog(Activity context,
+                                                      String dialogMessageRef,
+                                                      String positiveButtonTextRef,
+                                                      DialogInterface.OnClickListener onPositiveClickListener) {
+        // Use a delay to allow the activity to finish initializing.
+        // Otherwise, if device is in dark mode the dialog is shown with wrong color scheme.
+        Utils.runOnMainThreadDelayed(() -> {
+            // Do not set cancelable to false, to allow using back button to skip the action,
+            // just in case the battery change can never be satisfied.
+            var dialog = new AlertDialog.Builder(context)
+                    .setTitle(str("gms_core_dialog_title"))
+                    .setMessage(str(dialogMessageRef))
+                    .setPositiveButton(str(positiveButtonTextRef), onPositiveClickListener)
+                    .create();
+            Utils.showDialog(context, dialog);
+        }, 100);
+    }
+
+    /**
+     * Injection point.
+     */
+    @RequiresApi(api = Build.VERSION_CODES.N)
+    public static void checkGmsCore(Activity context) {
+        try {
+            // Verify the user has not included GmsCore for a root installation.
+            // GmsCore Support changes the package name, but with a mounted installation
+            // all manifest changes are ignored and the original package name is used.
+            String packageName = context.getPackageName();
+            if (packageName.equals(PACKAGE_NAME_YOUTUBE) || packageName.equals(PACKAGE_NAME_YOUTUBE_MUSIC)) {
+                Logger.printInfo(() -> "App is mounted with root, but GmsCore patch was included");
+                // Cannot use localize text here, since the app will load
+                // resources from the unpatched app and all patch strings are missing.
+                Utils.showToastLong("The 'GmsCore support' patch breaks mount installations");
+
+                // Do not exit. If the app exits before launch completes (and without
+                // opening another activity), then on some devices such as Pixel phone Android 10
+                // no toast will be shown and the app will continually be relaunched
+                // with the appearance of a hung app.
+            }
+
+            // Verify GmsCore is installed.
+            try {
+                PackageManager manager = context.getPackageManager();
+                manager.getPackageInfo(GMS_CORE_PACKAGE_NAME, PackageManager.GET_ACTIVITIES);
+            } catch (PackageManager.NameNotFoundException exception) {
+                Logger.printInfo(() -> "GmsCore was not found");
+                // Cannot show a dialog and must show a toast,
+                // because on some installations the app crashes before a dialog can be displayed.
+                Utils.showToastLong(str("gms_core_toast_not_installed_message"));
+                open(getGmsCoreDownload());
+                return;
+            }
+
+            // Check if GmsCore is whitelisted from battery optimizations.
+            if (batteryOptimizationsEnabled(context)) {
+                Logger.printInfo(() -> "GmsCore is not whitelisted from battery optimizations");
+
+                showBatteryOptimizationDialog(context,
+                        "gms_core_dialog_not_whitelisted_using_battery_optimizations_message",
+                        "gms_core_dialog_continue_text",
+                        (dialog, id) -> openGmsCoreDisableBatteryOptimizationsIntent(context));
+                return;
+            }
+
+            // Check if GmsCore is currently running in the background.
+            try (var client = context.getContentResolver().acquireContentProviderClient(GMS_CORE_PROVIDER)) {
+                if (client == null) {
+                    Logger.printInfo(() -> "GmsCore is not running in the background");
+
+                    showBatteryOptimizationDialog(context,
+                            "gms_core_dialog_not_whitelisted_not_allowed_in_background_message",
+                            "gms_core_dialog_open_website_text",
+                            (dialog, id) -> open(DONT_KILL_MY_APP_LINK));
+                }
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "checkGmsCore failure", ex);
+        }
+    }
+
+    @SuppressLint("BatteryLife") // Permission is part of GmsCore
+    private static void openGmsCoreDisableBatteryOptimizationsIntent(Activity activity) {
+        Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
+        intent.setData(Uri.fromParts("package", GMS_CORE_PACKAGE_NAME, null));
+        activity.startActivityForResult(intent, 0);
+    }
+
+    /**
+     * @return If GmsCore is not whitelisted from battery optimizations.
+     */
+    private static boolean batteryOptimizationsEnabled(Context context) {
+        var powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+        return !powerManager.isIgnoringBatteryOptimizations(GMS_CORE_PACKAGE_NAME);
+    }
+
+    private static String getGmsCoreDownload() {
+        final var vendorGroupId = getGmsCoreVendorGroupId();
+        //noinspection SwitchStatementWithTooFewBranches
+        return switch (vendorGroupId) {
+            case "app.revanced" -> "https://github.com/revanced/gmscore/releases/latest";
+            default -> vendorGroupId + ".android.gms";
+        };
+    }
+
+    // Modified by a patch. Do not touch.
+    private static String getGmsCoreVendorGroupId() {
+        return "app.revanced";
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/Logger.java

@@ -0,0 +1,156 @@
+package app.revanced.extension.shared;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import app.revanced.extension.shared.settings.BaseSettings;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import static app.revanced.extension.shared.settings.BaseSettings.*;
+
+public class Logger {
+
+    /**
+     * Log messages using lambdas.
+     */
+    @FunctionalInterface
+    public interface LogMessage {
+        @NonNull
+        String buildMessageString();
+
+        /**
+         * @return For outer classes, this returns {@link Class#getSimpleName()}.
+         * For static, inner, or anonymous classes, this returns the simple name of the enclosing class.
+         * <br>
+         * For example, each of these classes return 'SomethingView':
+         * <code>
+         * com.company.SomethingView
+         * com.company.SomethingView$StaticClass
+         * com.company.SomethingView$1
+         * </code>
+         */
+        private String findOuterClassSimpleName() {
+            var selfClass = this.getClass();
+
+            String fullClassName = selfClass.getName();
+            final int dollarSignIndex = fullClassName.indexOf('$');
+            if (dollarSignIndex < 0) {
+                return selfClass.getSimpleName(); // Already an outer class.
+            }
+
+            // Class is inner, static, or anonymous.
+            // Parse the simple name full name.
+            // A class with no package returns index of -1, but incrementing gives index zero which is correct.
+            final int simpleClassNameStartIndex = fullClassName.lastIndexOf('.') + 1;
+            return fullClassName.substring(simpleClassNameStartIndex, dollarSignIndex);
+        }
+    }
+
+    private static final String REVANCED_LOG_PREFIX = "revanced: ";
+
+    /**
+     * Logs debug messages under the outer class name of the code calling this method.
+     * Whenever possible, the log string should be constructed entirely inside {@link LogMessage#buildMessageString()}
+     * so the performance cost of building strings is paid only if {@link BaseSettings#DEBUG} is enabled.
+     */
+    public static void printDebug(@NonNull LogMessage message) {
+        printDebug(message, null);
+    }
+
+    /**
+     * Logs debug messages under the outer class name of the code calling this method.
+     * Whenever possible, the log string should be constructed entirely inside {@link LogMessage#buildMessageString()}
+     * so the performance cost of building strings is paid only if {@link BaseSettings#DEBUG} is enabled.
+     */
+    public static void printDebug(@NonNull LogMessage message, @Nullable Exception ex) {
+        if (DEBUG.get()) {
+            String logMessage = message.buildMessageString();
+            String logTag = REVANCED_LOG_PREFIX + message.findOuterClassSimpleName();
+
+            if (DEBUG_STACKTRACE.get()) {
+                var builder = new StringBuilder(logMessage);
+                var sw = new StringWriter();
+                new Throwable().printStackTrace(new PrintWriter(sw));
+
+                builder.append('\n').append(sw);
+                logMessage = builder.toString();
+            }
+
+            if (ex == null) {
+                Log.d(logTag, logMessage);
+            } else {
+                Log.d(logTag, logMessage, ex);
+            }
+        }
+    }
+
+    /**
+     * Logs information messages using the outer class name of the code calling this method.
+     */
+    public static void printInfo(@NonNull LogMessage message) {
+        printInfo(message, null);
+    }
+
+    /**
+     * Logs information messages using the outer class name of the code calling this method.
+     */
+    public static void printInfo(@NonNull LogMessage message, @Nullable Exception ex) {
+        String logTag = REVANCED_LOG_PREFIX + message.findOuterClassSimpleName();
+        String logMessage = message.buildMessageString();
+        if (ex == null) {
+            Log.i(logTag, logMessage);
+        } else {
+            Log.i(logTag, logMessage, ex);
+        }
+    }
+
+    /**
+     * Logs exceptions under the outer class name of the code calling this method.
+     */
+    public static void printException(@NonNull LogMessage message) {
+        printException(message, null);
+    }
+
+    /**
+     * Logs exceptions under the outer class name of the code calling this method.
+     * <p>
+     * If the calling code is showing it's own error toast,
+     * instead use {@link #printInfo(LogMessage, Exception)}
+     *
+     * @param message          log message
+     * @param ex               exception (optional)
+     */
+    public static void printException(@NonNull LogMessage message, @Nullable Throwable ex) {
+        String messageString = message.buildMessageString();
+        String outerClassSimpleName = message.findOuterClassSimpleName();
+        String logMessage = REVANCED_LOG_PREFIX + outerClassSimpleName;
+        if (ex == null) {
+            Log.e(logMessage, messageString);
+        } else {
+            Log.e(logMessage, messageString, ex);
+        }
+        if (DEBUG_TOAST_ON_ERROR.get()) {
+            Utils.showToastLong(outerClassSimpleName + ": " + messageString);
+        }
+    }
+
+    /**
+     * Logging to use if {@link BaseSettings#DEBUG} or {@link Utils#getContext()} may not be initialized.
+     * Normally this method should not be used.
+     */
+    public static void initializationInfo(@NonNull Class<?> callingClass, @NonNull String message) {
+        Log.i(REVANCED_LOG_PREFIX + callingClass.getSimpleName(), message);
+    }
+
+    /**
+     * Logging to use if {@link BaseSettings#DEBUG} or {@link Utils#getContext()} may not be initialized.
+     * Normally this method should not be used.
+     */
+    public static void initializationException(@NonNull Class<?> callingClass, @NonNull String message,
+                                               @Nullable Exception ex) {
+        Log.e(REVANCED_LOG_PREFIX + callingClass.getSimpleName(), message, ex);
+    }
+
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/StringRef.java

@@ -0,0 +1,122 @@
+package app.revanced.extension.shared;
+
+import android.content.Context;
+import android.content.res.Resources;
+
+import androidx.annotation.NonNull;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class StringRef {
+    private static Resources resources;
+    private static String packageName;
+
+    // must use a thread safe map, as this class is used both on and off the main thread
+    private static final Map<String, StringRef> strings = Collections.synchronizedMap(new HashMap<>());
+
+    /**
+     * Returns a cached instance.
+     * Should be used if the same String could be loaded more than once.
+     *
+     * @param id string resource name/id
+     * @see #sf(String)
+     */
+    @NonNull
+    public static StringRef sfc(@NonNull String id) {
+        StringRef ref = strings.get(id);
+        if (ref == null) {
+            ref = new StringRef(id);
+            strings.put(id, ref);
+        }
+        return ref;
+    }
+
+    /**
+     * Creates a new instance, but does not cache the value.
+     * Should be used for Strings that are loaded exactly once.
+     *
+     * @param id string resource name/id
+     * @see #sfc(String)
+     */
+    @NonNull
+    public static StringRef sf(@NonNull String id) {
+        return new StringRef(id);
+    }
+
+    /**
+     * Gets string value by string id, shorthand for <code>sfc(id).toString()</code>
+     *
+     * @param id string resource name/id
+     * @return String value from string.xml
+     */
+    @NonNull
+    public static String str(@NonNull String id) {
+        return sfc(id).toString();
+    }
+
+    /**
+     * Gets string value by string id, shorthand for <code>sfc(id).toString()</code> and formats the string
+     * with given args.
+     *
+     * @param id   string resource name/id
+     * @param args the args to format the string with
+     * @return String value from string.xml formatted with given args
+     */
+    @NonNull
+    public static String str(@NonNull String id, Object... args) {
+        return String.format(str(id), args);
+    }
+
+    /**
+     * Creates a StringRef object that'll not change it's value
+     *
+     * @param value value which toString() method returns when invoked on returned object
+     * @return Unique StringRef instance, its value will never change
+     */
+    @NonNull
+    public static StringRef constant(@NonNull String value) {
+        final StringRef ref = new StringRef(value);
+        ref.resolved = true;
+        return ref;
+    }
+
+    /**
+     * Shorthand for <code>constant("")</code>
+     * Its value always resolves to empty string
+     */
+    @NonNull
+    public static final StringRef empty = constant("");
+
+    @NonNull
+    private String value;
+    private boolean resolved;
+
+    public StringRef(@NonNull String resName) {
+        this.value = resName;
+    }
+
+    @Override
+    @NonNull
+    public String toString() {
+        if (!resolved) {
+            if (resources == null || packageName == null) {
+                Context context = Utils.getContext();
+                resources = context.getResources();
+                packageName = context.getPackageName();
+            }
+            resolved = true;
+            if (resources != null) {
+                final int identifier = resources.getIdentifier(value, "string", packageName);
+                if (identifier == 0)
+                    Logger.printException(() -> "Resource not found: " + value);
+                else
+                    value = resources.getString(identifier);
+            } else {
+                Logger.printException(() -> "Could not resolve resources!");
+            }
+        }
+        return value;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/Utils.java

@@ -0,0 +1,794 @@
+package app.revanced.extension.shared;
+
+import android.annotation.SuppressLint;
+import android.app.*;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.net.ConnectivityManager;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.preference.Preference;
+import android.preference.PreferenceGroup;
+import android.preference.PreferenceScreen;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import android.widget.Toast;
+import android.widget.Toolbar;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.text.Bidi;
+import java.util.*;
+import java.util.regex.Pattern;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+import app.revanced.extension.shared.settings.BooleanSetting;
+import app.revanced.extension.shared.settings.preference.ReVancedAboutPreference;
+
+public class Utils {
+
+    @SuppressLint("StaticFieldLeak")
+    private static Context context;
+
+    private static String versionName;
+    private static String applicationLabel;
+
+    private Utils() {
+    } // utility class
+
+    /**
+     * Injection point.
+     *
+     * @return The manifest 'Version' entry of the patches.jar used during patching.
+     */
+    @SuppressWarnings("SameReturnValue")
+    public static String getPatchesReleaseVersion() {
+        return ""; // Value is replaced during patching.
+    }
+
+    private static PackageInfo getPackageInfo() throws PackageManager.NameNotFoundException {
+        final var packageName = Objects.requireNonNull(getContext()).getPackageName();
+
+        PackageManager packageManager = context.getPackageManager();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            return packageManager.getPackageInfo(
+                    packageName,
+                    PackageManager.PackageInfoFlags.of(0)
+            );
+        }
+
+        return packageManager.getPackageInfo(
+                packageName,
+                0
+        );
+    }
+
+    /**
+     * @return The version name of the app, such as 19.11.43
+     */
+    public static String getAppVersionName() {
+        if (versionName == null) {
+            try {
+                versionName = getPackageInfo().versionName;
+            } catch (Exception ex) {
+                Logger.printException(() -> "Failed to get package info", ex);
+                versionName = "Unknown";
+            }
+        }
+
+        return versionName;
+    }
+
+    public static String getApplicationName() {
+        if (applicationLabel == null) {
+            try {
+                ApplicationInfo applicationInfo = getPackageInfo().applicationInfo;
+                applicationLabel = (String) applicationInfo.loadLabel(context.getPackageManager());
+            } catch (Exception ex) {
+                Logger.printException(() -> "Failed to get application name", ex);
+                applicationLabel = "Unknown";
+            }
+        }
+
+        return applicationLabel;
+    }
+
+    /**
+     * Hide a view by setting its layout height and width to 1dp.
+     *
+     * @param condition The setting to check for hiding the view.
+     * @param view      The view to hide.
+     */
+    public static void hideViewBy0dpUnderCondition(BooleanSetting condition, View view) {
+        if (hideViewBy0dpUnderCondition(condition.get(), view)) {
+            Logger.printDebug(() -> "View hidden by setting: " + condition);
+        }
+    }
+
+    /**
+     * Hide a view by setting its layout height and width to 0dp.
+     *
+     * @param condition The setting to check for hiding the view.
+     * @param view      The view to hide.
+     */
+    public static boolean hideViewBy0dpUnderCondition(boolean condition, View view) {
+        if (condition) {
+            hideViewByLayoutParams(view);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Hide a view by setting its visibility to GONE.
+     *
+     * @param condition The setting to check for hiding the view.
+     * @param view      The view to hide.
+     */
+    public static void hideViewUnderCondition(BooleanSetting condition, View view) {
+        if (hideViewUnderCondition(condition.get(), view)) {
+            Logger.printDebug(() -> "View hidden by setting: " + condition);
+        }
+    }
+
+    /**
+     * Hide a view by setting its visibility to GONE.
+     *
+     * @param condition The setting to check for hiding the view.
+     * @param view      The view to hide.
+     */
+    public static boolean hideViewUnderCondition(boolean condition, View view) {
+        if (condition) {
+            view.setVisibility(View.GONE);
+            return true;
+        }
+
+        return false;
+    }
+
+    public static void hideViewByRemovingFromParentUnderCondition(BooleanSetting condition, View view) {
+        if (hideViewByRemovingFromParentUnderCondition(condition.get(), view)) {
+            Logger.printDebug(() -> "View hidden by setting: " + condition);
+        }
+    }
+
+    public static boolean hideViewByRemovingFromParentUnderCondition(boolean setting, View view) {
+        if (setting) {
+            ViewParent parent = view.getParent();
+            if (parent instanceof ViewGroup) {
+                ((ViewGroup) parent).removeView(view);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * General purpose pool for network calls and other background tasks.
+     * All tasks run at max thread priority.
+     */
+    private static final ThreadPoolExecutor backgroundThreadPool = new ThreadPoolExecutor(
+            3, // 3 threads always ready to go
+            Integer.MAX_VALUE,
+            10, // For any threads over the minimum, keep them alive 10 seconds after they go idle
+            TimeUnit.SECONDS,
+            new SynchronousQueue<>(),
+            r -> { // ThreadFactory
+                Thread t = new Thread(r);
+                t.setPriority(Thread.MAX_PRIORITY); // run at max priority
+                return t;
+            });
+
+    public static void runOnBackgroundThread(@NonNull Runnable task) {
+        backgroundThreadPool.execute(task);
+    }
+
+    @NonNull
+    public static <T> Future<T> submitOnBackgroundThread(@NonNull Callable<T> call) {
+        return backgroundThreadPool.submit(call);
+    }
+
+    /**
+     * Simulates a delay by doing meaningless calculations.
+     * Used for debugging to verify UI timeout logic.
+     */
+    @SuppressWarnings("UnusedReturnValue")
+    public static long doNothingForDuration(long amountOfTimeToWaste) {
+        final long timeCalculationStarted = System.currentTimeMillis();
+        Logger.printDebug(() -> "Artificially creating delay of: " + amountOfTimeToWaste + "ms");
+
+        long meaninglessValue = 0;
+        while (System.currentTimeMillis() - timeCalculationStarted < amountOfTimeToWaste) {
+            // could do a thread sleep, but that will trigger an exception if the thread is interrupted
+            meaninglessValue += Long.numberOfLeadingZeros((long) Math.exp(Math.random()));
+        }
+        // return the value, otherwise the compiler or VM might optimize and remove the meaningless time wasting work,
+        // leaving an empty loop that hammers on the System.currentTimeMillis native call
+        return meaninglessValue;
+    }
+
+
+    public static boolean containsAny(@NonNull String value, @NonNull String... targets) {
+        return indexOfFirstFound(value, targets) >= 0;
+    }
+
+    public static int indexOfFirstFound(@NonNull String value, @NonNull String... targets) {
+        for (String string : targets) {
+            if (!string.isEmpty()) {
+                final int indexOf = value.indexOf(string);
+                if (indexOf >= 0) return indexOf;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * @return zero, if the resource is not found
+     */
+    @SuppressLint("DiscouragedApi")
+    public static int getResourceIdentifier(@NonNull Context context, @NonNull String resourceIdentifierName, @NonNull String type) {
+        return context.getResources().getIdentifier(resourceIdentifierName, type, context.getPackageName());
+    }
+
+    /**
+     * @return zero, if the resource is not found
+     */
+    public static int getResourceIdentifier(@NonNull String resourceIdentifierName, @NonNull String type) {
+        return getResourceIdentifier(getContext(), resourceIdentifierName, type);
+    }
+
+    public static int getResourceInteger(@NonNull String resourceIdentifierName) throws Resources.NotFoundException {
+        return getContext().getResources().getInteger(getResourceIdentifier(resourceIdentifierName, "integer"));
+    }
+
+    @NonNull
+    public static Animation getResourceAnimation(@NonNull String resourceIdentifierName) throws Resources.NotFoundException {
+        return AnimationUtils.loadAnimation(getContext(), getResourceIdentifier(resourceIdentifierName, "anim"));
+    }
+
+    public static int getResourceColor(@NonNull String resourceIdentifierName) throws Resources.NotFoundException {
+        //noinspection deprecation
+        return getContext().getResources().getColor(getResourceIdentifier(resourceIdentifierName, "color"));
+    }
+
+    public static int getResourceDimensionPixelSize(@NonNull String resourceIdentifierName) throws Resources.NotFoundException {
+        return getContext().getResources().getDimensionPixelSize(getResourceIdentifier(resourceIdentifierName, "dimen"));
+    }
+
+    public static float getResourceDimension(@NonNull String resourceIdentifierName) throws Resources.NotFoundException {
+        return getContext().getResources().getDimension(getResourceIdentifier(resourceIdentifierName, "dimen"));
+    }
+
+    public interface MatchFilter<T> {
+        boolean matches(T object);
+    }
+
+    /**
+     * Includes sub children.
+     *
+     * @noinspection unchecked
+     */
+    public static <R extends View> R getChildViewByResourceName(@NonNull View view, @NonNull String str) {
+        var child = view.findViewById(Utils.getResourceIdentifier(str, "id"));
+        if (child != null) {
+            return (R) child;
+        }
+
+        throw new IllegalArgumentException("View with resource name '" + str + "' not found");
+    }
+
+    /**
+     * @param searchRecursively If children ViewGroups should also be
+     *                          recursively searched using depth first search.
+     * @return The first child view that matches the filter.
+     */
+    @Nullable
+    public static <T extends View> T getChildView(@NonNull ViewGroup viewGroup, boolean searchRecursively,
+                                                  @NonNull MatchFilter<View> filter) {
+        for (int i = 0, childCount = viewGroup.getChildCount(); i < childCount; i++) {
+            View childAt = viewGroup.getChildAt(i);
+
+            if (filter.matches(childAt)) {
+                //noinspection unchecked
+                return (T) childAt;
+            }
+            // Must do recursive after filter check, in case the filter is looking for a ViewGroup.
+            if (searchRecursively && childAt instanceof ViewGroup) {
+                T match = getChildView((ViewGroup) childAt, true, filter);
+                if (match != null) return match;
+            }
+        }
+
+        return null;
+    }
+
+    @Nullable
+    public static ViewParent getParentView(@NonNull View view, int nthParent) {
+        ViewParent parent = view.getParent();
+
+        int currentDepth = 0;
+        while (++currentDepth < nthParent && parent != null) {
+            parent = parent.getParent();
+        }
+
+        if (currentDepth == nthParent) {
+            return parent;
+        }
+
+        final int currentDepthLog = currentDepth;
+        Logger.printDebug(() -> "Could not find parent view of depth: " + nthParent
+                + " and instead found at: " + currentDepthLog + " view: " + view);
+        return null;
+    }
+
+    public static void restartApp(@NonNull Context context) {
+        String packageName = context.getPackageName();
+        Intent intent = Objects.requireNonNull(context.getPackageManager().getLaunchIntentForPackage(packageName));
+        Intent mainIntent = Intent.makeRestartActivityTask(intent.getComponent());
+        // Required for API 34 and later
+        // Ref: https://developer.android.com/about/versions/14/behavior-changes-14#safer-intents
+        mainIntent.setPackage(packageName);
+        context.startActivity(mainIntent);
+        System.exit(0);
+    }
+
+    public static Context getContext() {
+        if (context == null) {
+            Logger.initializationException(Utils.class, "Context is null, returning null!",  null);
+        }
+        return context;
+    }
+
+    public static void setContext(Context appContext) {
+        context = appContext;
+        // In some apps like TikTok, the Setting classes can load in weird orders due to cyclic class dependencies.
+        // Calling the regular printDebug method here can cause a Settings context null pointer exception,
+        // even though the context is already set before the call.
+        //
+        // The initialization logger methods do not directly or indirectly
+        // reference the Context or any Settings and are unaffected by this problem.
+        //
+        // Info level also helps debug if a patch hook is called before
+        // the context is set since debug logging is off by default.
+        Logger.initializationInfo(Utils.class, "Set context: " + appContext);
+    }
+
+    public static void setClipboard(@NonNull String text) {
+        android.content.ClipboardManager clipboard = (android.content.ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
+        android.content.ClipData clip = android.content.ClipData.newPlainText("ReVanced", text);
+        clipboard.setPrimaryClip(clip);
+    }
+
+    public static boolean isTablet() {
+        return context.getResources().getConfiguration().smallestScreenWidthDp >= 600;
+    }
+
+    @Nullable
+    private static Boolean isRightToLeftTextLayout;
+
+    /**
+     * If the device language uses right to left text layout (hebrew, arabic, etc)
+     */
+    public static boolean isRightToLeftTextLayout() {
+        if (isRightToLeftTextLayout == null) {
+            String displayLanguage = Locale.getDefault().getDisplayLanguage();
+            isRightToLeftTextLayout = new Bidi(displayLanguage, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT).isRightToLeft();
+        }
+        return isRightToLeftTextLayout;
+    }
+
+    /**
+     * @return if the text contains at least 1 number character,
+     *         including any unicode numbers such as Arabic.
+     */
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    public static boolean containsNumber(@NonNull CharSequence text) {
+        for (int index = 0, length = text.length(); index < length;) {
+            final int codePoint = Character.codePointAt(text, index);
+            if (Character.isDigit(codePoint)) {
+                return true;
+            }
+            index += Character.charCount(codePoint);
+        }
+
+        return false;
+    }
+
+    /**
+     * Ignore this class. It must be public to satisfy Android requirements.
+     */
+    @SuppressWarnings("deprecation")
+    public static final class DialogFragmentWrapper extends DialogFragment {
+
+        private Dialog dialog;
+        @Nullable
+        private DialogFragmentOnStartAction onStartAction;
+
+        @Override
+        public void onSaveInstanceState(Bundle outState) {
+            // Do not call super method to prevent state saving.
+        }
+
+        @NonNull
+        @Override
+        public Dialog onCreateDialog(Bundle savedInstanceState) {
+            return dialog;
+        }
+
+        @Override
+        public void onStart() {
+            try {
+                super.onStart();
+
+                if (onStartAction != null) {
+                    onStartAction.onStart((AlertDialog) getDialog());
+                }
+            } catch (Exception ex) {
+                Logger.printException(() -> "onStart failure: " + dialog.getClass().getSimpleName(), ex);
+            }
+        }
+    }
+
+    /**
+     * Interface for {@link #showDialog(Activity, AlertDialog, boolean, DialogFragmentOnStartAction)}.
+     */
+    @FunctionalInterface
+    public interface DialogFragmentOnStartAction {
+        void onStart(AlertDialog dialog);
+    }
+
+    public static void showDialog(Activity activity, AlertDialog dialog) {
+        showDialog(activity, dialog, true, null);
+    }
+
+    /**
+     * Utility method to allow showing an AlertDialog on top of other alert dialogs.
+     * Calling this will always display the dialog on top of all other dialogs
+     * previously called using this method.
+     * <br>
+     * Be aware the on start action can be called multiple times for some situations,
+     * such as the user switching apps without dismissing the dialog then switching back to this app.
+     *<br>
+     * This method is only useful during app startup and multiple patches may show their own dialog,
+     * and the most important dialog can be called last (using a delay) so it's always on top.
+     *<br>
+     * For all other situations it's better to not use this method and
+     * call {@link AlertDialog#show()} on the dialog.
+     */
+    @SuppressWarnings("deprecation")
+    public static void showDialog(Activity activity,
+                                  AlertDialog dialog,
+                                  boolean isCancelable,
+                                  @Nullable DialogFragmentOnStartAction onStartAction) {
+        verifyOnMainThread();
+
+        DialogFragmentWrapper fragment = new DialogFragmentWrapper();
+        fragment.dialog = dialog;
+        fragment.onStartAction = onStartAction;
+        fragment.setCancelable(isCancelable);
+
+        fragment.show(activity.getFragmentManager(), null);
+    }
+
+    /**
+     * Safe to call from any thread
+     */
+    public static void showToastShort(@NonNull String messageToToast) {
+        showToast(messageToToast, Toast.LENGTH_SHORT);
+    }
+
+    /**
+     * Safe to call from any thread
+     */
+    public static void showToastLong(@NonNull String messageToToast) {
+        showToast(messageToToast, Toast.LENGTH_LONG);
+    }
+
+    private static void showToast(@NonNull String messageToToast, int toastDuration) {
+        Objects.requireNonNull(messageToToast);
+        runOnMainThreadNowOrLater(() -> {
+                    if (context == null) {
+                        Logger.initializationException(Utils.class, "Cannot show toast (context is null): " + messageToToast, null);
+                    } else {
+                        Logger.printDebug(() -> "Showing toast: " + messageToToast);
+                        Toast.makeText(context, messageToToast, toastDuration).show();
+                    }
+                }
+        );
+    }
+
+    public static boolean isDarkModeEnabled(Context context) {
+        Configuration config = context.getResources().getConfiguration();
+        final int currentNightMode = config.uiMode & Configuration.UI_MODE_NIGHT_MASK;
+        return currentNightMode == Configuration.UI_MODE_NIGHT_YES;
+    }
+
+    /**
+     * Automatically logs any exceptions the runnable throws.
+     *
+     * @see #runOnMainThreadNowOrLater(Runnable)
+     */
+    public static void runOnMainThread(@NonNull Runnable runnable) {
+        runOnMainThreadDelayed(runnable, 0);
+    }
+
+    /**
+     * Automatically logs any exceptions the runnable throws
+     */
+    public static void runOnMainThreadDelayed(@NonNull Runnable runnable, long delayMillis) {
+        Runnable loggingRunnable = () -> {
+            try {
+                runnable.run();
+            } catch (Exception ex) {
+                Logger.printException(() -> runnable.getClass().getSimpleName() + ": " + ex.getMessage(), ex);
+            }
+        };
+        new Handler(Looper.getMainLooper()).postDelayed(loggingRunnable, delayMillis);
+    }
+
+    /**
+     * If called from the main thread, the code is run immediately.<p>
+     * If called off the main thread, this is the same as {@link #runOnMainThread(Runnable)}.
+     */
+    public static void runOnMainThreadNowOrLater(@NonNull Runnable runnable) {
+        if (isCurrentlyOnMainThread()) {
+            runnable.run();
+        } else {
+            runOnMainThread(runnable);
+        }
+    }
+
+    /**
+     * @return if the calling thread is on the main thread
+     */
+    public static boolean isCurrentlyOnMainThread() {
+        return Looper.getMainLooper().isCurrentThread();
+    }
+
+    /**
+     * @throws IllegalStateException if the calling thread is _off_ the main thread
+     */
+    public static void verifyOnMainThread() throws IllegalStateException {
+        if (!isCurrentlyOnMainThread()) {
+            throw new IllegalStateException("Must call _on_ the main thread");
+        }
+    }
+
+    /**
+     * @throws IllegalStateException if the calling thread is _on_ the main thread
+     */
+    public static void verifyOffMainThread() throws IllegalStateException {
+        if (isCurrentlyOnMainThread()) {
+            throw new IllegalStateException("Must call _off_ the main thread");
+        }
+    }
+
+    public enum NetworkType {
+        NONE,
+        MOBILE,
+        OTHER,
+    }
+
+    public static boolean isNetworkConnected() {
+        NetworkType networkType = getNetworkType();
+        return networkType == NetworkType.MOBILE
+                || networkType == NetworkType.OTHER;
+    }
+
+    @SuppressLint("MissingPermission") // permission already included in YouTube
+    public static NetworkType getNetworkType() {
+        Context networkContext = getContext();
+        if (networkContext == null) {
+            return NetworkType.NONE;
+        }
+        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        var networkInfo = cm.getActiveNetworkInfo();
+
+        if (networkInfo == null || !networkInfo.isConnected()) {
+            return NetworkType.NONE;
+        }
+        var type = networkInfo.getType();
+        return (type == ConnectivityManager.TYPE_MOBILE)
+                || (type == ConnectivityManager.TYPE_BLUETOOTH) ? NetworkType.MOBILE : NetworkType.OTHER;
+    }
+
+    /**
+     * Hide a view by setting its layout params to 0x0
+     * @param view The view to hide.
+     */
+    public static void hideViewByLayoutParams(View view) {
+        if (view instanceof LinearLayout) {
+            LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(0, 0);
+            view.setLayoutParams(layoutParams);
+        } else if (view instanceof FrameLayout) {
+            FrameLayout.LayoutParams layoutParams2 = new FrameLayout.LayoutParams(0, 0);
+            view.setLayoutParams(layoutParams2);
+        } else if (view instanceof RelativeLayout) {
+            RelativeLayout.LayoutParams layoutParams3 = new RelativeLayout.LayoutParams(0, 0);
+            view.setLayoutParams(layoutParams3);
+        } else if (view instanceof Toolbar) {
+            Toolbar.LayoutParams layoutParams4 = new Toolbar.LayoutParams(0, 0);
+            view.setLayoutParams(layoutParams4);
+        } else if (view instanceof ViewGroup) {
+            ViewGroup.LayoutParams layoutParams5 = new ViewGroup.LayoutParams(0, 0);
+            view.setLayoutParams(layoutParams5);
+        } else {
+            ViewGroup.LayoutParams params = view.getLayoutParams();
+            params.width = 0;
+            params.height = 0;
+            view.setLayoutParams(params);
+        }
+    }
+
+    /**
+     * {@link PreferenceScreen} and {@link PreferenceGroup} sorting styles.
+     */
+    private enum Sort {
+        /**
+         * Sort by the localized preference title.
+         */
+        BY_TITLE("_sort_by_title"),
+
+        /**
+         * Sort by the preference keys.
+         */
+        BY_KEY("_sort_by_key"),
+
+        /**
+         * Unspecified sorting.
+         */
+        UNSORTED("_sort_by_unsorted");
+
+        final String keySuffix;
+
+        Sort(String keySuffix) {
+            this.keySuffix = keySuffix;
+        }
+
+        @NonNull
+        static Sort fromKey(@Nullable String key, @NonNull Sort defaultSort) {
+            if (key != null) {
+                for (Sort sort : values()) {
+                    if (key.endsWith(sort.keySuffix)) {
+                        return sort;
+                    }
+                }
+            }
+            return defaultSort;
+        }
+    }
+
+    private static final Pattern punctuationPattern = Pattern.compile("\\p{P}+");
+
+    /**
+     * Strips all punctuation and converts to lower case.  A null parameter returns an empty string.
+     */
+    public static String removePunctuationConvertToLowercase(@Nullable CharSequence original) {
+        if (original == null) return "";
+        return punctuationPattern.matcher(original).replaceAll("").toLowerCase();
+    }
+
+    /**
+     * Sort a PreferenceGroup and all it's sub groups by title or key.
+     *
+     * Sort order is determined by the preferences key {@link Sort} suffix.
+     *
+     * If a preference has no key or no {@link Sort} suffix,
+     * then the preferences are left unsorted.
+     */
+    @SuppressWarnings("deprecation")
+    public static void sortPreferenceGroups(@NonNull PreferenceGroup group) {
+        Sort groupSort = Sort.fromKey(group.getKey(), Sort.UNSORTED);
+        SortedMap<String, Preference> preferences = new TreeMap<>();
+
+        for (int i = 0, prefCount = group.getPreferenceCount(); i < prefCount; i++) {
+            Preference preference = group.getPreference(i);
+
+            final Sort preferenceSort;
+            if (preference instanceof PreferenceGroup) {
+                sortPreferenceGroups((PreferenceGroup) preference);
+                preferenceSort = groupSort; // Sort value for groups is for it's content, not itself.
+            } else {
+                // Allow individual preferences to set a key sorting.
+                // Used to force a preference to the top or bottom of a group.
+                preferenceSort = Sort.fromKey(preference.getKey(), groupSort);
+            }
+
+            final String sortValue;
+            switch (preferenceSort) {
+                case BY_TITLE:
+                    sortValue = removePunctuationConvertToLowercase(preference.getTitle());
+                    break;
+                case BY_KEY:
+                    sortValue = preference.getKey();
+                    break;
+                case UNSORTED:
+                    continue; // Keep original sorting.
+                default:
+                    throw new IllegalStateException();
+            }
+
+            preferences.put(sortValue, preference);
+        }
+
+        int index = 0;
+        for (Preference pref : preferences.values()) {
+            int order = index++;
+
+            // Move any screens, intents, and the one off About preference to the top.
+            if (pref instanceof PreferenceScreen || pref instanceof ReVancedAboutPreference
+                    || pref.getIntent() != null) {
+                // Arbitrary high number.
+                order -= 1000;
+            }
+
+            pref.setOrder(order);
+        }
+    }
+
+    /**
+     * Set all preferences to multiline titles if the device is not using an English variant.
+     * The English strings are heavily scrutinized and all titles fit on screen
+     * except 2 or 3 preference strings and those do not affect readability.
+     *
+     * Allowing multiline for those 2 or 3 English preferences looks weird and out of place,
+     * and visually it looks better to clip the text and keep all titles 1 line.
+     */
+    @SuppressWarnings("deprecation")
+    public static void setPreferenceTitlesToMultiLineIfNeeded(PreferenceGroup group) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+
+        String deviceLanguage = Utils.getContext().getResources().getConfiguration().locale.getLanguage();
+        if (deviceLanguage.equals("en")) {
+            return;
+        }
+
+        for (int i = 0, prefCount = group.getPreferenceCount(); i < prefCount; i++) {
+            Preference pref = group.getPreference(i);
+            pref.setSingleLineTitle(false);
+
+            if (pref instanceof PreferenceGroup) {
+                setPreferenceTitlesToMultiLineIfNeeded((PreferenceGroup) pref);
+            }
+        }
+    }
+
+    /**
+     * If {@link Fragment} uses [Android library] rather than [AndroidX library],
+     * the Dialog theme corresponding to [Android library] should be used.
+     * <p>
+     * If not, the following issues will occur:
+     * <a href="https://github.com/ReVanced/revanced-patches/issues/3061">ReVanced/revanced-patches#3061</a>
+     * <p>
+     * To prevent these issues, apply the Dialog theme corresponding to [Android library].
+     */
+    public static void setEditTextDialogTheme(AlertDialog.Builder builder) {
+        final int editTextDialogStyle = getResourceIdentifier(
+                "revanced_edit_text_dialog_style", "style");
+        if (editTextDialogStyle != 0) {
+            builder.getContext().setTheme(editTextDialogStyle);
+        }
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/checks/Check.java

@@ -0,0 +1,164 @@
+package app.revanced.extension.shared.checks;
+
+import static android.text.Html.FROM_HTML_MODE_COMPACT;
+import static app.revanced.extension.shared.StringRef.str;
+import static app.revanced.extension.shared.Utils.DialogFragmentOnStartAction;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.net.Uri;
+import android.text.Html;
+import android.widget.Button;
+
+import androidx.annotation.Nullable;
+
+import java.util.Collection;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.settings.BaseSettings;
+
+abstract class Check {
+    private static final int NUMBER_OF_TIMES_TO_IGNORE_WARNING_BEFORE_DISABLING = 2;
+
+    private static final int SECONDS_BEFORE_SHOWING_IGNORE_BUTTON = 15;
+    private static final int SECONDS_BEFORE_SHOWING_WEBSITE_BUTTON = 10;
+
+    private static final Uri GOOD_SOURCE = Uri.parse("https://revanced.app");
+
+    /**
+     * @return If the check conclusively passed or failed. A null value indicates it neither passed nor failed.
+     */
+    @Nullable
+    protected abstract Boolean check();
+
+    protected abstract String failureReason();
+
+    /**
+     * Specifies a sorting order for displaying the checks that failed.
+     * A lower value indicates to show first before other checks.
+     */
+    public abstract int uiSortingValue();
+
+    /**
+     * For debugging and development only.
+     * Forces all checks to be performed and the check failed dialog to be shown.
+     * Can be enabled by importing settings text with {@link BaseSettings#CHECK_ENVIRONMENT_WARNINGS_ISSUED}
+     * set to -1.
+     */
+    static boolean debugAlwaysShowWarning() {
+        final boolean alwaysShowWarning = BaseSettings.CHECK_ENVIRONMENT_WARNINGS_ISSUED.get() < 0;
+        if (alwaysShowWarning) {
+            Logger.printInfo(() -> "Debug forcing environment check warning to show");
+        }
+
+        return alwaysShowWarning;
+    }
+
+    static boolean shouldRun() {
+        return BaseSettings.CHECK_ENVIRONMENT_WARNINGS_ISSUED.get()
+                < NUMBER_OF_TIMES_TO_IGNORE_WARNING_BEFORE_DISABLING;
+    }
+
+    static void disableForever() {
+        Logger.printInfo(() -> "Environment checks disabled forever");
+
+        BaseSettings.CHECK_ENVIRONMENT_WARNINGS_ISSUED.save(Integer.MAX_VALUE);
+    }
+
+    @SuppressLint("NewApi")
+    static void issueWarning(Activity activity, Collection<Check> failedChecks) {
+        final var reasons = new StringBuilder();
+
+        reasons.append("<ul>");
+        for (var check : failedChecks) {
+            // Add a non breaking space to fix bullet points spacing issue.
+            reasons.append("<li>&nbsp;").append(check.failureReason());
+        }
+        reasons.append("</ul>");
+
+        var message = Html.fromHtml(
+                str("revanced_check_environment_failed_message", reasons.toString()),
+                FROM_HTML_MODE_COMPACT
+        );
+
+        Utils.runOnMainThreadDelayed(() -> {
+            AlertDialog alert = new AlertDialog.Builder(activity)
+                    .setCancelable(false)
+                    .setIconAttribute(android.R.attr.alertDialogIcon)
+                    .setTitle(str("revanced_check_environment_failed_title"))
+                    .setMessage(message)
+                    .setPositiveButton(
+                            " ",
+                            (dialog, which) -> {
+                                final var intent = new Intent(Intent.ACTION_VIEW, GOOD_SOURCE);
+                                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                                activity.startActivity(intent);
+
+                                // Shutdown to prevent the user from navigating back to this app,
+                                // which is no longer showing a warning dialog.
+                                activity.finishAffinity();
+                                System.exit(0);
+                            }
+                    ).setNegativeButton(
+                            " ",
+                            (dialog, which) -> {
+                                // Cleanup data if the user incorrectly imported a huge negative number.
+                                final int current = Math.max(0, BaseSettings.CHECK_ENVIRONMENT_WARNINGS_ISSUED.get());
+                                BaseSettings.CHECK_ENVIRONMENT_WARNINGS_ISSUED.save(current + 1);
+
+                                dialog.dismiss();
+                            }
+                    ).create();
+
+            Utils.showDialog(activity, alert, false, new DialogFragmentOnStartAction() {
+                boolean hasRun;
+                @Override
+                public void onStart(AlertDialog dialog) {
+                    // Only run this once, otherwise if the user changes to a different app
+                    // then changes back, this handler will run again and disable the buttons.
+                    if (hasRun) {
+                        return;
+                    }
+                    hasRun = true;
+
+                    var openWebsiteButton = dialog.getButton(DialogInterface.BUTTON_POSITIVE);
+                    openWebsiteButton.setEnabled(false);
+
+                    var dismissButton = dialog.getButton(DialogInterface.BUTTON_NEGATIVE);
+                    dismissButton.setEnabled(false);
+
+                    getCountdownRunnable(dismissButton, openWebsiteButton).run();
+                }
+            });
+        }, 1000); // Use a delay, so this dialog is shown on top of any other startup dialogs.
+    }
+
+    private static Runnable getCountdownRunnable(Button dismissButton, Button openWebsiteButton) {
+        return new Runnable() {
+            private int secondsRemaining = SECONDS_BEFORE_SHOWING_IGNORE_BUTTON;
+
+            @Override
+            public void run() {
+                Utils.verifyOnMainThread();
+
+                if (secondsRemaining > 0) {
+                    if (secondsRemaining - SECONDS_BEFORE_SHOWING_WEBSITE_BUTTON == 0) {
+                        openWebsiteButton.setText(str("revanced_check_environment_dialog_open_official_source_button"));
+                        openWebsiteButton.setEnabled(true);
+                    }
+
+                    secondsRemaining--;
+
+                    Utils.runOnMainThreadDelayed(this, 1000);
+                } else {
+                    dismissButton.setText(str("revanced_check_environment_dialog_ignore_button"));
+                    dismissButton.setEnabled(true);
+                }
+            }
+        };
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/checks/CheckEnvironmentPatch.java

@@ -0,0 +1,341 @@
+package app.revanced.extension.shared.checks;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.util.Base64;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.*;
+
+import static app.revanced.extension.shared.StringRef.str;
+import static app.revanced.extension.shared.checks.Check.debugAlwaysShowWarning;
+import static app.revanced.extension.shared.checks.PatchInfo.Build.*;
+
+/**
+ * This class is used to check if the app was patched by the user
+ * and not downloaded pre-patched, because pre-patched apps are difficult to trust.
+ * <br>
+ * Various indicators help to detect if the app was patched by the user.
+ */
+@SuppressWarnings("unused")
+public final class CheckEnvironmentPatch {
+    private static final boolean DEBUG_ALWAYS_SHOW_CHECK_FAILED_DIALOG = debugAlwaysShowWarning();
+
+    private enum InstallationType {
+        /**
+         * CLI patching, manual installation of a previously patched using adb,
+         * or root installation if stock app is first installed using adb.
+         */
+        ADB((String) null),
+        ROOT_MOUNT_ON_APP_STORE("com.android.vending"),
+        MANAGER("app.revanced.manager.flutter",
+                "app.revanced.manager",
+                "app.revanced.manager.debug");
+
+        @Nullable
+        static InstallationType installTypeFromPackageName(@Nullable String packageName) {
+            for (InstallationType type : values()) {
+                for (String installPackageName : type.packageNames) {
+                    if (Objects.equals(installPackageName, packageName)) {
+                        return type;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /**
+         * Array elements can be null.
+         */
+        final String[] packageNames;
+
+        InstallationType(String... packageNames) {
+            this.packageNames = packageNames;
+        }
+    }
+
+    /**
+     * Check if the app is installed by the manager, the app store, or through adb/CLI.
+     * <br>
+     * Does not conclusively
+     * If the app is installed by the manager or the app store, it is likely, the app was patched using the manager,
+     * or installed manually via ADB (in the case of ReVanced CLI for example).
+     * <br>
+     * If the app is not installed by the manager or the app store, then the app was likely downloaded pre-patched
+     * and installed by the browser or another unknown app.
+     */
+    private static class CheckExpectedInstaller extends Check {
+        @Nullable
+        InstallationType installerFound;
+
+        @NonNull
+        @Override
+        protected Boolean check() {
+            final var context = Utils.getContext();
+
+            final var installerPackageName =
+                    context.getPackageManager().getInstallerPackageName(context.getPackageName());
+
+            Logger.printInfo(() -> "Installed by: " + installerPackageName);
+
+            installerFound = InstallationType.installTypeFromPackageName(installerPackageName);
+            final boolean passed = (installerFound != null);
+
+            Logger.printInfo(() -> passed
+                    ? "Apk was not installed from an unknown source"
+                    : "Apk was installed from an unknown source");
+
+            return passed;
+        }
+
+        @Override
+        protected String failureReason() {
+            return str("revanced_check_environment_manager_not_expected_installer");
+        }
+
+        @Override
+        public int uiSortingValue() {
+            return -100; // Show first.
+        }
+    }
+
+    /**
+     * Check if the build properties are the same as during the patch.
+     * <br>
+     * If the build properties are the same as during the patch, it is likely, the app was patched on the same device.
+     * <br>
+     * If the build properties are different, the app was likely downloaded pre-patched or patched on another device.
+     */
+    private static class CheckWasPatchedOnSameDevice extends Check {
+        @SuppressLint({"NewApi", "HardwareIds"})
+        @Override
+        protected Boolean check() {
+            if (PATCH_BOARD.isEmpty()) {
+                // Did not patch with Manager, and cannot conclusively say where this was from.
+                Logger.printInfo(() -> "APK does not contain a hardware signature and cannot compare to current device");
+                return null;
+            }
+
+            //noinspection deprecation
+            final var passed = buildFieldEqualsHash("BOARD", Build.BOARD, PATCH_BOARD) &
+                    buildFieldEqualsHash("BOOTLOADER", Build.BOOTLOADER, PATCH_BOOTLOADER) &
+                    buildFieldEqualsHash("BRAND", Build.BRAND, PATCH_BRAND) &
+                    buildFieldEqualsHash("CPU_ABI", Build.CPU_ABI, PATCH_CPU_ABI) &
+                    buildFieldEqualsHash("CPU_ABI2", Build.CPU_ABI2, PATCH_CPU_ABI2) &
+                    buildFieldEqualsHash("DEVICE", Build.DEVICE, PATCH_DEVICE) &
+                    buildFieldEqualsHash("DISPLAY", Build.DISPLAY, PATCH_DISPLAY) &
+                    buildFieldEqualsHash("FINGERPRINT", Build.FINGERPRINT, PATCH_FINGERPRINT) &
+                    buildFieldEqualsHash("HARDWARE", Build.HARDWARE, PATCH_HARDWARE) &
+                    buildFieldEqualsHash("HOST", Build.HOST, PATCH_HOST) &
+                    buildFieldEqualsHash("ID", Build.ID, PATCH_ID) &
+                    buildFieldEqualsHash("MANUFACTURER", Build.MANUFACTURER, PATCH_MANUFACTURER) &
+                    buildFieldEqualsHash("MODEL", Build.MODEL, PATCH_MODEL) &
+                    buildFieldEqualsHash("PRODUCT", Build.PRODUCT, PATCH_PRODUCT) &
+                    buildFieldEqualsHash("RADIO", Build.RADIO, PATCH_RADIO) &
+                    buildFieldEqualsHash("TAGS", Build.TAGS, PATCH_TAGS) &
+                    buildFieldEqualsHash("TYPE", Build.TYPE, PATCH_TYPE) &
+                    buildFieldEqualsHash("USER", Build.USER, PATCH_USER);
+
+            Logger.printInfo(() -> passed
+                    ? "Device hardware signature matches current device"
+                    : "Device hardware signature does not match current device");
+
+            return passed;
+        }
+
+        @Override
+        protected String failureReason() {
+            return str("revanced_check_environment_not_same_patching_device");
+        }
+
+        @Override
+        public int uiSortingValue() {
+            return 0; // Show in the middle.
+        }
+    }
+
+    /**
+     * Check if the app was installed within the last 30 minutes after being patched.
+     * <br>
+     * If the app was installed within the last 30 minutes, it is likely, the app was patched by the user.
+     * <br>
+     * If the app was installed much later than the patch time, it is likely the app was
+     * downloaded pre-patched or the user waited too long to install the app.
+     */
+    private static class CheckIsNearPatchTime extends Check {
+        /**
+         * How soon after patching the app must be installed to pass.
+         */
+        static final int INSTALL_AFTER_PATCHING_DURATION_THRESHOLD = 30 * 60 * 1000;  // 30 minutes.
+
+        /**
+         * Milliseconds between the time the app was patched, and when it was installed/updated.
+         */
+        long durationBetweenPatchingAndInstallation;
+
+        @NonNull
+        @Override
+        protected Boolean check() {
+            try {
+                Context context = Utils.getContext();
+                PackageManager packageManager = context.getPackageManager();
+                PackageInfo packageInfo = packageManager.getPackageInfo(context.getPackageName(), 0);
+
+                // Duration since initial install or last update, which ever is sooner.
+                durationBetweenPatchingAndInstallation = packageInfo.lastUpdateTime - PatchInfo.PATCH_TIME;
+                Logger.printInfo(() -> "App was installed/updated: "
+                        + (durationBetweenPatchingAndInstallation / (60 * 1000) + " minutes after patching"));
+
+                if (durationBetweenPatchingAndInstallation < 0) {
+                    // Patch time is in the future and clearly wrong.
+                    return false;
+                }
+
+                if (durationBetweenPatchingAndInstallation < INSTALL_AFTER_PATCHING_DURATION_THRESHOLD) {
+                    return true;
+                }
+            } catch (PackageManager.NameNotFoundException ex) {
+                Logger.printException(() -> "Package name not found exception", ex); // Will never happen.
+            }
+
+            // User installed more than 30 minutes after patching.
+            return false;
+        }
+
+        @Override
+        protected String failureReason() {
+            if (durationBetweenPatchingAndInstallation < 0) {
+                // Could happen if the user has their device clock incorrectly set in the past,
+                // but assume that isn't the case and the apk was patched on a device with the wrong system time.
+                return str("revanced_check_environment_not_near_patch_time_invalid");
+            }
+
+            // If patched over 1 day ago, show how old this pre-patched apk is.
+            // Showing the age can help convey it's better to patch yourself and know it's the latest.
+            final long oneDay = 24 * 60 * 60 * 1000;
+            final long daysSincePatching = durationBetweenPatchingAndInstallation / oneDay;
+            if (daysSincePatching > 1) { // Use over 1 day to avoid singular vs plural strings.
+                return str("revanced_check_environment_not_near_patch_time_days", daysSincePatching);
+            }
+
+            return str("revanced_check_environment_not_near_patch_time");
+        }
+
+        @Override
+        public int uiSortingValue() {
+            return 100; // Show last.
+        }
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void check(Activity context) {
+        // If the warning was already issued twice, or if the check was successful in the past,
+        // do not run the checks again.
+        if (!Check.shouldRun() && !DEBUG_ALWAYS_SHOW_CHECK_FAILED_DIALOG) {
+            Logger.printDebug(() -> "Environment checks are disabled");
+            return;
+        }
+
+        Utils.runOnBackgroundThread(() -> {
+            try {
+                Logger.printInfo(() -> "Running environment checks");
+                List<Check> failedChecks = new ArrayList<>();
+
+                CheckWasPatchedOnSameDevice sameHardware = new CheckWasPatchedOnSameDevice();
+                Boolean hardwareCheckPassed = sameHardware.check();
+                if (hardwareCheckPassed != null) {
+                    if (hardwareCheckPassed && !DEBUG_ALWAYS_SHOW_CHECK_FAILED_DIALOG) {
+                        // Patched on the same device using Manager,
+                        // and no further checks are needed.
+                        Check.disableForever();
+                        return;
+                    }
+
+                    failedChecks.add(sameHardware);
+                }
+
+                CheckExpectedInstaller installerCheck = new CheckExpectedInstaller();
+                if (installerCheck.check() && !DEBUG_ALWAYS_SHOW_CHECK_FAILED_DIALOG) {
+                    // If the installer package is Manager but this code is reached,
+                    // that means it must not be the right Manager otherwise the hardware hash
+                    // signatures would be present and this check would not have run.
+                    if (installerCheck.installerFound == InstallationType.MANAGER) {
+                        failedChecks.add(installerCheck);
+                        // Also could not have been patched on this device.
+                        failedChecks.add(sameHardware);
+                    } else if (failedChecks.isEmpty()) {
+                        // ADB install of CLI build. Allow even if patched a long time ago.
+                        Check.disableForever();
+                        return;
+                    }
+                } else {
+                    failedChecks.add(installerCheck);
+                }
+
+                CheckIsNearPatchTime nearPatchTime = new CheckIsNearPatchTime();
+                Boolean timeCheckPassed = nearPatchTime.check();
+                if (timeCheckPassed && !DEBUG_ALWAYS_SHOW_CHECK_FAILED_DIALOG) {
+                    // Allow installing recently patched apks,
+                    // even if the install source is not Manager or ADB.
+                    Check.disableForever();
+                    return;
+                } else {
+                    failedChecks.add(nearPatchTime);
+                }
+
+                if (DEBUG_ALWAYS_SHOW_CHECK_FAILED_DIALOG) {
+                    // Show all failures for debugging layout.
+                    failedChecks = Arrays.asList(
+                            sameHardware,
+                            nearPatchTime,
+                            installerCheck
+                    );
+                }
+
+                //noinspection ComparatorCombinators
+                Collections.sort(failedChecks, (o1, o2) -> o1.uiSortingValue() - o2.uiSortingValue());
+
+                Check.issueWarning(
+                        context,
+                        failedChecks
+                );
+            } catch (Exception ex) {
+                Logger.printException(() -> "check failure", ex);
+            }
+        });
+    }
+
+    private static boolean buildFieldEqualsHash(String buildFieldName, String buildFieldValue, @Nullable String hash) {
+        try {
+            final var sha1 = MessageDigest.getInstance("SHA-1")
+                    .digest(buildFieldValue.getBytes(StandardCharsets.UTF_8));
+
+            // Must be careful to use same base64 encoding Kotlin uses.
+            String runtimeHash = new String(Base64.encode(sha1, Base64.NO_WRAP), StandardCharsets.ISO_8859_1);
+            final boolean equals = runtimeHash.equals(hash);
+            if (!equals) {
+                Logger.printInfo(() -> "Hashes do not match. " + buildFieldName + ": '" + buildFieldValue
+                        + "' runtimeHash: '" + runtimeHash + "' patchTimeHash: '" + hash + "'");
+            }
+
+            return equals;
+        } catch (NoSuchAlgorithmException ex) {
+            Logger.printException(() -> "buildFieldEqualsHash failure", ex); // Will never happen.
+
+            return false;
+        }
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/checks/PatchInfo.java

@@ -0,0 +1,32 @@
+package app.revanced.extension.shared.checks;
+
+/**
+ * Fields are set by the patch. Do not modify.
+ * Fields are not final, because the compiler is inlining them.
+ *
+ * @noinspection CanBeFinal
+ */
+final class PatchInfo {
+    static long PATCH_TIME = 0L;
+
+    final static class Build {
+        static String PATCH_BOARD = "";
+        static String PATCH_BOOTLOADER = "";
+        static String PATCH_BRAND = "";
+        static String PATCH_CPU_ABI = "";
+        static String PATCH_CPU_ABI2 = "";
+        static String PATCH_DEVICE = "";
+        static String PATCH_DISPLAY = "";
+        static String PATCH_FINGERPRINT = "";
+        static String PATCH_HARDWARE = "";
+        static String PATCH_HOST = "";
+        static String PATCH_ID = "";
+        static String PATCH_MANUFACTURER = "";
+        static String PATCH_MODEL = "";
+        static String PATCH_PRODUCT = "";
+        static String PATCH_RADIO = "";
+        static String PATCH_TAGS = "";
+        static String PATCH_TYPE = "";
+        static String PATCH_USER = "";
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/fixes/slink/BaseFixSLinksPatch.java

@@ -0,0 +1,208 @@
+package app.revanced.extension.shared.fixes.slink;
+
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import androidx.annotation.NonNull;
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.SocketTimeoutException;
+import java.net.URL;
+import java.util.Objects;
+
+import static app.revanced.extension.shared.Utils.getContext;
+
+
+/**
+ * Base class to implement /s/ link resolution in 3rd party Reddit apps.
+ * <br>
+ * <br>
+ * Usage:
+ * <br>
+ * <br>
+ * An implementation of this class must have two static methods that are called by the app:
+ * <ul>
+ *     <li>public static boolean patchResolveSLink(String link)</li>
+ *     <li>public static void patchSetAccessToken(String accessToken)</li>
+ * </ul>
+ * The static methods must call the instance methods of the base class.
+ * <br>
+ * The singleton pattern can be used to access the instance of the class:
+ * <pre>
+ * {@code
+ * {
+ *     INSTANCE = new FixSLinksPatch();
+ * }
+ * }
+ * </pre>
+ * Set the app's web view activity class as a fallback to open /s/ links if the resolution fails:
+ * <pre>
+ * {@code
+ * private FixSLinksPatch() {
+ *     webViewActivityClass = WebViewActivity.class;
+ * }
+ * }
+ * </pre>
+ * Hook the app's navigation handler to call this method before doing any of its own resolution:
+ * <pre>
+ * {@code
+ * public static boolean patchResolveSLink(Context context, String link) {
+ *     return INSTANCE.resolveSLink(context, link);
+ * }
+ * }
+ * </pre>
+ * If this method returns true, the app should early return and not do any of its own resolution.
+ * <br>
+ * <br>
+ * Hook the app's access token so that this class can use it to resolve /s/ links:
+ * <pre>
+ * {@code
+ * public static void patchSetAccessToken(String accessToken) {
+ *     INSTANCE.setAccessToken(access_token);
+ * }
+ * }
+ * </pre>
+ */
+public abstract class BaseFixSLinksPatch {
+    /**
+     * The class of the activity used to open links in a web view if resolving them fails.
+     */
+    protected Class<? extends Activity> webViewActivityClass;
+
+    /**
+     * The access token used to resolve the /s/ link.
+     */
+    protected String accessToken;
+
+    /**
+     * The URL that was trying to be resolved before the access token was set.
+     * If this is not null, the URL will be resolved right after the access token is set.
+     */
+    protected String pendingUrl;
+
+    /**
+     * The singleton instance of the class.
+     */
+    protected static BaseFixSLinksPatch INSTANCE;
+
+    public boolean resolveSLink(String link) {
+        switch (resolveLink(link)) {
+            case ACCESS_TOKEN_START: {
+                pendingUrl = link;
+                return true;
+            }
+            case DO_NOTHING:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private ResolveResult resolveLink(String link) {
+        Context context = getContext();
+        if (link.matches(".*reddit\\.com/r/[^/]+/s/[^/]+")) {
+            // A link ends with #bypass if it failed to resolve below.
+            // resolveLink is called with the same link again but this time with #bypass
+            // so that the link is opened in the app browser instead of trying to resolve it again.
+            if (link.endsWith("#bypass")) {
+                openInAppBrowser(context, link);
+
+                return ResolveResult.DO_NOTHING;
+            }
+
+            Logger.printDebug(() -> "Resolving " + link);
+
+            if (accessToken == null) {
+                // This is not optimal.
+                // However, an accessToken is necessary to make an authenticated request to Reddit.
+                // in case Reddit has banned the IP - e.g. VPN.
+                Intent startIntent = context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
+                context.startActivity(startIntent);
+
+                return ResolveResult.ACCESS_TOKEN_START;
+            }
+
+
+            Utils.runOnBackgroundThread(() -> {
+                String bypassLink = link + "#bypass";
+
+                String finalLocation = bypassLink;
+                try {
+                    HttpURLConnection connection = getHttpURLConnection(link, accessToken);
+                    connection.connect();
+                    String location = connection.getHeaderField("location");
+                    connection.disconnect();
+
+                    Objects.requireNonNull(location, "Location is null");
+
+                    finalLocation = location;
+                    Logger.printDebug(() -> "Resolved " + link + " to " + location);
+                } catch (SocketTimeoutException e) {
+                    Logger.printException(() -> "Timeout when trying to resolve " + link, e);
+                    finalLocation = bypassLink;
+                } catch (Exception e) {
+                    Logger.printException(() -> "Failed to resolve " + link, e);
+                    finalLocation = bypassLink;
+                } finally {
+                    Intent startIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(finalLocation));
+                    startIntent.setPackage(context.getPackageName());
+                    startIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                    context.startActivity(startIntent);
+                }
+            });
+
+            return ResolveResult.DO_NOTHING;
+        }
+
+        return ResolveResult.CONTINUE;
+    }
+
+    public void setAccessToken(String accessToken) {
+        Logger.printDebug(() -> "Setting access token");
+
+        this.accessToken = accessToken;
+
+        // In case a link was trying to be resolved before access token was set.
+        // The link is resolved now, after the access token is set.
+        if (pendingUrl != null) {
+            String link = pendingUrl;
+            pendingUrl = null;
+
+            Logger.printDebug(() -> "Opening pending URL");
+
+            resolveLink(link);
+        }
+    }
+
+    private void openInAppBrowser(Context context, String link) {
+        Intent intent = new Intent(context, webViewActivityClass);
+        intent.putExtra("url", link);
+        context.startActivity(intent);
+    }
+
+    @NonNull
+    private HttpURLConnection getHttpURLConnection(String link, String accessToken) throws IOException {
+        URL url = new URL(link);
+
+        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+        connection.setInstanceFollowRedirects(false);
+        connection.setRequestMethod("HEAD");
+        connection.setConnectTimeout(2000);
+        connection.setReadTimeout(2000);
+
+        if (accessToken != null) {
+            Logger.printDebug(() -> "Setting access token to make /s/ request");
+
+            connection.setRequestProperty("Authorization", "Bearer " + accessToken);
+        } else {
+            Logger.printDebug(() -> "Not setting access token to make /s/ request, because it is null");
+        }
+
+        return connection;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/fixes/slink/ResolveResult.java

@@ -0,0 +1,10 @@
+package app.revanced.extension.shared.fixes.slink;
+
+public enum ResolveResult {
+    // Let app handle rest of stuff
+    CONTINUE,
+    // Start app, to make it cache its access_token
+    ACCESS_TOKEN_START,
+    // Don't do anything - we started resolving
+    DO_NOTHING
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/requests/Requester.java

@@ -0,0 +1,145 @@
+package app.revanced.extension.shared.requests;
+
+import app.revanced.extension.shared.Utils;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+public class Requester {
+    private Requester() {
+    }
+
+    public static HttpURLConnection getConnectionFromRoute(String apiUrl, Route route, String... params) throws IOException {
+        return getConnectionFromCompiledRoute(apiUrl, route.compile(params));
+    }
+
+    public static HttpURLConnection getConnectionFromCompiledRoute(String apiUrl, Route.CompiledRoute route) throws IOException {
+        String url = apiUrl + route.getCompiledRoute();
+        HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
+        // Request data is in the URL parameters and no body is sent.
+        // The calling code must set a length if using a request body.
+        connection.setFixedLengthStreamingMode(0);
+        connection.setRequestMethod(route.getMethod().name());
+        String agentString = System.getProperty("http.agent")
+                + "; ReVanced/" + Utils.getAppVersionName()
+                + " (" + Utils.getPatchesReleaseVersion() + ")";
+        connection.setRequestProperty("User-Agent", agentString);
+
+        return connection;
+    }
+
+    /**
+     * Parse the {@link HttpURLConnection}, and closes the underlying InputStream.
+     */
+    private static String parseInputStreamAndClose(InputStream inputStream) throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
+            StringBuilder jsonBuilder = new StringBuilder();
+            String line;
+            while ((line = reader.readLine()) != null) {
+                jsonBuilder.append(line);
+                jsonBuilder.append('\n');
+            }
+            return jsonBuilder.toString();
+        }
+    }
+
+    /**
+     * Parse the {@link HttpURLConnection} response as a String.
+     * This does not close the url connection. If further requests to this host are unlikely
+     * in the near future, then instead use {@link #parseStringAndDisconnect(HttpURLConnection)}.
+     */
+    public static String parseString(HttpURLConnection connection) throws IOException {
+        return parseInputStreamAndClose(connection.getInputStream());
+    }
+
+    /**
+     * Parse the {@link HttpURLConnection} response as a String, and disconnect.
+     *
+     * <b>Should only be used if other requests to the server in the near future are unlikely</b>
+     *
+     * @see #parseString(HttpURLConnection)
+     */
+    public static String parseStringAndDisconnect(HttpURLConnection connection) throws IOException {
+        String result = parseString(connection);
+        connection.disconnect();
+        return result;
+    }
+
+    /**
+     * Parse the {@link HttpURLConnection} error stream as a String.
+     * If the server sent no error response data, this returns an empty string.
+     */
+    public static String parseErrorString(HttpURLConnection connection) throws IOException {
+        InputStream errorStream = connection.getErrorStream();
+        if (errorStream == null) {
+            return "";
+        }
+        return parseInputStreamAndClose(errorStream);
+    }
+
+    /**
+     * Parse the {@link HttpURLConnection} error stream as a String, and disconnect.
+     * If the server sent no error response data, this returns an empty string.
+     *
+     * Should only be used if other requests to the server are unlikely in the near future.
+     *
+     * @see #parseErrorString(HttpURLConnection)
+     */
+    public static String parseErrorStringAndDisconnect(HttpURLConnection connection) throws IOException {
+        String result = parseErrorString(connection);
+        connection.disconnect();
+        return result;
+    }
+
+    /**
+     * Parse the {@link HttpURLConnection} response into a JSONObject.
+     * This does not close the url connection. If further requests to this host are unlikely
+     * in the near future, then instead use {@link #parseJSONObjectAndDisconnect(HttpURLConnection)}.
+     */
+    public static JSONObject parseJSONObject(HttpURLConnection connection) throws JSONException, IOException {
+        return new JSONObject(parseString(connection));
+    }
+
+    /**
+     * Parse the {@link HttpURLConnection}, close the underlying InputStream, and disconnect.
+     *
+     * <b>Should only be used if other requests to the server in the near future are unlikely</b>
+     *
+     * @see #parseJSONObject(HttpURLConnection)
+     */
+    public static JSONObject parseJSONObjectAndDisconnect(HttpURLConnection connection) throws JSONException, IOException {
+        JSONObject object = parseJSONObject(connection);
+        connection.disconnect();
+        return object;
+    }
+
+    /**
+     * Parse the {@link HttpURLConnection}, and closes the underlying InputStream.
+     * This does not close the url connection. If further requests to this host are unlikely
+     * in the near future, then instead use {@link #parseJSONArrayAndDisconnect(HttpURLConnection)}.
+     */
+    public static JSONArray parseJSONArray(HttpURLConnection connection) throws JSONException, IOException  {
+        return new JSONArray(parseString(connection));
+    }
+
+    /**
+     * Parse the {@link HttpURLConnection}, close the underlying InputStream, and disconnect.
+     *
+     * <b>Should only be used if other requests to the server in the near future are unlikely</b>
+     *
+     * @see #parseJSONArray(HttpURLConnection)
+     */
+    public static JSONArray parseJSONArrayAndDisconnect(HttpURLConnection connection) throws JSONException, IOException  {
+        JSONArray array = parseJSONArray(connection);
+        connection.disconnect();
+        return array;
+    }
+
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/requests/Route.java

@@ -0,0 +1,66 @@
+package app.revanced.extension.shared.requests;
+
+public class Route {
+    private final String route;
+    private final Method method;
+    private final int paramCount;
+
+    public Route(Method method, String route) {
+        this.method = method;
+        this.route = route;
+        this.paramCount = countMatches(route, '{');
+
+        if (paramCount != countMatches(route, '}'))
+            throw new IllegalArgumentException("Not enough parameters");
+    }
+
+    public Method getMethod() {
+        return method;
+    }
+
+    public CompiledRoute compile(String... params) {
+        if (params.length != paramCount)
+            throw new IllegalArgumentException("Error compiling route [" + route + "], incorrect amount of parameters provided. " +
+                    "Expected: " + paramCount + ", provided: " + params.length);
+
+        StringBuilder compiledRoute = new StringBuilder(route);
+        for (int i = 0; i < paramCount; i++) {
+            int paramStart = compiledRoute.indexOf("{");
+            int paramEnd = compiledRoute.indexOf("}");
+            compiledRoute.replace(paramStart, paramEnd + 1, params[i]);
+        }
+        return new CompiledRoute(this, compiledRoute.toString());
+    }
+
+    public static class CompiledRoute {
+        private final Route baseRoute;
+        private final String compiledRoute;
+
+        private CompiledRoute(Route baseRoute, String compiledRoute) {
+            this.baseRoute = baseRoute;
+            this.compiledRoute = compiledRoute;
+        }
+
+        public String getCompiledRoute() {
+            return compiledRoute;
+        }
+
+        public Method getMethod() {
+            return baseRoute.method;
+        }
+    }
+
+    private int countMatches(CharSequence seq, char c) {
+        int count = 0;
+        for (int i = 0; i < seq.length(); i++) {
+            if (seq.charAt(i) == c)
+                count++;
+        }
+        return count;
+    }
+
+    public enum Method {
+        GET,
+        POST
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/BaseSettings.java

@@ -0,0 +1,24 @@
+package app.revanced.extension.shared.settings;
+
+import static java.lang.Boolean.FALSE;
+import static java.lang.Boolean.TRUE;
+import static app.revanced.extension.shared.settings.Setting.parent;
+
+import app.revanced.extension.shared.spoof.AudioStreamLanguage;
+
+/**
+ * Settings shared across multiple apps.
+ * <p>
+ * To ensure this class is loaded when the UI is created, app specific setting bundles should extend
+ * or reference this class.
+ */
+public class BaseSettings {
+    public static final BooleanSetting DEBUG = new BooleanSetting("revanced_debug", FALSE);
+    public static final BooleanSetting DEBUG_STACKTRACE = new BooleanSetting("revanced_debug_stacktrace", FALSE, parent(DEBUG));
+    public static final BooleanSetting DEBUG_TOAST_ON_ERROR = new BooleanSetting("revanced_debug_toast_on_error", TRUE, "revanced_debug_toast_on_error_user_dialog_message");
+
+    public static final IntegerSetting CHECK_ENVIRONMENT_WARNINGS_ISSUED = new IntegerSetting("revanced_check_environment_warnings_issued", 0, true, false);
+
+    public static final BooleanSetting SPOOF_VIDEO_STREAMS = new BooleanSetting("revanced_spoof_video_streams", TRUE, true, "revanced_spoof_video_streams_user_dialog_message");
+    public static final EnumSetting<AudioStreamLanguage> SPOOF_VIDEO_STREAMS_LANGUAGE = new EnumSetting<>("revanced_spoof_video_streams_language", AudioStreamLanguage.DEFAULT, parent(SPOOF_VIDEO_STREAMS));
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/BooleanSetting.java

@@ -0,0 +1,79 @@
+package app.revanced.extension.shared.settings;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Objects;
+
+@SuppressWarnings("unused")
+public class BooleanSetting extends Setting<Boolean> {
+    public BooleanSetting(String key, Boolean defaultValue) {
+        super(key, defaultValue);
+    }
+    public BooleanSetting(String key, Boolean defaultValue, boolean rebootApp) {
+        super(key, defaultValue, rebootApp);
+    }
+    public BooleanSetting(String key, Boolean defaultValue, boolean rebootApp, boolean includeWithImportExport) {
+        super(key, defaultValue, rebootApp, includeWithImportExport);
+    }
+    public BooleanSetting(String key, Boolean defaultValue, String userDialogMessage) {
+        super(key, defaultValue, userDialogMessage);
+    }
+    public BooleanSetting(String key, Boolean defaultValue, Availability availability) {
+        super(key, defaultValue, availability);
+    }
+    public BooleanSetting(String key, Boolean defaultValue, boolean rebootApp, String userDialogMessage) {
+        super(key, defaultValue, rebootApp, userDialogMessage);
+    }
+    public BooleanSetting(String key, Boolean defaultValue, boolean rebootApp, Availability availability) {
+        super(key, defaultValue, rebootApp, availability);
+    }
+    public BooleanSetting(String key, Boolean defaultValue, boolean rebootApp, String userDialogMessage, Availability availability) {
+        super(key, defaultValue, rebootApp, userDialogMessage, availability);
+    }
+    public BooleanSetting(@NonNull String key, @NonNull Boolean defaultValue, boolean rebootApp, boolean includeWithImportExport, @Nullable String userDialogMessage, @Nullable Availability availability) {
+        super(key, defaultValue, rebootApp, includeWithImportExport, userDialogMessage, availability);
+    }
+
+    /**
+     * Sets, but does _not_ persistently save the value.
+     * This method is only to be used by the Settings preference code.
+     *
+     * This intentionally is a static method to deter
+     * accidental usage when {@link #save(Boolean)} was intnded.
+     */
+    public static void privateSetValue(@NonNull BooleanSetting setting, @NonNull Boolean newValue) {
+        setting.value = Objects.requireNonNull(newValue);
+    }
+
+    @Override
+    protected void load() {
+        value = preferences.getBoolean(key, defaultValue);
+    }
+
+    @Override
+    protected Boolean readFromJSON(JSONObject json, String importExportKey) throws JSONException {
+        return json.getBoolean(importExportKey);
+    }
+
+    @Override
+    protected void setValueFromString(@NonNull String newValue) {
+        value = Boolean.valueOf(Objects.requireNonNull(newValue));
+    }
+
+    @Override
+    public void save(@NonNull Boolean newValue) {
+        // Must set before saving to preferences (otherwise importing fails to update UI correctly).
+        value = Objects.requireNonNull(newValue);
+        preferences.saveBoolean(key, newValue);
+    }
+
+    @NonNull
+    @Override
+    public Boolean get() {
+        return value;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/EnumSetting.java

@@ -0,0 +1,117 @@
+package app.revanced.extension.shared.settings;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Locale;
+import java.util.Objects;
+
+import app.revanced.extension.shared.Logger;
+
+/**
+ * If an Enum value is removed or changed, any saved or imported data using the
+ * non-existent value will be reverted to the default value
+ * (the event is logged, but no user error is displayed).
+ *
+ * All saved JSON text is converted to lowercase to keep the output less obnoxious.
+ */
+@SuppressWarnings("unused")
+public class EnumSetting<T extends Enum<?>> extends Setting<T> {
+    public EnumSetting(String key, T defaultValue) {
+        super(key, defaultValue);
+    }
+    public EnumSetting(String key, T defaultValue, boolean rebootApp) {
+        super(key, defaultValue, rebootApp);
+    }
+    public EnumSetting(String key, T defaultValue, boolean rebootApp, boolean includeWithImportExport) {
+        super(key, defaultValue, rebootApp, includeWithImportExport);
+    }
+    public EnumSetting(String key, T defaultValue, String userDialogMessage) {
+        super(key, defaultValue, userDialogMessage);
+    }
+    public EnumSetting(String key, T defaultValue, Availability availability) {
+        super(key, defaultValue, availability);
+    }
+    public EnumSetting(String key, T defaultValue, boolean rebootApp, String userDialogMessage) {
+        super(key, defaultValue, rebootApp, userDialogMessage);
+    }
+    public EnumSetting(String key, T defaultValue, boolean rebootApp, Availability availability) {
+        super(key, defaultValue, rebootApp, availability);
+    }
+    public EnumSetting(String key, T defaultValue, boolean rebootApp, String userDialogMessage, Availability availability) {
+        super(key, defaultValue, rebootApp, userDialogMessage, availability);
+    }
+    public EnumSetting(@NonNull String key, @NonNull T defaultValue, boolean rebootApp, boolean includeWithImportExport, @Nullable String userDialogMessage, @Nullable Availability availability) {
+        super(key, defaultValue, rebootApp, includeWithImportExport, userDialogMessage, availability);
+    }
+
+    @Override
+    protected void load() {
+        value = preferences.getEnum(key, defaultValue);
+    }
+
+    @Override
+    protected T readFromJSON(JSONObject json, String importExportKey) throws JSONException {
+        String enumName = json.getString(importExportKey);
+        try {
+            return getEnumFromString(enumName);
+        } catch (IllegalArgumentException ex) {
+            // Info level to allow removing enum values in the future without showing any user errors.
+            Logger.printInfo(() -> "Using default, and ignoring unknown enum value: "  + enumName, ex);
+            return defaultValue;
+        }
+    }
+
+    @Override
+    protected void writeToJSON(JSONObject json, String importExportKey) throws JSONException {
+        // Use lowercase to keep the output less ugly.
+        json.put(importExportKey, value.name().toLowerCase(Locale.ENGLISH));
+    }
+
+    @NonNull
+    private T getEnumFromString(String enumName) {
+        //noinspection ConstantConditions
+        for (Enum<?> value : defaultValue.getClass().getEnumConstants()) {
+            if (value.name().equalsIgnoreCase(enumName)) {
+                // noinspection unchecked
+                return (T) value;
+            }
+        }
+        throw new IllegalArgumentException("Unknown enum value: " + enumName);
+    }
+
+    @Override
+    protected void setValueFromString(@NonNull String newValue) {
+        value = getEnumFromString(Objects.requireNonNull(newValue));
+    }
+
+    @Override
+    public void save(@NonNull T newValue) {
+        // Must set before saving to preferences (otherwise importing fails to update UI correctly).
+        value = Objects.requireNonNull(newValue);
+        preferences.saveEnumAsString(key, newValue);
+    }
+
+    @NonNull
+    @Override
+    public T get() {
+        return value;
+    }
+
+    /**
+     * Availability based on if this setting is currently set to any of the provided types.
+     */
+    @SafeVarargs
+    public final Setting.Availability availability(@NonNull T... types) {
+        return () -> {
+            T currentEnumType = get();
+            for (T enumType : types) {
+                if (currentEnumType == enumType) return true;
+            }
+            return false;
+        };
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/FloatSetting.java

@@ -0,0 +1,69 @@
+package app.revanced.extension.shared.settings;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Objects;
+
+@SuppressWarnings("unused")
+public class FloatSetting extends Setting<Float> {
+
+    public FloatSetting(String key, Float defaultValue) {
+        super(key, defaultValue);
+    }
+    public FloatSetting(String key, Float defaultValue, boolean rebootApp) {
+        super(key, defaultValue, rebootApp);
+    }
+    public FloatSetting(String key, Float defaultValue, boolean rebootApp, boolean includeWithImportExport) {
+        super(key, defaultValue, rebootApp, includeWithImportExport);
+    }
+    public FloatSetting(String key, Float defaultValue, String userDialogMessage) {
+        super(key, defaultValue, userDialogMessage);
+    }
+    public FloatSetting(String key, Float defaultValue, Availability availability) {
+        super(key, defaultValue, availability);
+    }
+    public FloatSetting(String key, Float defaultValue, boolean rebootApp, String userDialogMessage) {
+        super(key, defaultValue, rebootApp, userDialogMessage);
+    }
+    public FloatSetting(String key, Float defaultValue, boolean rebootApp, Availability availability) {
+        super(key, defaultValue, rebootApp, availability);
+    }
+    public FloatSetting(String key, Float defaultValue, boolean rebootApp, String userDialogMessage, Availability availability) {
+        super(key, defaultValue, rebootApp, userDialogMessage, availability);
+    }
+    public FloatSetting(@NonNull String key, @NonNull Float defaultValue, boolean rebootApp, boolean includeWithImportExport, @Nullable String userDialogMessage, @Nullable Availability availability) {
+        super(key, defaultValue, rebootApp, includeWithImportExport, userDialogMessage, availability);
+    }
+
+    @Override
+    protected void load() {
+        value = preferences.getFloatString(key, defaultValue);
+    }
+
+    @Override
+    protected Float readFromJSON(JSONObject json, String importExportKey) throws JSONException {
+        return (float) json.getDouble(importExportKey);
+    }
+
+    @Override
+    protected void setValueFromString(@NonNull String newValue) {
+        value = Float.valueOf(Objects.requireNonNull(newValue));
+    }
+
+    @Override
+    public void save(@NonNull Float newValue) {
+        // Must set before saving to preferences (otherwise importing fails to update UI correctly).
+        value = Objects.requireNonNull(newValue);
+        preferences.saveFloatString(key, newValue);
+    }
+
+    @NonNull
+    @Override
+    public Float get() {
+        return value;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/IntegerSetting.java

@@ -0,0 +1,69 @@
+package app.revanced.extension.shared.settings;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Objects;
+
+@SuppressWarnings("unused")
+public class IntegerSetting extends Setting<Integer> {
+
+    public IntegerSetting(String key, Integer defaultValue) {
+        super(key, defaultValue);
+    }
+    public IntegerSetting(String key, Integer defaultValue, boolean rebootApp) {
+        super(key, defaultValue, rebootApp);
+    }
+    public IntegerSetting(String key, Integer defaultValue, boolean rebootApp, boolean includeWithImportExport) {
+        super(key, defaultValue, rebootApp, includeWithImportExport);
+    }
+    public IntegerSetting(String key, Integer defaultValue, String userDialogMessage) {
+        super(key, defaultValue, userDialogMessage);
+    }
+    public IntegerSetting(String key, Integer defaultValue, Availability availability) {
+        super(key, defaultValue, availability);
+    }
+    public IntegerSetting(String key, Integer defaultValue, boolean rebootApp, String userDialogMessage) {
+        super(key, defaultValue, rebootApp, userDialogMessage);
+    }
+    public IntegerSetting(String key, Integer defaultValue, boolean rebootApp, Availability availability) {
+        super(key, defaultValue, rebootApp, availability);
+    }
+    public IntegerSetting(String key, Integer defaultValue, boolean rebootApp, String userDialogMessage, Availability availability) {
+        super(key, defaultValue, rebootApp, userDialogMessage, availability);
+    }
+    public IntegerSetting(@NonNull String key, @NonNull Integer defaultValue, boolean rebootApp, boolean includeWithImportExport, @Nullable String userDialogMessage, @Nullable Availability availability) {
+        super(key, defaultValue, rebootApp, includeWithImportExport, userDialogMessage, availability);
+    }
+
+    @Override
+    protected void load() {
+        value = preferences.getIntegerString(key, defaultValue);
+    }
+
+    @Override
+    protected Integer readFromJSON(JSONObject json, String importExportKey) throws JSONException {
+        return json.getInt(importExportKey);
+    }
+
+    @Override
+    protected void setValueFromString(@NonNull String newValue) {
+        value = Integer.valueOf(Objects.requireNonNull(newValue));
+    }
+
+    @Override
+    public void save(@NonNull Integer newValue) {
+        // Must set before saving to preferences (otherwise importing fails to update UI correctly).
+        value = Objects.requireNonNull(newValue);
+        preferences.saveIntegerString(key, newValue);
+    }
+
+    @NonNull
+    @Override
+    public Integer get() {
+        return value;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/LongSetting.java

@@ -0,0 +1,69 @@
+package app.revanced.extension.shared.settings;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Objects;
+
+@SuppressWarnings("unused")
+public class LongSetting extends Setting<Long> {
+
+    public LongSetting(String key, Long defaultValue) {
+        super(key, defaultValue);
+    }
+    public LongSetting(String key, Long defaultValue, boolean rebootApp) {
+        super(key, defaultValue, rebootApp);
+    }
+    public LongSetting(String key, Long defaultValue, boolean rebootApp, boolean includeWithImportExport) {
+        super(key, defaultValue, rebootApp, includeWithImportExport);
+    }
+    public LongSetting(String key, Long defaultValue, String userDialogMessage) {
+        super(key, defaultValue, userDialogMessage);
+    }
+    public LongSetting(String key, Long defaultValue, Availability availability) {
+        super(key, defaultValue, availability);
+    }
+    public LongSetting(String key, Long defaultValue, boolean rebootApp, String userDialogMessage) {
+        super(key, defaultValue, rebootApp, userDialogMessage);
+    }
+    public LongSetting(String key, Long defaultValue, boolean rebootApp, Availability availability) {
+        super(key, defaultValue, rebootApp, availability);
+    }
+    public LongSetting(String key, Long defaultValue, boolean rebootApp, String userDialogMessage, Availability availability) {
+        super(key, defaultValue, rebootApp, userDialogMessage, availability);
+    }
+    public LongSetting(@NonNull String key, @NonNull Long defaultValue, boolean rebootApp, boolean includeWithImportExport, @Nullable String userDialogMessage, @Nullable Availability availability) {
+        super(key, defaultValue, rebootApp, includeWithImportExport, userDialogMessage, availability);
+    }
+
+    @Override
+    protected void load() {
+        value = preferences.getLongString(key, defaultValue);
+    }
+
+    @Override
+    protected Long readFromJSON(JSONObject json, String importExportKey) throws JSONException {
+        return json.getLong(importExportKey);
+    }
+
+    @Override
+    protected void setValueFromString(@NonNull String newValue) {
+        value = Long.valueOf(Objects.requireNonNull(newValue));
+    }
+
+    @Override
+    public void save(@NonNull Long newValue) {
+        // Must set before saving to preferences (otherwise importing fails to update UI correctly).
+        value = Objects.requireNonNull(newValue);
+        preferences.saveLongString(key, newValue);
+    }
+
+    @NonNull
+    @Override
+    public Long get() {
+        return value;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/Setting.java

@@ -0,0 +1,459 @@
+package app.revanced.extension.shared.settings;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.StringRef;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.settings.preference.SharedPrefCategory;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.*;
+
+import static app.revanced.extension.shared.StringRef.str;
+
+@SuppressWarnings("unused")
+public abstract class Setting<T> {
+
+    /**
+     * Indicates if a {@link Setting} is available to edit and use.
+     * Typically this is dependent upon other BooleanSetting(s) set to 'true',
+     * but this can be used to call into extension code and check other conditions.
+     */
+    public interface Availability {
+        boolean isAvailable();
+    }
+
+    /**
+     * Availability based on a single parent setting being enabled.
+     */
+    @NonNull
+    public static Availability parent(@NonNull BooleanSetting parent) {
+        return parent::get;
+    }
+
+    /**
+     * Availability based on all parents being enabled.
+     */
+    @NonNull
+    public static Availability parentsAll(@NonNull BooleanSetting... parents) {
+        return () -> {
+            for (BooleanSetting parent : parents) {
+                if (!parent.get()) return false;
+            }
+            return true;
+        };
+    }
+
+    /**
+     * Availability based on any parent being enabled.
+     */
+    @NonNull
+    public static Availability parentsAny(@NonNull BooleanSetting... parents) {
+        return () -> {
+            for (BooleanSetting parent : parents) {
+                if (parent.get()) return true;
+            }
+            return false;
+        };
+    }
+
+    /**
+     * Callback for importing/exporting settings.
+     */
+    public interface ImportExportCallback {
+        /**
+         * Called after all settings have been imported.
+         */
+        void settingsImported(@Nullable Context context);
+
+        /**
+         * Called after all settings have been exported.
+         */
+        void settingsExported(@Nullable Context context);
+    }
+
+    private static final List<ImportExportCallback> importExportCallbacks = new ArrayList<>();
+
+    /**
+     * Adds a callback for {@link #importFromJSON(Context, String)} and {@link #exportToJson(Context)}.
+     */
+    public static void addImportExportCallback(@NonNull ImportExportCallback callback) {
+        importExportCallbacks.add(Objects.requireNonNull(callback));
+    }
+
+    /**
+     * All settings that were instantiated.
+     * When a new setting is created, it is automatically added to this list.
+     */
+    private static final List<Setting<?>> SETTINGS = new ArrayList<>();
+
+    /**
+     * Map of setting path to setting object.
+     */
+    private static final Map<String, Setting<?>> PATH_TO_SETTINGS = new HashMap<>();
+
+    /**
+     * Preference all instances are saved to.
+     */
+    public static final SharedPrefCategory preferences = new SharedPrefCategory("revanced_prefs");
+
+    @Nullable
+    public static Setting<?> getSettingFromPath(@NonNull String str) {
+        return PATH_TO_SETTINGS.get(str);
+    }
+
+    /**
+     * @return All settings that have been created.
+     */
+    @NonNull
+    public static List<Setting<?>> allLoadedSettings() {
+        return Collections.unmodifiableList(SETTINGS);
+    }
+
+    /**
+     * @return All settings that have been created, sorted by keys.
+     */
+    @NonNull
+    private static List<Setting<?>> allLoadedSettingsSorted() {
+        Collections.sort(SETTINGS, (Setting<?> o1, Setting<?> o2) -> o1.key.compareTo(o2.key));
+        return allLoadedSettings();
+    }
+
+    /**
+     * The key used to store the value in the shared preferences.
+     */
+    @NonNull
+    public final String key;
+
+    /**
+     * The default value of the setting.
+     */
+    @NonNull
+    public final T defaultValue;
+
+    /**
+     * If the app should be rebooted, if this setting is changed
+     */
+    public final boolean rebootApp;
+
+    /**
+     * If this setting should be included when importing/exporting settings.
+     */
+    public final boolean includeWithImportExport;
+
+    /**
+     * If this setting is available to edit and use.
+     * Not to be confused with it's status returned from {@link #get()}.
+     */
+    @Nullable
+    private final Availability availability;
+
+    /**
+     * Confirmation message to display, if the user tries to change the setting from the default value.
+     * Currently this works only for Boolean setting types.
+     */
+    @Nullable
+    public final StringRef userDialogMessage;
+
+    // Must be volatile, as some settings are read/write from different threads.
+    // Of note, the object value is persistently stored using SharedPreferences (which is thread safe).
+    /**
+     * The value of the setting.
+     */
+    @NonNull
+    protected volatile T value;
+
+    public Setting(String key, T defaultValue) {
+        this(key, defaultValue, false, true, null, null);
+    }
+    public Setting(String key, T defaultValue, boolean rebootApp) {
+        this(key, defaultValue, rebootApp, true, null, null);
+    }
+    public Setting(String key, T defaultValue, boolean rebootApp, boolean includeWithImportExport) {
+        this(key, defaultValue, rebootApp, includeWithImportExport, null, null);
+    }
+    public Setting(String key, T defaultValue, String userDialogMessage) {
+        this(key, defaultValue, false, true, userDialogMessage, null);
+    }
+    public Setting(String key, T defaultValue, Availability availability) {
+        this(key, defaultValue, false, true, null, availability);
+    }
+    public Setting(String key, T defaultValue, boolean rebootApp, String userDialogMessage) {
+        this(key, defaultValue, rebootApp, true, userDialogMessage, null);
+    }
+    public Setting(String key, T defaultValue, boolean rebootApp, Availability availability) {
+        this(key, defaultValue, rebootApp, true, null, availability);
+    }
+    public Setting(String key, T defaultValue, boolean rebootApp, String userDialogMessage, Availability availability) {
+        this(key, defaultValue, rebootApp, true, userDialogMessage, availability);
+    }
+
+    /**
+     * A setting backed by a shared preference.
+     *
+     * @param key                     The key used to store the value in the shared preferences.
+     * @param defaultValue            The default value of the setting.
+     * @param rebootApp               If the app should be rebooted, if this setting is changed.
+     * @param includeWithImportExport If this setting should be shown in the import/export dialog.
+     * @param userDialogMessage       Confirmation message to display, if the user tries to change the setting from the default value.
+     * @param availability            Condition that must be true, for this setting to be available to configure.
+     */
+    public Setting(@NonNull String key,
+                   @NonNull T defaultValue,
+                   boolean rebootApp,
+                   boolean includeWithImportExport,
+                   @Nullable String userDialogMessage,
+                   @Nullable Availability availability
+    ) {
+        this.key = Objects.requireNonNull(key);
+        this.value = this.defaultValue = Objects.requireNonNull(defaultValue);
+        this.rebootApp = rebootApp;
+        this.includeWithImportExport = includeWithImportExport;
+        this.userDialogMessage = (userDialogMessage == null) ? null : new StringRef(userDialogMessage);
+        this.availability = availability;
+
+        SETTINGS.add(this);
+        if (PATH_TO_SETTINGS.put(key, this) != null) {
+            // Debug setting may not be created yet so using Logger may cause an initialization crash.
+            // Show a toast instead.
+            Utils.showToastLong(this.getClass().getSimpleName()
+                    + " error: Duplicate Setting key found: " + key);
+        }
+
+        load();
+    }
+
+    /**
+     * Migrate a setting value if the path is renamed but otherwise the old and new settings are identical.
+     */
+    public static <T> void migrateOldSettingToNew(@NonNull Setting<T> oldSetting, @NonNull Setting<T> newSetting) {
+        if (oldSetting == newSetting) throw new IllegalArgumentException();
+
+        if (!oldSetting.isSetToDefault()) {
+            Logger.printInfo(() -> "Migrating old setting value: " + oldSetting + " into replacement setting: " + newSetting);
+            newSetting.save(oldSetting.value);
+            oldSetting.resetToDefault();
+        }
+    }
+
+    /**
+     * Migrate an old Setting value previously stored in a different SharedPreference.
+     *
+     * This method will be deleted in the future.
+     */
+    public static void migrateFromOldPreferences(@NonNull SharedPrefCategory oldPrefs, @NonNull Setting setting, String settingKey) {
+        if (!oldPrefs.preferences.contains(settingKey)) {
+            return; // Nothing to do.
+        }
+
+        Object newValue = setting.get();
+        final Object migratedValue;
+        if (setting instanceof BooleanSetting) {
+            migratedValue = oldPrefs.getBoolean(settingKey, (Boolean) newValue);
+        } else if (setting instanceof IntegerSetting) {
+            migratedValue = oldPrefs.getIntegerString(settingKey, (Integer) newValue);
+        } else if (setting instanceof LongSetting) {
+            migratedValue = oldPrefs.getLongString(settingKey, (Long) newValue);
+        } else if (setting instanceof FloatSetting) {
+            migratedValue = oldPrefs.getFloatString(settingKey, (Float) newValue);
+        } else if (setting instanceof StringSetting) {
+            migratedValue = oldPrefs.getString(settingKey, (String) newValue);
+        } else {
+            Logger.printException(() -> "Unknown setting: " + setting);
+            // Remove otherwise it'll show a toast on every launch
+            oldPrefs.preferences.edit().remove(settingKey).apply();
+            return;
+        }
+
+        oldPrefs.preferences.edit().remove(settingKey).apply(); // Remove the old setting.
+        if (migratedValue.equals(newValue)) {
+            Logger.printDebug(() -> "Value does not need migrating: " + settingKey);
+            return; // Old value is already equal to the new setting value.
+        }
+
+        Logger.printDebug(() -> "Migrating old preference value into current preference: " + settingKey);
+        //noinspection unchecked
+        setting.save(migratedValue);
+    }
+
+    /**
+     * Sets, but does _not_ persistently save the value.
+     * This method is only to be used by the Settings preference code.
+     *
+     * This intentionally is a static method to deter
+     * accidental usage when {@link #save(Object)} was intended.
+     */
+    public static void privateSetValueFromString(@NonNull Setting<?> setting, @NonNull String newValue) {
+        setting.setValueFromString(newValue);
+    }
+
+    /**
+     * Sets the value of {@link #value}, but do not save to {@link #preferences}.
+     */
+    protected abstract void setValueFromString(@NonNull String newValue);
+
+    /**
+     * Load and set the value of {@link #value}.
+     */
+    protected abstract void load();
+
+    /**
+     * Persistently saves the value.
+     */
+    public abstract void save(@NonNull T newValue);
+
+    @NonNull
+    public abstract T get();
+
+    /**
+     * Identical to calling {@link #save(Object)} using {@link #defaultValue}.
+     */
+    public void resetToDefault() {
+        save(defaultValue);
+    }
+
+    /**
+     * @return if this setting can be configured and used.
+     */
+    public boolean isAvailable() {
+        return availability == null || availability.isAvailable();
+    }
+
+    /**
+     * @return if the currently set value is the same as {@link #defaultValue}
+     */
+    public boolean isSetToDefault() {
+        return value.equals(defaultValue);
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return key + "=" + get();
+    }
+
+    // region Import / export
+
+    /**
+     * If a setting path has this prefix, then remove it before importing/exporting.
+     */
+    private static final String OPTIONAL_REVANCED_SETTINGS_PREFIX = "revanced_";
+
+    /**
+     * The path, minus any 'revanced' prefix to keep json concise.
+     */
+    private String getImportExportKey() {
+        if (key.startsWith(OPTIONAL_REVANCED_SETTINGS_PREFIX)) {
+            return key.substring(OPTIONAL_REVANCED_SETTINGS_PREFIX.length());
+        }
+        return key;
+    }
+
+    /**
+     * @param importExportKey The JSON key. The JSONObject parameter will contain data for this key.
+     * @return the value stored using the import/export key.  Do not set any values in this method.
+     */
+    protected abstract T readFromJSON(JSONObject json, String importExportKey) throws JSONException;
+
+    /**
+     * Saves this instance to JSON.
+     * <p>
+     * To keep the JSON simple and readable,
+     * subclasses should not write out any embedded types (such as JSON Array or Dictionaries).
+     * <p>
+     * If this instance is not a type supported natively by JSON (ie: it's not a String/Integer/Float/Long),
+     * then subclasses can override this method and write out a String value representing the value.
+     */
+    protected void writeToJSON(JSONObject json, String importExportKey) throws JSONException {
+        json.put(importExportKey, value);
+    }
+
+    @NonNull
+    public static String exportToJson(@Nullable Context alertDialogContext) {
+        try {
+            JSONObject json = new JSONObject();
+            for (Setting<?> setting : allLoadedSettingsSorted()) {
+                String importExportKey = setting.getImportExportKey();
+                if (json.has(importExportKey)) {
+                    throw new IllegalArgumentException("duplicate key found: " + importExportKey);
+                }
+
+                final boolean exportDefaultValues = false; // Enable to see what all settings looks like in the UI.
+                //noinspection ConstantValue
+                if (setting.includeWithImportExport && (!setting.isSetToDefault() || exportDefaultValues)) {
+                    setting.writeToJSON(json, importExportKey);
+                }
+            }
+
+            for (ImportExportCallback callback : importExportCallbacks) {
+                callback.settingsExported(alertDialogContext);
+            }
+
+            if (json.length() == 0) {
+                return "";
+            }
+
+            String export = json.toString(0);
+
+            // Remove the outer JSON braces to make the output more compact,
+            // and leave less chance of the user forgetting to copy it
+            return export.substring(2, export.length() - 2);
+        } catch (JSONException e) {
+            Logger.printException(() -> "Export failure", e); // should never happen
+            return "";
+        }
+    }
+
+    /**
+     * @return if any settings that require a reboot were changed.
+     */
+    public static boolean importFromJSON(@NonNull Context alertDialogContext, @NonNull String settingsJsonString) {
+        try {
+            if (!settingsJsonString.matches("[\\s\\S]*\\{")) {
+                settingsJsonString = '{' + settingsJsonString + '}'; // Restore outer JSON braces
+            }
+            JSONObject json = new JSONObject(settingsJsonString);
+
+            boolean rebootSettingChanged = false;
+            int numberOfSettingsImported = 0;
+            for (Setting setting : SETTINGS) {
+                String key = setting.getImportExportKey();
+                if (json.has(key)) {
+                    Object value = setting.readFromJSON(json, key);
+                    if (!setting.get().equals(value)) {
+                        rebootSettingChanged |= setting.rebootApp;
+                        //noinspection unchecked
+                        setting.save(value);
+                    }
+                    numberOfSettingsImported++;
+                } else if (setting.includeWithImportExport && !setting.isSetToDefault()) {
+                    Logger.printDebug(() -> "Resetting to default: " + setting);
+                    rebootSettingChanged |= setting.rebootApp;
+                    setting.resetToDefault();
+                }
+            }
+
+            for (ImportExportCallback callback : importExportCallbacks) {
+                callback.settingsImported(alertDialogContext);
+            }
+
+            Utils.showToastLong(numberOfSettingsImported == 0
+                    ? str("revanced_settings_import_reset")
+                    : str("revanced_settings_import_success", numberOfSettingsImported));
+
+            return rebootSettingChanged;
+        } catch (JSONException | IllegalArgumentException ex) {
+            Utils.showToastLong(str("revanced_settings_import_failure_parse", ex.getMessage()));
+            Logger.printInfo(() -> "", ex);
+        } catch (Exception ex) {
+            Logger.printException(() -> "Import failure: " + ex.getMessage(), ex); // should never happen
+        }
+        return false;
+    }
+
+    // End import / export
+
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/StringSetting.java

@@ -0,0 +1,69 @@
+package app.revanced.extension.shared.settings;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Objects;
+
+@SuppressWarnings("unused")
+public class StringSetting extends Setting<String> {
+
+    public StringSetting(String key, String defaultValue) {
+        super(key, defaultValue);
+    }
+    public StringSetting(String key, String defaultValue, boolean rebootApp) {
+        super(key, defaultValue, rebootApp);
+    }
+    public StringSetting(String key, String defaultValue, boolean rebootApp, boolean includeWithImportExport) {
+        super(key, defaultValue, rebootApp, includeWithImportExport);
+    }
+    public StringSetting(String key, String defaultValue, String userDialogMessage) {
+        super(key, defaultValue, userDialogMessage);
+    }
+    public StringSetting(String key, String defaultValue, Availability availability) {
+        super(key, defaultValue, availability);
+    }
+    public StringSetting(String key, String defaultValue, boolean rebootApp, String userDialogMessage) {
+        super(key, defaultValue, rebootApp, userDialogMessage);
+    }
+    public StringSetting(String key, String defaultValue, boolean rebootApp, Availability availability) {
+        super(key, defaultValue, rebootApp, availability);
+    }
+    public StringSetting(String key, String defaultValue, boolean rebootApp, String userDialogMessage, Availability availability) {
+        super(key, defaultValue, rebootApp, userDialogMessage, availability);
+    }
+    public StringSetting(@NonNull String key, @NonNull String defaultValue, boolean rebootApp, boolean includeWithImportExport, @Nullable String userDialogMessage, @Nullable Availability availability) {
+        super(key, defaultValue, rebootApp, includeWithImportExport, userDialogMessage, availability);
+    }
+
+    @Override
+    protected void load() {
+        value = preferences.getString(key, defaultValue);
+    }
+
+    @Override
+    protected String readFromJSON(JSONObject json, String importExportKey) throws JSONException {
+        return json.getString(importExportKey);
+    }
+
+    @Override
+    protected void setValueFromString(@NonNull String newValue) {
+        value = Objects.requireNonNull(newValue);
+    }
+
+    @Override
+    public void save(@NonNull String newValue) {
+        // Must set before saving to preferences (otherwise importing fails to update UI correctly).
+        value = Objects.requireNonNull(newValue);
+        preferences.saveString(key, newValue);
+    }
+
+    @NonNull
+    @Override
+    public String get() {
+        return value;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/preference/AbstractPreferenceFragment.java

@@ -0,0 +1,280 @@
+package app.revanced.extension.shared.settings.preference;
+
+import static app.revanced.extension.shared.StringRef.str;
+
+import android.annotation.SuppressLint;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.*;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.util.Objects;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.settings.BaseSettings;
+import app.revanced.extension.shared.settings.BooleanSetting;
+import app.revanced.extension.shared.settings.Setting;
+
+@SuppressWarnings("deprecation")
+public abstract class AbstractPreferenceFragment extends PreferenceFragment {
+    /**
+     * Indicates that if a preference changes,
+     * to apply the change from the Setting to the UI component.
+     */
+    public static boolean settingImportInProgress;
+
+    /**
+     * Confirm and restart dialog button text and title.
+     * Set by subclasses if Strings cannot be added as a resource.
+     */
+    @Nullable
+    protected static String restartDialogButtonText, restartDialogTitle, confirmDialogTitle;
+
+    /**
+     * Used to prevent showing reboot dialog, if user cancels a setting user dialog.
+     */
+    private boolean showingUserDialogMessage;
+
+    private final SharedPreferences.OnSharedPreferenceChangeListener listener = (sharedPreferences, str) -> {
+        try {
+            Setting<?> setting = Setting.getSettingFromPath(str);
+            if (setting == null) {
+                return;
+            }
+            Preference pref = findPreference(str);
+            if (pref == null) {
+                return;
+            }
+            Logger.printDebug(() -> "Preference changed: " + setting.key);
+
+            // Apply 'Setting <- Preference', unless during importing when it needs to be 'Setting -> Preference'.
+            updatePreference(pref, setting, true, settingImportInProgress);
+            // Update any other preference availability that may now be different.
+            updateUIAvailability();
+
+            if (settingImportInProgress) {
+                return;
+            }
+
+            if (!showingUserDialogMessage) {
+                if (setting.userDialogMessage != null && ((SwitchPreference) pref).isChecked() != (Boolean) setting.defaultValue) {
+                    showSettingUserDialogConfirmation((SwitchPreference) pref, (BooleanSetting) setting);
+                } else if (setting.rebootApp) {
+                    showRestartDialog(getContext());
+                }
+            }
+
+        } catch (Exception ex) {
+            Logger.printException(() -> "OnSharedPreferenceChangeListener failure", ex);
+        }
+    };
+
+
+    /**
+     * Initialize this instance, and do any custom behavior.
+     * <p>
+     * To ensure all {@link Setting} instances are correctly synced to the UI,
+     * it is important that subclasses make a call or otherwise reference their Settings class bundle
+     * so all app specific {@link Setting} instances are loaded before this method returns.
+     */
+    protected void initialize() {
+        final var identifier = Utils.getResourceIdentifier("revanced_prefs", "xml");
+        if (identifier == 0) return;
+        addPreferencesFromResource(identifier);
+
+        PreferenceScreen screen = getPreferenceScreen();
+        Utils.sortPreferenceGroups(screen);
+        Utils.setPreferenceTitlesToMultiLineIfNeeded(screen);
+    }
+
+    private void showSettingUserDialogConfirmation(SwitchPreference switchPref, BooleanSetting setting) {
+        Utils.verifyOnMainThread();
+
+        final var context = getContext();
+        if (confirmDialogTitle == null) {
+            confirmDialogTitle = str("revanced_settings_confirm_user_dialog_title");
+        }
+        showingUserDialogMessage = true;
+        new AlertDialog.Builder(context)
+                .setTitle(confirmDialogTitle)
+                .setMessage(Objects.requireNonNull(setting.userDialogMessage).toString())
+                .setPositiveButton(android.R.string.ok, (dialog, id) -> {
+                    if (setting.rebootApp) {
+                        showRestartDialog(context);
+                    }
+                })
+                .setNegativeButton(android.R.string.cancel, (dialog, id) -> {
+                    switchPref.setChecked(setting.defaultValue); // Recursive call that resets the Setting value.
+                })
+                .setOnDismissListener(dialog -> {
+                    showingUserDialogMessage = false;
+                })
+                .setCancelable(false)
+                .show();
+    }
+
+    /**
+     * Updates all Preferences values and their availability using the current values in {@link Setting}.
+     */
+    protected void updateUIToSettingValues() {
+        updatePreferenceScreen(getPreferenceScreen(), true,true);
+    }
+
+    /**
+     * Updates Preferences availability only using the status of {@link Setting}.
+     */
+    protected void updateUIAvailability() {
+        updatePreferenceScreen(getPreferenceScreen(), false, false);
+    }
+
+    /**
+     * Syncs all UI Preferences to any {@link Setting} they represent.
+     */
+    private void updatePreferenceScreen(@NonNull PreferenceScreen screen,
+                                        boolean syncSettingValue,
+                                        boolean applySettingToPreference) {
+        // Alternatively this could iterate thru all Settings and check for any matching Preferences,
+        // but there are many more Settings than UI preferences so it's more efficient to only check
+        // the Preferences.
+        for (int i = 0, prefCount = screen.getPreferenceCount(); i < prefCount; i++) {
+            Preference pref = screen.getPreference(i);
+            if (pref instanceof PreferenceScreen) {
+                updatePreferenceScreen((PreferenceScreen) pref, syncSettingValue, applySettingToPreference);
+            } else if (pref.hasKey()) {
+                String key = pref.getKey();
+                Setting<?> setting = Setting.getSettingFromPath(key);
+
+                if (setting != null) {
+                    updatePreference(pref, setting, syncSettingValue, applySettingToPreference);
+                } else if (BaseSettings.DEBUG.get() && (pref instanceof SwitchPreference
+                        || pref instanceof EditTextPreference || pref instanceof ListPreference)) {
+                    // Probably a typo in the patches preference declaration.
+                    Logger.printException(() -> "Preference key has no setting: " + key);
+                }
+            }
+        }
+    }
+
+    /**
+     * Handles syncing a UI Preference with the {@link Setting} that backs it.
+     * If needed, subclasses can override this to handle additional UI Preference types.
+     *
+     * @param applySettingToPreference If true, then apply {@link Setting} -> Preference.
+     *                                 If false, then apply {@link Setting} <- Preference.
+     */
+    protected void syncSettingWithPreference(@NonNull Preference pref,
+                                             @NonNull Setting<?> setting,
+                                             boolean applySettingToPreference) {
+        if (pref instanceof SwitchPreference) {
+            SwitchPreference switchPref = (SwitchPreference) pref;
+            BooleanSetting boolSetting = (BooleanSetting) setting;
+            if (applySettingToPreference) {
+                switchPref.setChecked(boolSetting.get());
+            } else {
+                BooleanSetting.privateSetValue(boolSetting, switchPref.isChecked());
+            }
+        } else if (pref instanceof EditTextPreference) {
+            EditTextPreference editPreference = (EditTextPreference) pref;
+            if (applySettingToPreference) {
+                editPreference.setText(setting.get().toString());
+            } else {
+                Setting.privateSetValueFromString(setting, editPreference.getText());
+            }
+        } else if (pref instanceof ListPreference) {
+            ListPreference listPref = (ListPreference) pref;
+            if (applySettingToPreference) {
+                listPref.setValue(setting.get().toString());
+            } else {
+                Setting.privateSetValueFromString(setting, listPref.getValue());
+            }
+            updateListPreferenceSummary(listPref, setting);
+        } else {
+            Logger.printException(() -> "Setting cannot be handled: " + pref.getClass() + ": " + pref);
+        }
+    }
+
+    /**
+     * Updates a UI Preference with the {@link Setting} that backs it.
+     *
+     * @param syncSetting If the UI should be synced {@link Setting} <-> Preference
+     * @param applySettingToPreference If true, then apply {@link Setting} -> Preference.
+     *                                 If false, then apply {@link Setting} <- Preference.
+     */
+    private void updatePreference(@NonNull Preference pref, @NonNull Setting<?> setting,
+                                  boolean syncSetting, boolean applySettingToPreference) {
+        if (!syncSetting && applySettingToPreference) {
+            throw new IllegalArgumentException();
+        }
+
+        if (syncSetting) {
+            syncSettingWithPreference(pref, setting, applySettingToPreference);
+        }
+
+        updatePreferenceAvailability(pref, setting);
+    }
+
+    protected void updatePreferenceAvailability(@NonNull Preference pref, @NonNull Setting<?> setting) {
+        pref.setEnabled(setting.isAvailable());
+    }
+
+    protected void updateListPreferenceSummary(ListPreference listPreference, Setting<?> setting) {
+        String objectStringValue = setting.get().toString();
+        final int entryIndex = listPreference.findIndexOfValue(objectStringValue);
+        if (entryIndex >= 0) {
+            listPreference.setSummary(listPreference.getEntries()[entryIndex]);
+        } else {
+            // Value is not an available option.
+            // User manually edited import data, or options changed and current selection is no longer available.
+            // Still show the value in the summary, so it's clear that something is selected.
+            listPreference.setSummary(objectStringValue);
+        }
+    }
+
+    public static void showRestartDialog(@NonNull final Context context) {
+        Utils.verifyOnMainThread();
+        if (restartDialogTitle == null) {
+            restartDialogTitle = str("revanced_settings_restart_title");
+        }
+        if (restartDialogButtonText == null) {
+            restartDialogButtonText = str("revanced_settings_restart");
+        }
+        new AlertDialog.Builder(context)
+                .setMessage(restartDialogTitle)
+                .setPositiveButton(restartDialogButtonText, (dialog, id)
+                        -> Utils.restartApp(context))
+                .setNegativeButton(android.R.string.cancel, null)
+                .setCancelable(false)
+                .show();
+    }
+
+    @SuppressLint("ResourceType")
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        try {
+            PreferenceManager preferenceManager = getPreferenceManager();
+            preferenceManager.setSharedPreferencesName(Setting.preferences.name);
+
+            // Must initialize before adding change listener,
+            // otherwise the syncing of Setting -> UI
+            // causes a callback to the listener even though nothing changed.
+            initialize();
+            updateUIToSettingValues();
+
+            preferenceManager.getSharedPreferences().registerOnSharedPreferenceChangeListener(listener);
+        } catch (Exception ex) {
+            Logger.printException(() -> "onCreate() failure", ex);
+        }
+    }
+
+    @Override
+    public void onDestroy() {
+        getPreferenceManager().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(listener);
+        super.onDestroy();
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/preference/ImportExportPreference.java

@@ -0,0 +1,100 @@
+package app.revanced.extension.shared.settings.preference;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.os.Build;
+import android.preference.EditTextPreference;
+import android.preference.Preference;
+import android.text.InputType;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import android.widget.EditText;
+import app.revanced.extension.shared.settings.Setting;
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+
+import static app.revanced.extension.shared.StringRef.str;
+
+@SuppressWarnings({"unused", "deprecation"})
+public class ImportExportPreference extends EditTextPreference implements Preference.OnPreferenceClickListener {
+
+    private String existingSettings;
+
+    private void init() {
+        setSelectable(true);
+
+        EditText editText = getEditText();
+        editText.setTextIsSelectable(true);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            editText.setAutofillHints((String) null);
+        }
+        editText.setInputType(editText.getInputType() | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);
+        editText.setTextSize(TypedValue.COMPLEX_UNIT_PT, 7); // Use a smaller font to reduce text wrap.
+
+        setOnPreferenceClickListener(this);
+    }
+
+    public ImportExportPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+        init();
+    }
+    public ImportExportPreference(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init();
+    }
+    public ImportExportPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+    public ImportExportPreference(Context context) {
+        super(context);
+        init();
+    }
+
+    @Override
+    public boolean onPreferenceClick(Preference preference) {
+        try {
+            // Must set text before preparing dialog, otherwise text is non selectable if this preference is later reopened.
+            existingSettings = Setting.exportToJson(getContext());
+            getEditText().setText(existingSettings);
+        } catch (Exception ex) {
+            Logger.printException(() -> "showDialog failure", ex);
+        }
+        return true;
+    }
+
+    @Override
+    protected void onPrepareDialogBuilder(AlertDialog.Builder builder) {
+        try {
+            Utils.setEditTextDialogTheme(builder);
+
+            // Show the user the settings in JSON format.
+            builder.setNeutralButton(str("revanced_settings_import_copy"), (dialog, which) -> {
+                Utils.setClipboard(getEditText().getText().toString());
+            }).setPositiveButton(str("revanced_settings_import"), (dialog, which) -> {
+                importSettings(builder.getContext(), getEditText().getText().toString());
+            });
+        } catch (Exception ex) {
+            Logger.printException(() -> "onPrepareDialogBuilder failure", ex);
+        }
+    }
+
+    private void importSettings(Context context, String replacementSettings) {
+        try {
+            if (replacementSettings.equals(existingSettings)) {
+                return;
+            }
+            AbstractPreferenceFragment.settingImportInProgress = true;
+
+            final boolean rebootNeeded = Setting.importFromJSON(context, replacementSettings);
+            if (rebootNeeded) {
+                AbstractPreferenceFragment.showRestartDialog(getContext());
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "importSettings failure", ex);
+        } finally {
+            AbstractPreferenceFragment.settingImportInProgress = false;
+        }
+    }
+
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/preference/ReVancedAboutPreference.java

@@ -0,0 +1,359 @@
+package app.revanced.extension.shared.settings.preference;
+
+import static app.revanced.extension.shared.StringRef.str;
+import static app.revanced.extension.shared.requests.Route.Method.GET;
+
+import android.annotation.SuppressLint;
+import android.app.Dialog;
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.graphics.Color;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.preference.Preference;
+import android.util.AttributeSet;
+import android.view.Window;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.net.HttpURLConnection;
+import java.net.SocketTimeoutException;
+import java.util.ArrayList;
+import java.util.List;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.requests.Requester;
+import app.revanced.extension.shared.requests.Route;
+
+/**
+ * Opens a dialog showing official links.
+ */
+@SuppressWarnings({"unused", "deprecation"})
+public class ReVancedAboutPreference extends Preference {
+
+    private static String useNonBreakingHyphens(String text) {
+        // Replace any dashes with non breaking dashes, so the English text 'pre-release'
+        // and the dev release number does not break and cover two lines.
+        return text.replace("-", "‑"); // #8209 = non breaking hyphen.
+    }
+
+    private static String getColorHexString(int color) {
+        return String.format("#%06X", (0x00FFFFFF & color));
+    }
+
+    protected boolean isDarkModeEnabled() {
+        return Utils.isDarkModeEnabled(getContext());
+    }
+
+    /**
+     * Subclasses can override this and provide a themed color.
+     */
+    protected int getLightColor() {
+        return Color.WHITE;
+    }
+
+    /**
+     * Subclasses can override this and provide a themed color.
+     */
+    protected int getDarkColor() {
+        return Color.BLACK;
+    }
+
+    /**
+     * Apps that do not support bundling resources must override this.
+     *
+     * @return A localized string to display for the key.
+     */
+    protected String getString(String key, Object ... args) {
+        return str(key, args);
+    }
+
+    private String createDialogHtml(WebLink[] aboutLinks) {
+        final boolean isNetworkConnected = Utils.isNetworkConnected();
+
+        StringBuilder builder = new StringBuilder();
+        builder.append("<html>");
+        builder.append("<body style=\"text-align: center; padding: 10px;\">");
+
+        final boolean isDarkMode = isDarkModeEnabled();
+        String backgroundColorHex = getColorHexString(isDarkMode ? getDarkColor() : getLightColor());
+        String foregroundColorHex = getColorHexString(isDarkMode ? getLightColor() : getDarkColor());
+        // Apply light/dark mode colors.
+        builder.append(String.format(
+                "<style> body { background-color: %s; color: %s; } a { color: %s; } </style>",
+                backgroundColorHex, foregroundColorHex, foregroundColorHex));
+
+        if (isNetworkConnected) {
+            builder.append("<img style=\"width: 100px; height: 100px;\" "
+                    // Hide the image if it does not load.
+                    + "onerror=\"this.style.display='none';\" "
+                    + "src=\"").append(AboutLinksRoutes.aboutLogoUrl).append("\" />");
+        }
+
+        String patchesVersion = Utils.getPatchesReleaseVersion();
+
+        // Add the title.
+        builder.append("<h1>")
+                .append("ReVanced")
+                .append("</h1>");
+
+        builder.append("<p>")
+                // Replace hyphens with non breaking dashes so the version number does not break lines.
+                .append(useNonBreakingHyphens(getString("revanced_settings_about_links_body", patchesVersion)))
+                .append("</p>");
+
+        // Add a disclaimer if using a dev release.
+        if (patchesVersion.contains("dev")) {
+            builder.append("<h3>")
+                    // English text 'Pre-release' can break lines.
+                    .append(useNonBreakingHyphens(getString("revanced_settings_about_links_dev_header")))
+                    .append("</h3>");
+
+            builder.append("<p>")
+                    .append(getString("revanced_settings_about_links_dev_body"))
+                    .append("</p>");
+        }
+
+        builder.append("<h2 style=\"margin-top: 30px;\">")
+                .append(getString("revanced_settings_about_links_header"))
+                .append("</h2>");
+
+        builder.append("<div>");
+        for (WebLink link : aboutLinks) {
+            builder.append("<div style=\"margin-bottom: 20px;\">");
+            builder.append(String.format("<a href=\"%s\">%s</a>", link.url, link.name));
+            builder.append("</div>");
+        }
+        builder.append("</div>");
+
+        builder.append("</body></html>");
+        return builder.toString();
+    }
+
+    {
+        setOnPreferenceClickListener(pref -> {
+            // Show a progress spinner if the social links are not fetched yet.
+            if (!AboutLinksRoutes.hasFetchedLinks() && Utils.isNetworkConnected()) {
+                // Show a progress spinner, but only if the api fetch takes more than a half a second.
+                final long delayToShowProgressSpinner = 500;
+                ProgressDialog progress = new ProgressDialog(getContext());
+                progress.setProgressStyle(ProgressDialog.STYLE_SPINNER);
+
+                Handler handler = new Handler(Looper.getMainLooper());
+                Runnable showDialogRunnable = progress::show;
+                handler.postDelayed(showDialogRunnable, delayToShowProgressSpinner);
+
+                Utils.runOnBackgroundThread(() ->
+                        fetchLinksAndShowDialog(handler, showDialogRunnable, progress));
+            } else {
+                // No network call required and can run now.
+                fetchLinksAndShowDialog(null, null, null);
+            }
+
+            return false;
+        });
+    }
+
+    private void fetchLinksAndShowDialog(@Nullable Handler handler,
+                                         Runnable showDialogRunnable,
+                                         @Nullable ProgressDialog progress) {
+        WebLink[] links = AboutLinksRoutes.fetchAboutLinks();
+        String htmlDialog = createDialogHtml(links);
+
+        // Enable to randomly force a delay to debug the spinner logic.
+        final boolean debugSpinnerDelayLogic = false;
+        //noinspection ConstantConditions
+        if (debugSpinnerDelayLogic && handler != null && Math.random() < 0.5f) {
+            Utils.doNothingForDuration((long) (Math.random() * 4000));
+        }
+
+        Utils.runOnMainThreadNowOrLater(() -> {
+            if (handler != null) {
+                handler.removeCallbacks(showDialogRunnable);
+            }
+            if (progress != null) {
+                progress.dismiss();
+            }
+            new WebViewDialog(getContext(), htmlDialog).show();
+        });
+    }
+
+    public ReVancedAboutPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+    public ReVancedAboutPreference(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+    public ReVancedAboutPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+    public ReVancedAboutPreference(Context context) {
+        super(context);
+    }
+}
+
+/**
+ * Displays html content as a dialog. Any links a user taps on are opened in an external browser.
+ */
+class WebViewDialog extends Dialog {
+
+    private final String htmlContent;
+
+    public WebViewDialog(@NonNull Context context, @NonNull String htmlContent) {
+        super(context);
+        this.htmlContent = htmlContent;
+    }
+
+    // JS required to hide any broken images. No remote javascript is ever loaded.
+    @SuppressLint("SetJavaScriptEnabled")
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+
+        WebView webView = new WebView(getContext());
+        webView.getSettings().setJavaScriptEnabled(true);
+        webView.setWebViewClient(new OpenLinksExternallyWebClient());
+        webView.loadDataWithBaseURL(null, htmlContent, "text/html", "utf-8", null);
+
+        setContentView(webView);
+    }
+
+    private class OpenLinksExternallyWebClient extends WebViewClient {
+        @Override
+        public boolean shouldOverrideUrlLoading(WebView view, String url) {
+            try {
+                Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
+                getContext().startActivity(intent);
+            } catch (Exception ex) {
+                Logger.printException(() -> "Open link failure", ex);
+            }
+            // Dismiss the about dialog using a delay,
+            // otherwise without a delay the UI looks hectic with the dialog dismissing
+            // to show the settings while simultaneously a web browser is opening.
+            Utils.runOnMainThreadDelayed(WebViewDialog.this::dismiss, 500);
+            return true;
+        }
+    }
+}
+
+class WebLink {
+    final boolean preferred;
+    String name;
+    final String url;
+
+    WebLink(JSONObject json) throws JSONException {
+        this(json.getBoolean("preferred"),
+                json.getString("name"),
+                json.getString("url")
+        );
+    }
+
+    WebLink(boolean preferred, String name, String url) {
+        this.preferred = preferred;
+        this.name = name;
+        this.url = url;
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return "WebLink{" +
+                "preferred=" + preferred +
+                ", name='" + name + '\'' +
+                ", url='" + url + '\'' +
+                '}';
+    }
+}
+
+class AboutLinksRoutes {
+    /**
+     * Backup icon url if the API call fails.
+     */
+    public static volatile String aboutLogoUrl = "https://revanced.app/favicon.ico";
+
+    /**
+     * Links to use if fetch links api call fails.
+     */
+    private static final WebLink[] NO_CONNECTION_STATIC_LINKS = {
+            new WebLink(true, "ReVanced.app", "https://revanced.app")
+    };
+
+    private static final String SOCIAL_LINKS_PROVIDER = "https://api.revanced.app/v4";
+    private static final Route.CompiledRoute GET_SOCIAL = new Route(GET, "/about").compile();
+
+    @Nullable
+    private static volatile WebLink[] fetchedLinks;
+
+    static boolean hasFetchedLinks() {
+        return fetchedLinks != null;
+    }
+
+    static WebLink[] fetchAboutLinks() {
+        try {
+            if (hasFetchedLinks()) return fetchedLinks;
+
+            // Check if there is no internet connection.
+            if (!Utils.isNetworkConnected()) return NO_CONNECTION_STATIC_LINKS;
+
+            HttpURLConnection connection = Requester.getConnectionFromCompiledRoute(SOCIAL_LINKS_PROVIDER, GET_SOCIAL);
+            connection.setConnectTimeout(5000);
+            connection.setReadTimeout(5000);
+            Logger.printDebug(() -> "Fetching social links from: " + connection.getURL());
+
+            // Do not show an exception toast if the server is down
+            final int responseCode = connection.getResponseCode();
+            if (responseCode != 200) {
+                Logger.printDebug(() -> "Failed to get social links.  Response code: " + responseCode);
+                return NO_CONNECTION_STATIC_LINKS;
+            }
+
+            JSONObject json = Requester.parseJSONObjectAndDisconnect(connection);
+            aboutLogoUrl = json.getJSONObject("branding").getString("logo");
+
+            List<WebLink> links = new ArrayList<>();
+
+            JSONArray donations = json.getJSONObject("donations").getJSONArray("links");
+            for (int i = 0, length = donations.length(); i < length; i++) {
+                WebLink link = new WebLink(donations.getJSONObject(i));
+                if (link.preferred) {
+                    // This could be localized, but TikTok does not support localized resources.
+                    // All link names returned by the api are also non localized.
+                    link.name = "Donate";
+                    links.add(link);
+                }
+            }
+
+            JSONArray socials = json.getJSONArray("socials");
+            for (int i = 0, length = socials.length(); i < length; i++) {
+                WebLink link = new WebLink(socials.getJSONObject(i));
+                links.add(link);
+            }
+
+            Logger.printDebug(() -> "links: " + links);
+
+            return fetchedLinks = links.toArray(new WebLink[0]);
+
+        } catch (SocketTimeoutException ex) {
+            Logger.printInfo(() -> "Could not fetch social links", ex); // No toast.
+        } catch (JSONException ex) {
+            Logger.printException(() -> "Could not parse about information", ex);
+        } catch (Exception ex) {
+            Logger.printException(() -> "Failed to get about information", ex);
+        }
+
+        return NO_CONNECTION_STATIC_LINKS;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/preference/ResettableEditTextPreference.java

@@ -0,0 +1,67 @@
+package app.revanced.extension.shared.settings.preference;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.os.Bundle;
+import android.preference.EditTextPreference;
+import android.util.AttributeSet;
+import android.widget.Button;
+import android.widget.EditText;
+
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.settings.Setting;
+import app.revanced.extension.shared.Logger;
+
+import java.util.Objects;
+
+import static app.revanced.extension.shared.StringRef.str;
+
+@SuppressWarnings({"unused", "deprecation"})
+public class ResettableEditTextPreference extends EditTextPreference {
+
+    public ResettableEditTextPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+    public ResettableEditTextPreference(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+    public ResettableEditTextPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+    public ResettableEditTextPreference(Context context) {
+        super(context);
+    }
+
+    @Override
+    protected void onPrepareDialogBuilder(AlertDialog.Builder builder) {
+        super.onPrepareDialogBuilder(builder);
+        Utils.setEditTextDialogTheme(builder);
+
+        Setting<?> setting = Setting.getSettingFromPath(getKey());
+        if (setting != null) {
+            builder.setNeutralButton(str("revanced_settings_reset"), null);
+        }
+    }
+
+    @Override
+    protected void showDialog(Bundle state) {
+        super.showDialog(state);
+
+        // Override the button click listener to prevent dismissing the dialog.
+        Button button = ((AlertDialog) getDialog()).getButton(AlertDialog.BUTTON_NEUTRAL);
+        if (button == null) {
+            return;
+        }
+        button.setOnClickListener(v -> {
+            try {
+                Setting<?> setting = Objects.requireNonNull(Setting.getSettingFromPath(getKey()));
+                String defaultStringValue = setting.defaultValue.toString();
+                EditText editText = getEditText();
+                editText.setText(defaultStringValue);
+                editText.setSelection(defaultStringValue.length()); // move cursor to end of text
+            } catch (Exception ex) {
+                Logger.printException(() -> "reset failure", ex);
+            }
+        });
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/settings/preference/SharedPrefCategory.java

@@ -0,0 +1,190 @@
+package app.revanced.extension.shared.settings.preference;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.preference.PreferenceFragment;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+
+import java.util.Objects;
+
+/**
+ * Shared categories, and helper methods.
+ *
+ * The various save methods store numbers as Strings,
+ * which is required if using {@link PreferenceFragment}.
+ *
+ * If saved numbers will not be used with a preference fragment,
+ * then store the primitive numbers using the {@link #preferences} itself.
+ */
+public class SharedPrefCategory {
+    @NonNull
+    public final String name;
+    @NonNull
+    public final SharedPreferences preferences;
+
+    public SharedPrefCategory(@NonNull String name) {
+        this.name = Objects.requireNonNull(name);
+        preferences = Objects.requireNonNull(Utils.getContext()).getSharedPreferences(name, Context.MODE_PRIVATE);
+    }
+
+    private void removeConflictingPreferenceKeyValue(@NonNull String key) {
+        Logger.printException(() -> "Found conflicting preference: " + key);
+        removeKey(key);
+    }
+
+    private void saveObjectAsString(@NonNull String key, @Nullable Object value) {
+        preferences.edit().putString(key, (value == null ? null : value.toString())).apply();
+    }
+
+    /**
+     * Removes any preference data type that has the specified key.
+     */
+    public void removeKey(@NonNull String key) {
+        preferences.edit().remove(Objects.requireNonNull(key)).apply();
+    }
+
+    public void saveBoolean(@NonNull String key, boolean value) {
+        preferences.edit().putBoolean(key, value).apply();
+    }
+
+    /**
+     * @param value a NULL parameter removes the value from the preferences
+     */
+    public void saveEnumAsString(@NonNull String key, @Nullable Enum<?> value) {
+        saveObjectAsString(key, value);
+    }
+
+    /**
+     * @param value a NULL parameter removes the value from the preferences
+     */
+    public void saveIntegerString(@NonNull String key, @Nullable Integer value) {
+        saveObjectAsString(key, value);
+    }
+
+    /**
+     * @param value a NULL parameter removes the value from the preferences
+     */
+    public void saveLongString(@NonNull String key, @Nullable Long value) {
+        saveObjectAsString(key, value);
+    }
+
+    /**
+     * @param value a NULL parameter removes the value from the preferences
+     */
+    public void saveFloatString(@NonNull String key, @Nullable Float value) {
+        saveObjectAsString(key, value);
+    }
+
+    /**
+     * @param value a NULL parameter removes the value from the preferences
+     */
+    public void saveString(@NonNull String key, @Nullable String value) {
+        saveObjectAsString(key, value);
+    }
+
+    @NonNull
+    public String getString(@NonNull String key, @NonNull String _default) {
+        Objects.requireNonNull(_default);
+        try {
+            return preferences.getString(key, _default);
+        } catch (ClassCastException ex) {
+            // Value stored is a completely different type (should never happen).
+            removeConflictingPreferenceKeyValue(key);
+            return _default;
+        }
+    }
+
+    @NonNull
+    public <T extends Enum<?>> T getEnum(@NonNull String key, @NonNull T _default) {
+        Objects.requireNonNull(_default);
+        try {
+            String enumName = preferences.getString(key, null);
+            if (enumName != null) {
+                try {
+                    // noinspection unchecked
+                    return (T) Enum.valueOf(_default.getClass(), enumName);
+                } catch (IllegalArgumentException ex) {
+                    // Info level to allow removing enum values in the future without showing any user errors.
+                    Logger.printInfo(() -> "Using default, and ignoring unknown enum value: "  + enumName);
+                    removeKey(key);
+                }
+            }
+        } catch (ClassCastException ex) {
+            // Value stored is a completely different type (should never happen).
+            removeConflictingPreferenceKeyValue(key);
+        }
+        return _default;
+    }
+
+    public boolean getBoolean(@NonNull String key, boolean _default) {
+        try {
+            return preferences.getBoolean(key, _default);
+        } catch (ClassCastException ex) {
+            // Value stored is a completely different type (should never happen).
+            removeConflictingPreferenceKeyValue(key);
+            return _default;
+        }
+    }
+
+    @NonNull
+    public Integer getIntegerString(@NonNull String key, @NonNull Integer _default) {
+        try {
+            String value = preferences.getString(key, null);
+            if (value != null) {
+                return Integer.valueOf(value);
+            }
+        } catch (ClassCastException | NumberFormatException ex) {
+            try {
+                // Old data previously stored as primitive.
+                return preferences.getInt(key, _default);
+            } catch (ClassCastException ex2) {
+                // Value stored is a completely different type (should never happen).
+                removeConflictingPreferenceKeyValue(key);
+            }
+        }
+        return _default;
+    }
+
+    @NonNull
+    public Long getLongString(@NonNull String key, @NonNull Long _default) {
+        try {
+            String value = preferences.getString(key, null);
+            if (value != null) {
+                return Long.valueOf(value);
+            }
+        } catch (ClassCastException | NumberFormatException ex) {
+            try {
+                return preferences.getLong(key, _default);
+            } catch (ClassCastException ex2) {
+                removeConflictingPreferenceKeyValue(key);
+            }
+        }
+        return _default;
+    }
+
+    @NonNull
+    public Float getFloatString(@NonNull String key, @NonNull Float _default) {
+        try {
+            String value = preferences.getString(key, null);
+            if (value != null) {
+                return Float.valueOf(value);
+            }
+        } catch (ClassCastException | NumberFormatException ex) {
+            try {
+                return preferences.getFloat(key, _default);
+            } catch (ClassCastException ex2) {
+                removeConflictingPreferenceKeyValue(key);
+            }
+        }
+        return _default;
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return name;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/spoof/AudioStreamLanguage.java

@@ -0,0 +1,113 @@
+package app.revanced.extension.shared.spoof;
+
+import java.util.Locale;
+
+public enum AudioStreamLanguage {
+    /**
+     * YouTube default.
+     * Can be the original language or can be app language,
+     * depending on what YouTube decides to pick as the default.
+     */
+    DEFAULT,
+
+    // Language codes found in locale_config.xml
+    // Region specific variants of Chinese/English/Spanish/French have been removed.
+    AF,
+    AM,
+    AR,
+    AS,
+    AZ,
+    BE,
+    BG,
+    BN,
+    BS,
+    CA,
+    CS,
+    DA,
+    DE,
+    EL,
+    EN,
+    ES,
+    ET,
+    EU,
+    FA,
+    FI,
+    FR,
+    GL,
+    GU,
+    HI,
+    HE, // App uses obsolete 'IW' and 'HE' is modern ISO code.
+    HR,
+    HU,
+    HY,
+    ID,
+    IS,
+    IT,
+    JA,
+    KA,
+    KK,
+    KM,
+    KN,
+    KO,
+    KY,
+    LO,
+    LT,
+    LV,
+    MK,
+    ML,
+    MN,
+    MR,
+    MS,
+    MY,
+    NE,
+    NL,
+    NB,
+    OR,
+    PA,
+    PL,
+    PT_BR,
+    PT_PT,
+    RO,
+    RU,
+    SI,
+    SK,
+    SL,
+    SQ,
+    SR,
+    SV,
+    SW,
+    TA,
+    TE,
+    TH,
+    TL,
+    TR,
+    UK,
+    UR,
+    UZ,
+    VI,
+    ZH,
+    ZU;
+
+    private final String iso639_1;
+
+    AudioStreamLanguage() {
+        String name = name();
+        final int regionSeparatorIndex = name.indexOf('_');
+        if (regionSeparatorIndex >= 0) {
+            iso639_1 = name.substring(0, regionSeparatorIndex).toLowerCase(Locale.US)
+                    + name.substring(regionSeparatorIndex);
+        } else {
+            iso639_1 = name().toLowerCase(Locale.US);
+        }
+    }
+
+    public String getIso639_1() {
+        // Changing the app language does not force the app to completely restart,
+        // so the default needs to be the current language and not a static field.
+        if (this == DEFAULT) {
+            return Locale.getDefault().toLanguageTag();
+        }
+
+        return iso639_1;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/spoof/ClientType.java

@@ -0,0 +1,95 @@
+package app.revanced.extension.shared.spoof;
+
+import android.os.Build;
+
+import androidx.annotation.Nullable;
+
+public enum ClientType {
+    // https://dumps.tadiphone.dev/dumps/oculus/eureka
+    ANDROID_VR_NO_AUTH( // Must be first so a default audio language can be set.
+            28,
+            "ANDROID_VR",
+            "Quest 3",
+            "12",
+            "com.google.android.apps.youtube.vr.oculus/1.56.21 (Linux; U; Android 12; GB) gzip",
+            "32", // Android 12.1
+            "1.56.21",
+            false),
+    // Fall over to authenticated ('hl' is ignored and audio is same as language set in users Google account).
+    ANDROID_VR(
+            ANDROID_VR_NO_AUTH.id,
+            ANDROID_VR_NO_AUTH.clientName,
+            ANDROID_VR_NO_AUTH.deviceModel,
+            ANDROID_VR_NO_AUTH.osVersion,
+            ANDROID_VR_NO_AUTH.userAgent,
+            ANDROID_VR_NO_AUTH.androidSdkVersion,
+            ANDROID_VR_NO_AUTH.clientVersion,
+            true),
+    ANDROID_UNPLUGGED(
+            29,
+            "ANDROID_UNPLUGGED",
+            "Google TV Streamer",
+            "14",
+            "com.google.android.apps.youtube.unplugged/8.49.0 (Linux; U; Android 14; GB) gzip",
+            "34",
+            "8.49.0",
+            true); // Requires login.
+
+    /**
+     * YouTube
+     * <a href="https://github.com/zerodytrash/YouTube-Internal-Clients?tab=readme-ov-file#clients">client type</a>
+     */
+    public final int id;
+
+    public final String clientName;
+
+    /**
+     * Device model, equivalent to {@link Build#MODEL} (System property: ro.product.model)
+     */
+    public final String deviceModel;
+
+    /**
+     * Device OS version.
+     */
+    public final String osVersion;
+
+    /**
+     * Player user-agent.
+     */
+    public final String userAgent;
+
+    /**
+     * Android SDK version, equivalent to {@link Build.VERSION#SDK} (System property: ro.build.version.sdk)
+     * Field is null if not applicable.
+     */
+    @Nullable
+    public final String androidSdkVersion;
+
+    /**
+     * App version.
+     */
+    public final String clientVersion;
+
+    /**
+     * If the client can access the API logged in.
+     */
+    public final boolean canLogin;
+
+    ClientType(int id,
+               String clientName,
+               String deviceModel,
+               String osVersion,
+               String userAgent,
+               @Nullable String androidSdkVersion,
+               String clientVersion,
+               boolean canLogin) {
+        this.id = id;
+        this.clientName = clientName;
+        this.deviceModel = deviceModel;
+        this.osVersion = osVersion;
+        this.userAgent = userAgent;
+        this.androidSdkVersion = androidSdkVersion;
+        this.clientVersion = clientVersion;
+        this.canLogin = canLogin;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/spoof/SpoofVideoStreamsPatch.java

@@ -0,0 +1,186 @@
+package app.revanced.extension.shared.spoof;
+
+import android.net.Uri;
+
+import androidx.annotation.Nullable;
+
+import java.nio.ByteBuffer;
+import java.util.Map;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.settings.BaseSettings;
+import app.revanced.extension.shared.settings.Setting;
+import app.revanced.extension.shared.spoof.requests.StreamingDataRequest;
+
+@SuppressWarnings("unused")
+public class SpoofVideoStreamsPatch {
+    private static final boolean SPOOF_STREAMING_DATA = BaseSettings.SPOOF_VIDEO_STREAMS.get();
+
+    /**
+     * Any unreachable ip address.  Used to intentionally fail requests.
+     */
+    private static final String UNREACHABLE_HOST_URI_STRING = "https://127.0.0.0";
+    private static final Uri UNREACHABLE_HOST_URI = Uri.parse(UNREACHABLE_HOST_URI_STRING);
+
+    /**
+     * @return If this patch was included during patching.
+     */
+    private static boolean isPatchIncluded() {
+        return false; // Modified during patching.
+    }
+
+    public static final class NotSpoofingAndroidAvailability implements Setting.Availability {
+        @Override
+        public boolean isAvailable() {
+            if (SpoofVideoStreamsPatch.isPatchIncluded()) {
+                return !BaseSettings.SPOOF_VIDEO_STREAMS.get();
+            }
+
+            return true;
+        }
+    }
+
+    /**
+     * Injection point.
+     * Blocks /get_watch requests by returning an unreachable URI.
+     *
+     * @param playerRequestUri The URI of the player request.
+     * @return An unreachable URI if the request is a /get_watch request, otherwise the original URI.
+     */
+    public static Uri blockGetWatchRequest(Uri playerRequestUri) {
+        if (SPOOF_STREAMING_DATA) {
+            try {
+                String path = playerRequestUri.getPath();
+
+                if (path != null && path.contains("get_watch")) {
+                    Logger.printDebug(() -> "Blocking 'get_watch' by returning unreachable uri");
+
+                    return UNREACHABLE_HOST_URI;
+                }
+            } catch (Exception ex) {
+                Logger.printException(() -> "blockGetWatchRequest failure", ex);
+            }
+        }
+
+        return playerRequestUri;
+    }
+
+    /**
+     * Injection point.
+     * <p>
+     * Blocks /initplayback requests.
+     */
+    public static String blockInitPlaybackRequest(String originalUrlString) {
+        if (SPOOF_STREAMING_DATA) {
+            try {
+                var originalUri = Uri.parse(originalUrlString);
+                String path = originalUri.getPath();
+
+                if (path != null && path.contains("initplayback")) {
+                    Logger.printDebug(() -> "Blocking 'initplayback' by returning unreachable url");
+
+                    return UNREACHABLE_HOST_URI_STRING;
+                }
+            } catch (Exception ex) {
+                Logger.printException(() -> "blockInitPlaybackRequest failure", ex);
+            }
+        }
+
+        return originalUrlString;
+    }
+
+    /**
+     * Injection point.
+     */
+    public static boolean isSpoofingEnabled() {
+        return SPOOF_STREAMING_DATA;
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void fetchStreams(String url, Map<String, String> requestHeaders) {
+        if (SPOOF_STREAMING_DATA) {
+            try {
+                Uri uri = Uri.parse(url);
+                String path = uri.getPath();
+
+                // 'heartbeat' has no video id and appears to be only after playback has started.
+                // 'refresh' has no video id and appears to happen when waiting for a livestream to start.
+                if (path != null && path.contains("player") && !path.contains("heartbeat")
+                        && !path.contains("refresh")) {
+                    String id = uri.getQueryParameter("id");
+                    if (id == null) {
+                        Logger.printException(() -> "Ignoring request that has no video id." +
+                                " Url: " + url + " headers: " + requestHeaders);
+                        return;
+                    }
+
+                    StreamingDataRequest.fetchRequest(id, requestHeaders);
+                }
+            } catch (Exception ex) {
+                Logger.printException(() -> "buildRequest failure", ex);
+            }
+        }
+    }
+
+    /**
+     * Injection point.
+     * Fix playback by replace the streaming data.
+     * Called after {@link #fetchStreams(String, Map)}.
+     */
+    @Nullable
+    public static ByteBuffer getStreamingData(String videoId) {
+        if (SPOOF_STREAMING_DATA) {
+            try {
+                StreamingDataRequest request = StreamingDataRequest.getRequestForVideoId(videoId);
+                if (request != null) {
+                    // This hook is always called off the main thread,
+                    // but this can later be called for the same video id from the main thread.
+                    // This is not a concern, since the fetch will always be finished
+                    // and never block the main thread.
+                    // But if debugging, then still verify this is the situation.
+                    if (BaseSettings.DEBUG.get() && !request.fetchCompleted() && Utils.isCurrentlyOnMainThread()) {
+                        Logger.printException(() -> "Error: Blocking main thread");
+                    }
+
+                    var stream = request.getStream();
+                    if (stream != null) {
+                        Logger.printDebug(() -> "Overriding video stream: " + videoId);
+                        return stream;
+                    }
+                }
+
+                Logger.printDebug(() -> "Not overriding streaming data (video stream is null): " + videoId);
+            } catch (Exception ex) {
+                Logger.printException(() -> "getStreamingData failure", ex);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Injection point.
+     * Called after {@link #getStreamingData(String)}.
+     */
+    @Nullable
+    public static byte[] removeVideoPlaybackPostBody(Uri uri, int method, byte[] postData) {
+        if (SPOOF_STREAMING_DATA) {
+            try {
+                final int methodPost = 2;
+                if (method == methodPost) {
+                    String path = uri.getPath();
+                    if (path != null && path.contains("videoplayback")) {
+                        return null;
+                    }
+                }
+            } catch (Exception ex) {
+                Logger.printException(() -> "removeVideoPlaybackPostBody failure", ex);
+            }
+        }
+
+        return postData;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/spoof/requests/PlayerRoutes.java

@@ -0,0 +1,77 @@
+package app.revanced.extension.shared.spoof.requests;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.requests.Requester;
+import app.revanced.extension.shared.requests.Route;
+import app.revanced.extension.shared.settings.BaseSettings;
+import app.revanced.extension.shared.spoof.ClientType;
+
+final class PlayerRoutes {
+    static final Route.CompiledRoute GET_STREAMING_DATA = new Route(
+            Route.Method.POST,
+            "player" +
+                    "?fields=streamingData" +
+                    "&alt=proto"
+    ).compile();
+
+    private static final String YT_API_URL = "https://youtubei.googleapis.com/youtubei/v1/";
+
+    /**
+     * TCP connection and HTTP read timeout
+     */
+    private static final int CONNECTION_TIMEOUT_MILLISECONDS = 10 * 1000; // 10 Seconds.
+
+    private PlayerRoutes() {
+    }
+
+    static String createInnertubeBody(ClientType clientType) {
+        JSONObject innerTubeBody = new JSONObject();
+
+        try {
+            JSONObject context = new JSONObject();
+
+            JSONObject client = new JSONObject();
+            client.put("hl", BaseSettings.SPOOF_VIDEO_STREAMS_LANGUAGE.get().getIso639_1());
+            client.put("clientName", clientType.clientName);
+            client.put("clientVersion", clientType.clientVersion);
+            client.put("deviceModel", clientType.deviceModel);
+            client.put("osVersion", clientType.osVersion);
+            if (clientType.androidSdkVersion != null) {
+                client.put("androidSdkVersion", clientType.androidSdkVersion);
+            }
+            context.put("client", client);
+
+            innerTubeBody.put("context", context);
+            innerTubeBody.put("contentCheckOk", true);
+            innerTubeBody.put("racyCheckOk", true);
+            innerTubeBody.put("videoId", "%s");
+        } catch (JSONException e) {
+            Logger.printException(() -> "Failed to create innerTubeBody", e);
+        }
+
+        return innerTubeBody.toString();
+    }
+
+    /**
+     * @noinspection SameParameterValue
+     */
+    static HttpURLConnection getPlayerResponseConnectionFromRoute(Route.CompiledRoute route, ClientType clientType) throws IOException {
+        var connection = Requester.getConnectionFromCompiledRoute(YT_API_URL, route);
+
+        connection.setRequestProperty("Content-Type", "application/json");
+        connection.setRequestProperty("User-Agent", clientType.userAgent);
+
+        connection.setUseCaches(false);
+        connection.setDoOutput(true);
+
+        connection.setConnectTimeout(CONNECTION_TIMEOUT_MILLISECONDS);
+        connection.setReadTimeout(CONNECTION_TIMEOUT_MILLISECONDS);
+        return connection;
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/spoof/requests/StreamingDataRequest.java

@@ -0,0 +1,230 @@
+package app.revanced.extension.shared.spoof.requests;
+
+import static app.revanced.extension.shared.spoof.requests.PlayerRoutes.GET_STREAMING_DATA;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.SocketTimeoutException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.settings.BaseSettings;
+import app.revanced.extension.shared.spoof.AudioStreamLanguage;
+import app.revanced.extension.shared.spoof.ClientType;
+
+/**
+ * Video streaming data.  Fetching is tied to the behavior YT uses,
+ * where this class fetches the streams only when YT fetches.
+ * <p>
+ * Effectively the cache expiration of these fetches is the same as the stock app,
+ * since the stock app would not use expired streams and therefor
+ * the extension replace stream hook is called only if YT
+ * did use its own client streams.
+ */
+public class StreamingDataRequest {
+
+    private static final ClientType[] CLIENT_ORDER_TO_USE = ClientType.values();
+
+    private static final String AUTHORIZATION_HEADER = "Authorization";
+
+    private static final String[] REQUEST_HEADER_KEYS = {
+            AUTHORIZATION_HEADER, // Available only to logged-in users.
+            "X-GOOG-API-FORMAT-VERSION",
+            "X-Goog-Visitor-Id"
+    };
+
+    /**
+     * TCP connection and HTTP read timeout.
+     */
+    private static final int HTTP_TIMEOUT_MILLISECONDS = 10 * 1000;
+
+    /**
+     * Any arbitrarily large value, but must be at least twice {@link #HTTP_TIMEOUT_MILLISECONDS}
+     */
+    private static final int MAX_MILLISECONDS_TO_WAIT_FOR_FETCH = 20 * 1000;
+
+    private static final Map<String, StreamingDataRequest> cache = Collections.synchronizedMap(
+            new LinkedHashMap<>(100) {
+                /**
+                 * Cache limit must be greater than the maximum number of videos open at once,
+                 * which theoretically is more than 4 (3 Shorts + one regular minimized video).
+                 * But instead use a much larger value, to handle if a video viewed a while ago
+                 * is somehow still referenced.  Each stream is a small array of Strings
+                 * so memory usage is not a concern.
+                 */
+                private static final int CACHE_LIMIT = 50;
+
+                @Override
+                protected boolean removeEldestEntry(Entry eldest) {
+                    return size() > CACHE_LIMIT; // Evict the oldest entry if over the cache limit.
+                }
+            });
+
+    private final String videoId;
+
+    private final Future<ByteBuffer> future;
+
+    private StreamingDataRequest(String videoId, Map<String, String> playerHeaders) {
+        Objects.requireNonNull(playerHeaders);
+        this.videoId = videoId;
+        this.future = Utils.submitOnBackgroundThread(() -> fetch(videoId, playerHeaders));
+    }
+
+    public static void fetchRequest(String videoId, Map<String, String> fetchHeaders) {
+        // Always fetch, even if there is an existing request for the same video.
+        cache.put(videoId, new StreamingDataRequest(videoId, fetchHeaders));
+    }
+
+    @Nullable
+    public static StreamingDataRequest getRequestForVideoId(String videoId) {
+        return cache.get(videoId);
+    }
+
+    private static void handleConnectionError(String toastMessage, @Nullable Exception ex, boolean showToast) {
+        if (showToast) Utils.showToastShort(toastMessage);
+        Logger.printInfo(() -> toastMessage, ex);
+    }
+
+    @Nullable
+    private static HttpURLConnection send(ClientType clientType, String videoId,
+                                          Map<String, String> playerHeaders,
+                                          boolean showErrorToasts) {
+        Objects.requireNonNull(clientType);
+        Objects.requireNonNull(videoId);
+        Objects.requireNonNull(playerHeaders);
+
+        final long startTime = System.currentTimeMillis();
+        Logger.printDebug(() -> "Fetching video streams for: " + videoId + " using client: " + clientType);
+
+        try {
+            HttpURLConnection connection = PlayerRoutes.getPlayerResponseConnectionFromRoute(GET_STREAMING_DATA, clientType);
+            connection.setConnectTimeout(HTTP_TIMEOUT_MILLISECONDS);
+            connection.setReadTimeout(HTTP_TIMEOUT_MILLISECONDS);
+
+            for (String key : REQUEST_HEADER_KEYS) {
+                String value = playerHeaders.get(key);
+                if (value != null) {
+                    if (key.equals(AUTHORIZATION_HEADER)) {
+                        if (!clientType.canLogin) {
+                            Logger.printDebug(() -> "Not including request header: " + key);
+                            continue;
+                        }
+                    }
+
+                    Logger.printDebug(() -> "Including request header: " + key);
+                    connection.setRequestProperty(key, value);
+                }
+            }
+
+            String innerTubeBody = String.format(PlayerRoutes.createInnertubeBody(clientType), videoId);
+            byte[] requestBody = innerTubeBody.getBytes(StandardCharsets.UTF_8);
+            connection.setFixedLengthStreamingMode(requestBody.length);
+            connection.getOutputStream().write(requestBody);
+
+            final int responseCode = connection.getResponseCode();
+            if (responseCode == 200) return connection;
+
+            // This situation likely means the patches are outdated.
+            // Use a toast message that suggests updating.
+            handleConnectionError("Playback error (App is outdated?) " + clientType + ": "
+                            + responseCode + " response: " + connection.getResponseMessage(),
+                    null, showErrorToasts);
+        } catch (SocketTimeoutException ex) {
+            handleConnectionError("Connection timeout", ex, showErrorToasts);
+        } catch (IOException ex) {
+            handleConnectionError("Network error", ex, showErrorToasts);
+        } catch (Exception ex) {
+            Logger.printException(() -> "send failed", ex);
+        } finally {
+            Logger.printDebug(() -> "video: " + videoId + " took: " + (System.currentTimeMillis() - startTime) + "ms");
+        }
+
+        return null;
+    }
+
+    private static ByteBuffer fetch(String videoId, Map<String, String> playerHeaders) {
+        final boolean debugEnabled = BaseSettings.DEBUG.get();
+
+        // Retry with different client if empty response body is received.
+        int i = 0;
+        for (ClientType clientType : CLIENT_ORDER_TO_USE) {
+            // Show an error if the last client type fails, or if the debug is enabled then show for all attempts.
+            final boolean showErrorToast = (++i == CLIENT_ORDER_TO_USE.length) || debugEnabled;
+
+            if (clientType == ClientType.ANDROID_VR_NO_AUTH
+                    && BaseSettings.SPOOF_VIDEO_STREAMS_LANGUAGE.get() == AudioStreamLanguage.DEFAULT) {
+                // Only use no auth Android VR if a non default audio language is selected.
+                continue;
+            }
+
+            HttpURLConnection connection = send(clientType, videoId, playerHeaders, showErrorToast);
+            if (connection != null) {
+                try {
+                    // gzip encoding doesn't response with content length (-1),
+                    // but empty response body does.
+                    if (connection.getContentLength() == 0) {
+                        if (BaseSettings.DEBUG.get()) {
+                            Logger.printException(() -> "Ignoring empty client response: " + clientType);
+                        }
+                    } else {
+                        try (InputStream inputStream = new BufferedInputStream(connection.getInputStream());
+                             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
+
+                            byte[] buffer = new byte[2048];
+                            int bytesRead;
+                            while ((bytesRead = inputStream.read(buffer)) >= 0) {
+                                baos.write(buffer, 0, bytesRead);
+                            }
+
+                            return ByteBuffer.wrap(baos.toByteArray());
+                        }
+                    }
+                } catch (IOException ex) {
+                    Logger.printException(() -> "Fetch failed while processing response data", ex);
+                }
+            }
+        }
+
+        handleConnectionError("Could not fetch any client streams", null, debugEnabled);
+        return null;
+    }
+
+    public boolean fetchCompleted() {
+        return future.isDone();
+    }
+
+    @Nullable
+    public ByteBuffer getStream() {
+        try {
+            return future.get(MAX_MILLISECONDS_TO_WAIT_FOR_FETCH, TimeUnit.MILLISECONDS);
+        } catch (TimeoutException ex) {
+            Logger.printInfo(() -> "getStream timed out", ex);
+        } catch (InterruptedException ex) {
+            Logger.printException(() -> "getStream interrupted", ex);
+            Thread.currentThread().interrupt(); // Restore interrupt status flag.
+        } catch (ExecutionException ex) {
+            Logger.printException(() -> "getStream failure", ex);
+        }
+
+        return null;
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return "StreamingDataRequest{" + "videoId='" + videoId + '\'' + '}';
+    }
+}

extensions/shared/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/syncforreddit/build.gradle.kts

@@ -0,0 +1,5 @@
+dependencies {
+    compileOnly(project(":extensions:shared:library"))
+    compileOnly(project(":extensions:syncforreddit:stub"))
+    compileOnly(libs.annotation)
+}

extensions/syncforreddit/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/syncforreddit/src/main/java/app/revanced/extension/syncforreddit/FixRedditVideoDownloadPatch.java

@@ -0,0 +1,77 @@
+package app.revanced.extension.syncforreddit;
+
+import android.util.Pair;
+import androidx.annotation.Nullable;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+
+/**
+ * @noinspection unused
+ */
+public class FixRedditVideoDownloadPatch {
+    private static @Nullable Pair<Integer, String> getBestMpEntry(Element element) {
+        var representations = element.getElementsByTagName("Representation");
+        var entries = new ArrayList<Pair<Integer, String>>();
+
+        for (int i = 0; i < representations.getLength(); i++) {
+            Element representation = (Element) representations.item(i);
+            var bandwidthStr = representation.getAttribute("bandwidth");
+            try {
+                var bandwidth = Integer.parseInt(bandwidthStr);
+                var baseUrl = representation.getElementsByTagName("BaseURL").item(0);
+                if (baseUrl != null) {
+                    entries.add(new Pair<>(bandwidth, baseUrl.getTextContent()));
+                }
+            } catch (NumberFormatException ignored) {
+            }
+        }
+
+        if (entries.isEmpty()) {
+            return null;
+        }
+
+        Collections.sort(entries, (e1, e2) -> e2.first - e1.first);
+        return entries.get(0);
+    }
+
+    private static String[] parse(byte[] data) throws ParserConfigurationException, IOException, SAXException {
+        var adaptionSets = DocumentBuilderFactory
+                .newInstance()
+                .newDocumentBuilder()
+                .parse(new ByteArrayInputStream(data))
+                .getElementsByTagName("AdaptationSet");
+
+        String videoUrl = null;
+        String audioUrl = null;
+
+        for (int i = 0; i < adaptionSets.getLength(); i++) {
+            Element element = (Element) adaptionSets.item(i);
+            var contentType = element.getAttribute("contentType");
+            var bestEntry = getBestMpEntry(element);
+            if (bestEntry == null) continue;
+
+            if (contentType.equalsIgnoreCase("video")) {
+                videoUrl = bestEntry.second;
+            } else if (contentType.equalsIgnoreCase("audio")) {
+                audioUrl = bestEntry.second;
+            }
+        }
+
+        return new String[]{videoUrl, audioUrl};
+    }
+
+    public static String[] getLinks(byte[] data) {
+        try {
+            return parse(data);
+        } catch (ParserConfigurationException | IOException | SAXException e) {
+            return new String[]{null, null};
+        }
+    }
+}

extensions/syncforreddit/src/main/java/app/revanced/extension/syncforreddit/FixSLinksPatch.java

@@ -0,0 +1,24 @@
+package app.revanced.extension.syncforreddit;
+
+import com.laurencedawson.reddit_sync.ui.activities.WebViewActivity;
+
+import app.revanced.extension.shared.fixes.slink.BaseFixSLinksPatch;
+
+/** @noinspection unused*/
+public class FixSLinksPatch extends BaseFixSLinksPatch {
+    static {
+        INSTANCE = new FixSLinksPatch();
+    }
+
+    private FixSLinksPatch() {
+        webViewActivityClass = WebViewActivity.class;
+    }
+
+    public static boolean patchResolveSLink(String link) {
+        return INSTANCE.resolveSLink(link);
+    }
+
+    public static void patchSetAccessToken(String accessToken) {
+        INSTANCE.setAccessToken(accessToken);
+    }
+}

extensions/syncforreddit/stub/build.gradle.kts

@@ -0,0 +1,17 @@
+plugins {
+    id(libs.plugins.android.library.get().pluginId)
+}
+
+android {
+    namespace = "app.revanced.extension"
+    compileSdk = 33
+
+    defaultConfig {
+        minSdk = 24
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+}

extensions/syncforreddit/stub/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/syncforreddit/stub/src/main/java/com/laurencedawson/reddit_sync/ui/activities/WebViewActivity.java

@@ -0,0 +1,6 @@
+package com.laurencedawson.reddit_sync.ui.activities;
+
+import android.app.Activity;
+
+public class WebViewActivity extends Activity {
+}

extensions/tiktok/build.gradle.kts

@@ -0,0 +1,5 @@
+dependencies {
+    compileOnly(project(":extensions:shared:library"))
+    compileOnly(project(":extensions:tiktok:stub"))
+    compileOnly(libs.annotation)
+}

extensions/tiktok/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/Utils.java

@@ -0,0 +1,59 @@
+package app.revanced.extension.tiktok;
+
+import static app.revanced.extension.shared.Utils.isDarkModeEnabled;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.view.View;
+import android.widget.TextView;
+
+import androidx.annotation.ColorInt;
+
+import app.revanced.extension.shared.settings.StringSetting;
+
+public class Utils {
+
+    private static final long[] DEFAULT_MIN_MAX_VALUES = {0L, Long.MAX_VALUE};
+
+    // Edit: This could be handled using a custom Setting<Long[]> class
+    // that saves its value to preferences and JSON using the formatted String created here.
+    public static long[] parseMinMax(StringSetting setting) {
+        final String[] minMax = setting.get().split("-");
+        if (minMax.length == 2) {
+            try {
+                final long min = Long.parseLong(minMax[0]);
+                final long max = Long.parseLong(minMax[1]);
+
+                if (min <= max && min >= 0) return new long[]{min, max};
+
+            } catch (NumberFormatException ignored) {
+            }
+        }
+
+        setting.save("0-" + Long.MAX_VALUE);
+        return DEFAULT_MIN_MAX_VALUES;
+    }
+
+    // Colors picked by hand. These should be replaced with the styled resources TikTok uses.
+    private static final @ColorInt int TEXT_DARK_MODE_TITLE = Color.WHITE;
+    private static final @ColorInt int TEXT_DARK_MODE_SUMMARY
+            = Color.argb(255, 170, 170, 170);
+
+    private static final @ColorInt int TEXT_LIGHT_MODE_TITLE = Color.BLACK;
+    private static final @ColorInt int TEXT_LIGHT_MODE_SUMMARY
+            = Color.argb(255, 80, 80, 80);
+
+    public static void setTitleAndSummaryColor(Context context, View view) {
+        final boolean darkModeEnabled = isDarkModeEnabled(context);
+
+        TextView title = view.findViewById(android.R.id.title);
+        title.setTextColor(darkModeEnabled
+                ? TEXT_DARK_MODE_TITLE
+                : TEXT_LIGHT_MODE_TITLE);
+
+        TextView summary = view.findViewById(android.R.id.summary);
+        summary.setTextColor(darkModeEnabled
+                ? TEXT_DARK_MODE_SUMMARY
+                : TEXT_LIGHT_MODE_SUMMARY);
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/cleardisplay/RememberClearDisplayPatch.java

@@ -0,0 +1,13 @@
+package app.revanced.extension.tiktok.cleardisplay;
+
+import app.revanced.extension.tiktok.settings.Settings;
+
+@SuppressWarnings("unused")
+public class RememberClearDisplayPatch {
+    public static boolean getClearDisplayState() {
+        return Settings.CLEAR_DISPLAY.get();
+    }
+    public static void rememberClearDisplayState(boolean newState) {
+        Settings.CLEAR_DISPLAY.save(newState);
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/download/DownloadsPatch.java

@@ -0,0 +1,14 @@
+package app.revanced.extension.tiktok.download;
+
+import app.revanced.extension.tiktok.settings.Settings;
+
+@SuppressWarnings("unused")
+public class DownloadsPatch {
+    public static String getDownloadPath() {
+        return Settings.DOWNLOAD_PATH.get();
+    }
+
+    public static boolean shouldRemoveWatermark() {
+        return Settings.DOWNLOAD_WATERMARK.get();
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/feedfilter/AdsFilter.java

@@ -0,0 +1,16 @@
+package app.revanced.extension.tiktok.feedfilter;
+
+import app.revanced.extension.tiktok.settings.Settings;
+import com.ss.android.ugc.aweme.feed.model.Aweme;
+
+public class AdsFilter implements IFilter {
+    @Override
+    public boolean getEnabled() {
+        return Settings.REMOVE_ADS.get();
+    }
+
+    @Override
+    public boolean getFiltered(Aweme item) {
+        return item.isAd() || item.isWithPromotionalMusic();
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/feedfilter/FeedItemsFilter.java

@@ -0,0 +1,34 @@
+package app.revanced.extension.tiktok.feedfilter;
+
+import com.ss.android.ugc.aweme.feed.model.Aweme;
+import com.ss.android.ugc.aweme.feed.model.FeedItemList;
+
+import java.util.Iterator;
+import java.util.List;
+
+public final class FeedItemsFilter {
+    private static final List<IFilter> FILTERS = List.of(
+            new AdsFilter(),
+            new LiveFilter(),
+            new StoryFilter(),
+            new ImageVideoFilter(),
+            new ViewCountFilter(),
+            new LikeCountFilter()
+    );
+
+    public static void filter(FeedItemList feedItemList) {
+        Iterator<Aweme> feedItemListIterator = feedItemList.items.iterator();
+        while (feedItemListIterator.hasNext()) {
+            Aweme item = feedItemListIterator.next();
+            if (item == null) continue;
+
+            for (IFilter filter : FILTERS) {
+                boolean enabled = filter.getEnabled();
+                if (enabled && filter.getFiltered(item)) {
+                    feedItemListIterator.remove();
+                    break;
+                }
+            }
+        }
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/feedfilter/IFilter.java

@@ -0,0 +1,9 @@
+package app.revanced.extension.tiktok.feedfilter;
+
+import com.ss.android.ugc.aweme.feed.model.Aweme;
+
+public interface IFilter {
+    boolean getEnabled();
+
+    boolean getFiltered(Aweme item);
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/feedfilter/ImageVideoFilter.java

@@ -0,0 +1,16 @@
+package app.revanced.extension.tiktok.feedfilter;
+
+import app.revanced.extension.tiktok.settings.Settings;
+import com.ss.android.ugc.aweme.feed.model.Aweme;
+
+public class ImageVideoFilter implements IFilter {
+    @Override
+    public boolean getEnabled() {
+        return Settings.HIDE_IMAGE.get();
+    }
+
+    @Override
+    public boolean getFiltered(Aweme item) {
+        return item.isImage() || item.isPhotoMode();
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/feedfilter/LikeCountFilter.java

@@ -0,0 +1,33 @@
+package app.revanced.extension.tiktok.feedfilter;
+
+import com.ss.android.ugc.aweme.feed.model.Aweme;
+import com.ss.android.ugc.aweme.feed.model.AwemeStatistics;
+
+import app.revanced.extension.tiktok.Utils;
+import app.revanced.extension.tiktok.settings.Settings;
+
+public final class LikeCountFilter implements IFilter {
+
+    final long minLike;
+    final long maxLike;
+
+    LikeCountFilter() {
+        long[] minMax = Utils.parseMinMax(Settings.MIN_MAX_LIKES);
+        minLike = minMax[0];
+        maxLike = minMax[1];
+    }
+
+    @Override
+    public boolean getEnabled() {
+        return true;
+    }
+
+    @Override
+    public boolean getFiltered(Aweme item) {
+        AwemeStatistics statistics = item.getStatistics();
+        if (statistics == null) return false;
+
+        long likeCount = statistics.getDiggCount();
+        return likeCount < minLike || likeCount > maxLike;
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/feedfilter/LiveFilter.java

@@ -0,0 +1,16 @@
+package app.revanced.extension.tiktok.feedfilter;
+
+import app.revanced.extension.tiktok.settings.Settings;
+import com.ss.android.ugc.aweme.feed.model.Aweme;
+
+public class LiveFilter implements IFilter {
+    @Override
+    public boolean getEnabled() {
+        return Settings.HIDE_LIVE.get();
+    }
+
+    @Override
+    public boolean getFiltered(Aweme item) {
+        return item.isLive() || item.isLiveReplay();
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/feedfilter/StoryFilter.java

@@ -0,0 +1,16 @@
+package app.revanced.extension.tiktok.feedfilter;
+
+import app.revanced.extension.tiktok.settings.Settings;
+import com.ss.android.ugc.aweme.feed.model.Aweme;
+
+public class StoryFilter implements IFilter {
+    @Override
+    public boolean getEnabled() {
+        return Settings.HIDE_STORY.get();
+    }
+
+    @Override
+    public boolean getFiltered(Aweme item) {
+        return item.getIsTikTokStory();
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/feedfilter/ViewCountFilter.java

@@ -0,0 +1,32 @@
+package app.revanced.extension.tiktok.feedfilter;
+
+import app.revanced.extension.tiktok.Utils;
+import app.revanced.extension.tiktok.settings.Settings;
+import com.ss.android.ugc.aweme.feed.model.Aweme;
+import com.ss.android.ugc.aweme.feed.model.AwemeStatistics;
+
+
+public class ViewCountFilter implements IFilter {
+    final long minView;
+    final long maxView;
+
+    ViewCountFilter() {
+        long[] minMax = Utils.parseMinMax(Settings.MIN_MAX_VIEWS);
+        minView = minMax[0];
+        maxView = minMax[1];
+    }
+
+    @Override
+    public boolean getEnabled() {
+        return true;
+    }
+
+    @Override
+    public boolean getFiltered(Aweme item) {
+        AwemeStatistics statistics = item.getStatistics();
+        if (statistics == null) return false;
+
+        long playCount = statistics.getPlayCount();
+        return playCount < minView || playCount > maxView;
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/settings/AdPersonalizationActivityHook.java

@@ -0,0 +1,82 @@
+package app.revanced.extension.tiktok.settings;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.preference.PreferenceFragment;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.tiktok.settings.preference.ReVancedPreferenceFragment;
+import com.bytedance.ies.ugc.aweme.commercialize.compliance.personalization.AdPersonalizationActivity;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * Hooks AdPersonalizationActivity.
+ * <p>
+ * This class is responsible for injecting our own fragment by replacing the AdPersonalizationActivity.
+ *
+ * @noinspection unused
+ */
+public class AdPersonalizationActivityHook {
+    public static Object createSettingsEntry(String entryClazzName, String entryInfoClazzName) {
+        try {
+            Class<?> entryClazz = Class.forName(entryClazzName);
+            Class<?> entryInfoClazz = Class.forName(entryInfoClazzName);
+            Constructor<?> entryConstructor = entryClazz.getConstructor(entryInfoClazz);
+            Constructor<?> entryInfoConstructor = entryInfoClazz.getDeclaredConstructors()[0];
+            Object buttonInfo = entryInfoConstructor.newInstance("ReVanced settings", null, (View.OnClickListener) view -> startSettingsActivity(), "revanced");
+            return entryConstructor.newInstance(buttonInfo);
+        } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | IllegalAccessException |
+                 InstantiationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /***
+     * Initialize the settings menu.
+     * @param base The activity to initialize the settings menu on.
+     * @return Whether the settings menu should be initialized.
+     */
+    public static boolean initialize(AdPersonalizationActivity base) {
+        Bundle extras = base.getIntent().getExtras();
+        if (extras != null && !extras.getBoolean("revanced", false)) return false;
+
+        SettingsStatus.load();
+
+        LinearLayout linearLayout = new LinearLayout(base);
+        linearLayout.setLayoutParams(new LinearLayout.LayoutParams(-1, -1));
+        linearLayout.setOrientation(LinearLayout.VERTICAL);
+        linearLayout.setFitsSystemWindows(true);
+        linearLayout.setTransitionGroup(true);
+
+        FrameLayout fragment = new FrameLayout(base);
+        fragment.setLayoutParams(new FrameLayout.LayoutParams(-1, -1));
+        int fragmentId = View.generateViewId();
+        fragment.setId(fragmentId);
+
+        linearLayout.addView(fragment);
+        base.setContentView(linearLayout);
+
+        PreferenceFragment preferenceFragment = new ReVancedPreferenceFragment();
+        base.getFragmentManager().beginTransaction().replace(fragmentId, preferenceFragment).commit();
+
+        return true;
+    }
+
+    private static void startSettingsActivity() {
+        Context appContext = Utils.getContext();
+        if (appContext != null) {
+            Intent intent = new Intent(appContext, AdPersonalizationActivity.class);
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            intent.putExtra("revanced", true);
+            appContext.startActivity(intent);
+        } else {
+            Logger.printDebug(() -> "Utils.getContext() return null");
+        }
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/settings/Settings.java

@@ -0,0 +1,26 @@
+package app.revanced.extension.tiktok.settings;
+
+import static java.lang.Boolean.FALSE;
+import static java.lang.Boolean.TRUE;
+
+import app.revanced.extension.shared.settings.BaseSettings;
+import app.revanced.extension.shared.settings.BooleanSetting;
+import app.revanced.extension.shared.settings.FloatSetting;
+import app.revanced.extension.shared.settings.StringSetting;
+
+public class Settings extends BaseSettings {
+    public static final BooleanSetting REMOVE_ADS = new BooleanSetting("remove_ads", TRUE, true);
+    public static final BooleanSetting HIDE_LIVE = new BooleanSetting("hide_live", FALSE, true);
+    public static final BooleanSetting HIDE_STORY = new BooleanSetting("hide_story", FALSE, true);
+    public static final BooleanSetting HIDE_IMAGE = new BooleanSetting("hide_image", FALSE, true);
+    public static final StringSetting MIN_MAX_VIEWS = new StringSetting("min_max_views", "0-" + Long.MAX_VALUE, true);
+    public static final StringSetting MIN_MAX_LIKES = new StringSetting("min_max_likes", "0-" + Long.MAX_VALUE, true);
+    public static final StringSetting DOWNLOAD_PATH = new StringSetting("down_path", "DCIM/TikTok");
+    public static final BooleanSetting DOWNLOAD_WATERMARK = new BooleanSetting("down_watermark", TRUE);
+    public static final BooleanSetting CLEAR_DISPLAY = new BooleanSetting("clear_display", FALSE);
+    public static final FloatSetting REMEMBERED_SPEED = new FloatSetting("REMEMBERED_SPEED", 1.0f);
+    public static final BooleanSetting SIM_SPOOF = new BooleanSetting("simspoof", FALSE, true);
+    public static final StringSetting SIM_SPOOF_ISO = new StringSetting("simspoof_iso", "us");
+    public static final StringSetting SIMSPOOF_MCCMNC = new StringSetting("simspoof_mccmnc", "310160");
+    public static final StringSetting SIMSPOOF_OP_NAME = new StringSetting("simspoof_op_name", "T-Mobile");
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/settings/SettingsStatus.java

@@ -0,0 +1,23 @@
+package app.revanced.extension.tiktok.settings;
+
+public class SettingsStatus {
+    public static boolean feedFilterEnabled = false;
+    public static boolean downloadEnabled = false;
+    public static boolean simSpoofEnabled = false;
+
+    public static void enableFeedFilter() {
+        feedFilterEnabled = true;
+    }
+
+    public static void enableDownload() {
+        downloadEnabled = true;
+    }
+
+    public static void enableSimSpoof() {
+        simSpoofEnabled = true;
+    }
+
+    public static void load() {
+
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/settings/preference/DownloadPathPreference.java

@@ -0,0 +1,129 @@
+package app.revanced.extension.tiktok.settings.preference;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Environment;
+import android.preference.DialogPreference;
+import android.text.Editable;
+import android.text.InputType;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.view.View;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.RadioButton;
+import android.widget.RadioGroup;
+
+import app.revanced.extension.shared.settings.StringSetting;
+import app.revanced.extension.tiktok.Utils;
+
+@SuppressWarnings("deprecation")
+public class DownloadPathPreference extends DialogPreference {
+    private final String[] entryValues = {"DCIM", "Movies", "Pictures"};
+    private String mValue;
+
+    private boolean mValueSet;
+    private int mediaPathIndex;
+    private String childDownloadPath;
+
+    public DownloadPathPreference(Context context, String title, StringSetting setting) {
+        super(context);
+        setTitle(title);
+        setSummary(Environment.getExternalStorageDirectory().getPath() + "/" + setting.get());
+        setKey(setting.key);
+        setValue(setting.get());
+    }
+
+    public String getValue() {
+        return this.mValue;
+    }
+
+    public void setValue(String value) {
+        final boolean changed = !TextUtils.equals(mValue, value);
+        if (changed || !mValueSet) {
+            mValue = value;
+            mValueSet = true;
+            persistString(value);
+            if (changed) {
+                notifyDependencyChange(shouldDisableDependents());
+                notifyChanged();
+            }
+        }
+    }
+
+    @Override
+    protected View onCreateDialogView() {
+        String currentMedia = getValue().split("/")[0];
+        childDownloadPath = getValue().substring(getValue().indexOf("/") + 1);
+        mediaPathIndex = findIndexOf(currentMedia);
+
+        Context context = getContext();
+        LinearLayout dialogView = new LinearLayout(context);
+        RadioGroup mediaPath = new RadioGroup(context);
+        mediaPath.setLayoutParams(new RadioGroup.LayoutParams(-1, -2));
+        for (String entryValue : entryValues) {
+            RadioButton radioButton = new RadioButton(context);
+            radioButton.setText(entryValue);
+            radioButton.setId(View.generateViewId());
+            mediaPath.addView(radioButton);
+        }
+        mediaPath.setOnCheckedChangeListener((radioGroup, id) -> {
+            RadioButton radioButton = radioGroup.findViewById(id);
+            mediaPathIndex = findIndexOf(radioButton.getText().toString());
+        });
+        mediaPath.check(mediaPath.getChildAt(mediaPathIndex).getId());
+        EditText downloadPath = new EditText(context);
+        downloadPath.setInputType(InputType.TYPE_CLASS_TEXT);
+        downloadPath.setText(childDownloadPath);
+        downloadPath.addTextChangedListener(new TextWatcher() {
+            @Override
+            public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
+            }
+
+            @Override
+            public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
+            }
+
+            @Override
+            public void afterTextChanged(Editable editable) {
+                childDownloadPath = editable.toString();
+            }
+        });
+        dialogView.setLayoutParams(new LinearLayout.LayoutParams(-1, -1));
+        dialogView.setOrientation(LinearLayout.VERTICAL);
+        dialogView.addView(mediaPath);
+        dialogView.addView(downloadPath);
+        return dialogView;
+    }
+
+    @Override
+    protected void onBindView(View view) {
+        super.onBindView(view);
+
+        Utils.setTitleAndSummaryColor(getContext(), view);
+    }
+
+    @Override
+    protected void onPrepareDialogBuilder(AlertDialog.Builder builder) {
+        builder.setTitle("Download Path");
+        builder.setPositiveButton(android.R.string.ok, (dialog, which) -> this.onClick(dialog, DialogInterface.BUTTON_POSITIVE));
+        builder.setNegativeButton(android.R.string.cancel, null);
+    }
+
+    @Override
+    protected void onDialogClosed(boolean positiveResult) {
+        if (positiveResult && mediaPathIndex >= 0) {
+            String newValue = entryValues[mediaPathIndex] + "/" + childDownloadPath;
+            setSummary(Environment.getExternalStorageDirectory().getPath() + "/" + newValue);
+            setValue(newValue);
+        }
+    }
+
+    private int findIndexOf(String str) {
+        for (int i = 0; i < entryValues.length; i++) {
+            if (str.equals(entryValues[i])) return i;
+        }
+        return -1;
+    }
+}

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/settings/preference/InputTextPreference.java

@@ -0,0 +1,27 @@
+package app.revanced.extension.tiktok.settings.preference;
+
+import android.content.Context;
+import android.preference.EditTextPreference;
+import android.view.View;
+
+import app.revanced.extension.shared.settings.StringSetting;
+import app.revanced.extension.tiktok.Utils;
+
+@SuppressWarnings("deprecation")
+public class InputTextPreference extends EditTextPreference {
+
+    public InputTextPreference(Context context, String title, String summary, StringSetting setting) {
+        super(context);
+        setTitle(title);
+        setSummary(summary);
+        setKey(setting.key);
+        setText(setting.get());
+    }
+
+    @Override
+    protected void onBindView(View view) {
+        super.onBindView(view);
+
+        Utils.setTitleAndSummaryColor(getContext(), view);
+    }
+}