chore: Release v1.16.0-dev.1 [skip ci]

# [1.16.0-dev.1](https://github.com/ReVanced/revanced-integrations/compare/v1.15.1-dev.1...v1.16.0-dev.1) (2024-10-02)

### Features

* **YouTube - Hide Shorts components:** Add option to hide like fountain ([#708](https://github.com/ReVanced/revanced-integrations/issues/708)) ([16c3ef7](16c3ef7ee5))

.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-integrations/labels/Bug%20report).
+        - **Do not submit a duplicate bug report**: Search for existing bug reports [here](https://github.com/ReVanced/revanced-integrations/issues?q=label%3A%22Bug+report%22).
         - **Do not use the issue page for support**: If you need help or have questions, check out other platforms on [revanced.app](https://revanced.app).
   - type: textarea
     attributes:
@@ -101,7 +101,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-integrations/labels/Feature%20request).
+        - **Do not submit a duplicate feature request**: Search for existing feature requests [here](https://github.com/ReVanced/revanced-integrations/issues?q=label%3A%22Feature+request%22).
         - **Do not use the issue page for support**: If you need help or have questions, check out other platforms on [revanced.app](https://revanced.app).
   - type: textarea
     attributes:
@@ -97,7 +97,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/open_pull_request.yml

@@ -25,7 +25,7 @@ jobs:
           pr_body: |
             This pull request will ${{ env.MESSAGE }}.
             
-            ## Dependencies before merge
+            ## Before merging this PR
 
-            - [ ] https://github.com/revanced/revanced-patches
+            - [ ] Remember about https://github.com/revanced/revanced-patches
           pr_draft: true

.github/workflows/release.yml

@@ -10,6 +10,8 @@ on:
 jobs:
   release:
     name: Release
+    permissions:
+      contents: write
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -45,9 +47,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

.releaserc

@@ -7,7 +7,13 @@
     }
   ],
   "plugins": [
-    "@semantic-release/commit-analyzer",
+    [
+      "@semantic-release/commit-analyzer", {
+        "releaseRules": [
+          { "type": "build", "scope": "Needs bump", "release": "patch" }
+        ]
+      }
+    ],
     "@semantic-release/release-notes-generator",
     "@semantic-release/changelog",
     "gradle-semantic-release-plugin",
@@ -17,7 +23,8 @@
         "assets": [
           "CHANGELOG.md",
           "gradle.properties"
-        ]
+        ],
+        "message": "chore: Release v${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
       }
     ],
     [

app/build.gradle.kts

@@ -2,6 +2,7 @@ plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin)
     publishing
+    signing
 }
 
 android {
@@ -53,28 +54,27 @@ dependencies {
     compileOnly(project(":stub"))
 }
 
-tasks {
-    // Because the signing plugin doesn't support signing APKs, do it manually.
-    register("sign") {
-        group = "signing"
 
-        dependsOn(build)
+tasks {
+    val assembleReleaseSignApk by registering {
+        dependsOn("assembleRelease")
+
+        val apk = layout.buildDirectory.file("outputs/apk/release/${rootProject.name}-$version.apk")
+
+        inputs.file(apk).withPropertyName("input")
+        outputs.file(apk.map { it.asFile.resolveSibling("${it.asFile.name}.asc") })
 
         doLast {
-            val outputDirectory = layout.buildDirectory.dir("outputs/apk/release").get().asFile
-            val integrationsApk = outputDirectory.resolve("${rootProject.name}-$version.apk")
-
-            org.gradle.security.internal.gnupg.GnupgSignatoryFactory().createSignatory(project).sign(
-                integrationsApk.inputStream(),
-                outputDirectory.resolve("${integrationsApk.name}.asc").outputStream(),
-            )
+            signing {
+                useGpgCmd()
+                sign(*inputs.files.files.toTypedArray())
+            }
         }
     }
 
     // Needed by gradle-semantic-release-plugin.
-    // Tracking: https://github.com/KengoTODA/gradle-semantic-release-plugin/issues/435
+    // Tracking: https://github.com/KengoTODA/gradle-semantic-release-plugin/issues/435.
     publish {
-        dependsOn(build)
-        dependsOn("sign")
+        dependsOn(assembleReleaseSignApk)
     }
 }

app/src/main/java/app/revanced/integrations/boostforreddit/FixSLinksPatch.java

@@ -0,0 +1,24 @@
+package app.revanced.integrations.boostforreddit;
+
+import com.rubenmayayo.reddit.ui.activities.WebViewActivity;
+
+import app.revanced.integrations.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);
+    }
+}

app/src/main/java/app/revanced/integrations/shared/GmsCoreSupport.java

@@ -24,6 +24,7 @@ import java.net.URL;
  * @noinspection unused
  */
 public class GmsCoreSupport {
+    public static final String ORIGINAL_UNPATCHED_PACKAGE_NAME = "com.google.android.youtube";
     private static final String GMS_CORE_PACKAGE_NAME
             = getGmsCoreVendorGroupId() + ".android.gms";
     private static final Uri GMS_CORE_PROVIDER
@@ -53,18 +54,15 @@ public class GmsCoreSupport {
                                                       String dialogMessageRef,
                                                       String positiveButtonStringRef,
                                                       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(() -> {
-            new AlertDialog.Builder(context)
-                    .setIconAttribute(android.R.attr.alertDialogIcon)
-                    .setTitle(str("gms_core_dialog_title"))
-                    .setMessage(str(dialogMessageRef))
-                    .setPositiveButton(str(positiveButtonStringRef), onPositiveClickListener)
-                    // Allow using back button to skip the action, just in case the check can never be satisfied.
-                    .setCancelable(true)
-                    .show();
-        }, 100);
+        // Do not set cancelable to false, to allow using back button to skip the action,
+        // just in case the check can never be satisfied.
+        var dialog = new AlertDialog.Builder(context)
+                .setIconAttribute(android.R.attr.alertDialogIcon)
+                .setTitle(str("gms_core_dialog_title"))
+                .setMessage(str(dialogMessageRef))
+                .setPositiveButton(str(positiveButtonStringRef), onPositiveClickListener)
+                .create();
+        Utils.showDialog(context, dialog);
     }
 
     /**
@@ -73,6 +71,21 @@ public class GmsCoreSupport {
     @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.
+            if (context.getPackageName().equals(ORIGINAL_UNPATCHED_PACKAGE_NAME)) {
+                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();

app/src/main/java/app/revanced/integrations/shared/Logger.java

@@ -1,24 +1,21 @@
 package app.revanced.integrations.shared;
 
-import static app.revanced.integrations.shared.settings.BaseSettings.DEBUG;
-import static app.revanced.integrations.shared.settings.BaseSettings.DEBUG_STACKTRACE;
-import static app.revanced.integrations.shared.settings.BaseSettings.DEBUG_TOAST_ON_ERROR;
-
 import android.util.Log;
-
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import app.revanced.integrations.shared.settings.BaseSettings;
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
 
-import app.revanced.integrations.shared.settings.BaseSettings;
+import static app.revanced.integrations.shared.settings.BaseSettings.*;
 
 public class Logger {
 
     /**
      * Log messages using lambdas.
      */
+    @FunctionalInterface
     public interface LogMessage {
         @NonNull
         String buildMessageString();
@@ -59,19 +56,33 @@ public class Logger {
      * 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()) {
-            var messageString = message.buildMessageString();
+            String logMessage = message.buildMessageString();
+            String logTag = REVANCED_LOG_PREFIX + message.findOuterClassSimpleName();
 
             if (DEBUG_STACKTRACE.get()) {
-                var builder = new StringBuilder(messageString);
+                var builder = new StringBuilder(logMessage);
                 var sw = new StringWriter();
                 new Throwable().printStackTrace(new PrintWriter(sw));
 
                 builder.append('\n').append(sw);
-                messageString = builder.toString();
+                logMessage = builder.toString();
             }
 
-            Log.d(REVANCED_LOG_PREFIX + message.findOuterClassSimpleName(), messageString);
+            if (ex == null) {
+                Log.d(logTag, logMessage);
+            } else {
+                Log.d(logTag, logMessage, ex);
+            }
         }
     }
 

app/src/main/java/app/revanced/integrations/shared/checks/Check.java

@@ -0,0 +1,164 @@
+package app.revanced.integrations.shared.checks;
+
+import static android.text.Html.FROM_HTML_MODE_COMPACT;
+import static app.revanced.integrations.shared.StringRef.str;
+import static app.revanced.integrations.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.integrations.shared.Logger;
+import app.revanced.integrations.shared.Utils;
+import app.revanced.integrations.youtube.settings.Settings;
+
+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 Settings#CHECK_ENVIRONMENT_WARNINGS_ISSUED}
+     * set to -1.
+     */
+    static boolean debugAlwaysShowWarning() {
+        final boolean alwaysShowWarning = Settings.CHECK_ENVIRONMENT_WARNINGS_ISSUED.get() < 0;
+        if (alwaysShowWarning) {
+            Logger.printInfo(() -> "Debug forcing environment check warning to show");
+        }
+
+        return alwaysShowWarning;
+    }
+
+    static boolean shouldRun() {
+        return Settings.CHECK_ENVIRONMENT_WARNINGS_ISSUED.get()
+                < NUMBER_OF_TIMES_TO_IGNORE_WARNING_BEFORE_DISABLING;
+    }
+
+    static void disableForever() {
+        Logger.printInfo(() -> "Environment checks disabled forever");
+
+        Settings.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, Settings.CHECK_ENVIRONMENT_WARNINGS_ISSUED.get());
+                                Settings.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);
+                }
+            }
+        };
+    }
+}

app/src/main/java/app/revanced/integrations/shared/checks/PatchInfo.java

@@ -0,0 +1,28 @@
+package app.revanced.integrations.shared.checks;
+
+// Fields are set by the patch. Do not modify.
+// Fields are not final, because the compiler is inlining them.
+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 = "";
+    }
+}

app/src/main/java/app/revanced/integrations/shared/fixes/slink/BaseFixSLinksPatch.java

@@ -0,0 +1,208 @@
+package app.revanced.integrations.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.integrations.shared.Logger;
+import app.revanced.integrations.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.integrations.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;
+    }
+}

app/src/main/java/app/revanced/integrations/shared/fixes/slink/ResolveResult.java

@@ -0,0 +1,10 @@
+package app.revanced.integrations.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
+}

app/src/main/java/app/revanced/integrations/shared/settings/EnumSetting.java

@@ -2,13 +2,15 @@ package app.revanced.integrations.shared.settings;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import app.revanced.integrations.shared.Logger;
+
 import org.json.JSONException;
 import org.json.JSONObject;
 
 import java.util.Locale;
 import java.util.Objects;
 
+import app.revanced.integrations.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
@@ -98,4 +100,18 @@ public class EnumSetting<T extends Enum<?>> extends Setting<T> {
     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;
+        };
+    }
 }

app/src/main/java/app/revanced/integrations/shared/settings/preference/ReVancedAboutPreference.java

@@ -1,5 +1,6 @@
 package app.revanced.integrations.shared.settings.preference;
 
+import static app.revanced.integrations.shared.StringRef.sf;
 import static app.revanced.integrations.shared.StringRef.str;
 import static app.revanced.integrations.youtube.requests.Route.Method.GET;
 
@@ -71,7 +72,7 @@ public class ReVancedAboutPreference extends Preference {
         return Color.BLACK;
     }
 
-    private String createDialogHtml(ReVancedSocialLink[] socialLinks) {
+    private String createDialogHtml(WebLink[] socialLinks) {
         final boolean isNetworkConnected = Utils.isNetworkConnected();
 
         StringBuilder builder = new StringBuilder();
@@ -122,7 +123,7 @@ public class ReVancedAboutPreference extends Preference {
                 .append("</h2>");
 
         builder.append("<div>");
-        for (ReVancedSocialLink social : socialLinks) {
+        for (WebLink social : socialLinks) {
             builder.append("<div style=\"margin-bottom: 20px;\">");
             builder.append(String.format("<a href=\"%s\">%s</a>", social.url, social.name));
             builder.append("</div>");
@@ -151,7 +152,7 @@ public class ReVancedAboutPreference extends Preference {
     }
 
     private void fetchLinksAndShowDialog(@Nullable ProgressDialog progress) {
-        ReVancedSocialLink[] socialLinks = SocialLinksRoutes.fetchSocialLinks();
+        WebLink[] socialLinks = SocialLinksRoutes.fetchSocialLinks();
         String htmlDialog = createDialogHtml(socialLinks);
 
         Utils.runOnMainThreadNowOrLater(() -> {
@@ -221,19 +222,19 @@ class WebViewDialog extends Dialog {
     }
 }
 
-class ReVancedSocialLink {
+class WebLink {
     final boolean preferred;
     final String name;
     final String url;
 
-    ReVancedSocialLink(JSONObject json) throws JSONException {
+    WebLink(JSONObject json) throws JSONException {
         this(json.getBoolean("preferred"),
                 json.getString("name"),
                 json.getString("url")
         );
     }
 
-    ReVancedSocialLink(boolean preferred, String name, String url) {
+    WebLink(boolean preferred, String name, String url) {
         this.preferred = preferred;
         this.name = name;
         this.url = url;
@@ -251,24 +252,33 @@ class ReVancedSocialLink {
 }
 
 class SocialLinksRoutes {
+    /**
+     * Simple link to the website donate page,
+     * rather than fetching and parsing the donation links using the API.
+     */
+    public static final WebLink DONATE_LINK = new WebLink(true,
+            sf("revanced_settings_about_links_donate").toString(),
+            "https://revanced.app/donate");
+
     /**
      * Links to use if fetch links api call fails.
      */
-    private static final ReVancedSocialLink[] NO_CONNECTION_STATIC_LINKS = {
-            new ReVancedSocialLink(true, "ReVanced.app", "https://revanced.app")
+    private static final WebLink[] NO_CONNECTION_STATIC_LINKS = {
+            new WebLink(true, "ReVanced.app", "https://revanced.app"),
+            DONATE_LINK,
     };
 
     private static final String SOCIAL_LINKS_PROVIDER = "https://api.revanced.app/v2";
     private static final Route.CompiledRoute GET_SOCIAL = new Route(GET, "/socials").compile();
 
     @Nullable
-    private static volatile ReVancedSocialLink[] fetchedLinks;
+    private static volatile WebLink[] fetchedLinks;
 
     static boolean hasFetchedLinks() {
         return fetchedLinks != null;
     }
 
-    static ReVancedSocialLink[] fetchSocialLinks() {
+    static WebLink[] fetchSocialLinks() {
         try {
             if (hasFetchedLinks()) return fetchedLinks;
 
@@ -290,14 +300,17 @@ class SocialLinksRoutes {
             JSONObject json = Requester.parseJSONObjectAndDisconnect(connection);
             JSONArray socials = json.getJSONArray("socials");
 
-            List<ReVancedSocialLink> links = new ArrayList<>();
+            List<WebLink> links = new ArrayList<>();
+
+            links.add(DONATE_LINK); // Show donate link first.
             for (int i = 0, length = socials.length(); i < length; i++) {
-                ReVancedSocialLink link = new ReVancedSocialLink(socials.getJSONObject(i));
+                WebLink link = new WebLink(socials.getJSONObject(i));
                 links.add(link);
             }
+
             Logger.printDebug(() -> "links: " + links);
 
-            return fetchedLinks = links.toArray(new ReVancedSocialLink[0]);
+            return fetchedLinks = links.toArray(new WebLink[0]);
 
         } catch (SocketTimeoutException ex) {
             Logger.printInfo(() -> "Could not fetch social links", ex); // No toast.

app/src/main/java/app/revanced/integrations/syncforreddit/FixSLinksPatch.java

@@ -1,42 +1,24 @@
 package app.revanced.integrations.syncforreddit;
 
-import android.os.StrictMode;
-import app.revanced.integrations.shared.Logger;
+import com.laurencedawson.reddit_sync.ui.activities.WebViewActivity;
 
-import java.net.HttpURLConnection;
-import java.net.URL;
+import app.revanced.integrations.shared.fixes.slink.BaseFixSLinksPatch;
 
-public final class FixSLinksPatch {
-    public static String resolveSLink(String link) {
-        if (link.matches(".*reddit\\.com/r/[^/]+/s/[^/]+")) {
-            Logger.printInfo(() -> "Resolving " + link);
-            try {
-                URL url = new URL(link);
-                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
-                connection.setInstanceFollowRedirects(false);
-                connection.setRequestMethod("HEAD");
+/** @noinspection unused*/
+public class FixSLinksPatch extends BaseFixSLinksPatch {
+    static {
+        INSTANCE = new FixSLinksPatch();
+    }
 
-                // Disable strict mode in order to allow network access on the main thread.
-                // This is not ideal, but it's the easiest solution for now.
-                final var currentPolicy = StrictMode.getThreadPolicy();
-                StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
-                StrictMode.setThreadPolicy(policy);
+    private FixSLinksPatch() {
+        webViewActivityClass = WebViewActivity.class;
+    }
 
-                connection.connect();
-                String location = connection.getHeaderField("location");
-                connection.disconnect();
+    public static boolean patchResolveSLink(String link) {
+        return INSTANCE.resolveSLink(link);
+    }
 
-                // Restore the original strict mode policy.
-                StrictMode.setThreadPolicy(currentPolicy);
-
-                Logger.printInfo(() -> "Resolved " + link + " -> " + location);
-
-                return location;
-            } catch (Exception e) {
-                Logger.printException(() -> "Failed to resolve " + link, e);
-            }
-        }
-
-        return link;
+    public static void patchSetAccessToken(String accessToken) {
+        INSTANCE.setAccessToken(accessToken);
     }
 }

app/src/main/java/app/revanced/integrations/tiktok/spoof/sim/SpoofSimPatch.java

@@ -6,7 +6,7 @@ import app.revanced.integrations.tiktok.settings.Settings;
 @SuppressWarnings("unused")
 public class SpoofSimPatch {
 
-    private static final Boolean ENABLED = Settings.SIM_SPOOF.get();
+    private static final boolean ENABLED = Settings.SIM_SPOOF.get();
 
     public static String getCountryIso(String value) {
         if (ENABLED) {

app/src/main/java/app/revanced/integrations/youtube/ThemeHelper.java

@@ -16,6 +16,7 @@ public class ThemeHelper {
     /**
      * Injection point.
      */
+    @SuppressWarnings("unused")
     public static void setTheme(Enum<?> value) {
         final int newOrdinalValue = value.ordinal();
         if (themeValue != newOrdinalValue) {
@@ -38,14 +39,15 @@ public class ThemeHelper {
     /**
      * Injection point.
      */
+    @SuppressWarnings("SameReturnValue")
     private static String darkThemeResourceName() {
         // Value is changed by Theme patch, if included.
-        return "@android:color/black";
+        return "@color/yt_black3";
     }
 
     /**
      * @return The dark theme color as specified by the Theme patch (if included),
-     *         or the Android color of black.
+     *         or the dark mode background color unpatched YT uses.
      */
     public static int getDarkThemeColor() {
         if (darkThemeColor == null) {
@@ -57,14 +59,15 @@ public class ThemeHelper {
     /**
      * Injection point.
      */
+    @SuppressWarnings("SameReturnValue")
     private static String lightThemeResourceName() {
         // Value is changed by Theme patch, if included.
-        return "@android:color/white";
+        return "@color/yt_white1";
     }
 
     /**
      * @return The light theme color as specified by the Theme patch (if included),
-     *         or the Android color of white.
+     *         or the non dark mode background color unpatched YT uses.
      */
     public static int getLightThemeColor() {
         if (lightThemeColor == null) {

app/src/main/java/app/revanced/integrations/youtube/TrieSearch.java

@@ -380,7 +380,7 @@ public abstract class TrieSearch<T> {
             throw new IllegalArgumentException("endIndex: " + endIndex
                     + " is greater than texToSearchLength: " + textToSearchLength);
         }
-        if (patterns.size() == 0) {
+        if (patterns.isEmpty()) {
             return false; // No patterns were added.
         }
         for (int i = startIndex; i < endIndex; i++) {
@@ -393,7 +393,7 @@ public abstract class TrieSearch<T> {
      * @return Estimated memory size (in kilobytes) of this instance.
      */
     public int getEstimatedMemorySize() {
-        if (patterns.size() == 0) {
+        if (patterns.isEmpty()) {
             return 0;
         }
         // Assume the device has less than 32GB of ram (and can use pointer compression),

app/src/main/java/app/revanced/integrations/youtube/patches/AlternativeThumbnailsPatch.java

@@ -190,16 +190,17 @@ public final class AlternativeThumbnailsPatch {
      * Build the alternative thumbnail url using YouTube provided still video captures.
      *
      * @param decodedUrl Decoded original thumbnail request url.
-     * @return The alternative thumbnail url, or the original url. Both without tracking parameters.
+     * @return The alternative thumbnail url, or if not available NULL.
      */
-    @NonNull
-    private static String buildYoutubeVideoStillURL(@NonNull DecodedThumbnailUrl decodedUrl,
+    @Nullable
+    private static String buildYouTubeVideoStillURL(@NonNull DecodedThumbnailUrl decodedUrl,
                                                     @NonNull ThumbnailQuality qualityToUse) {
         String sanitizedReplacement = decodedUrl.createStillsUrl(qualityToUse, false);
         if (VerifiedQualities.verifyAltThumbnailExist(decodedUrl.videoId, qualityToUse, sanitizedReplacement)) {
             return sanitizedReplacement;
         }
-        return decodedUrl.sanitizedUrl;
+
+        return null;
     }
 
     /**
@@ -284,14 +285,21 @@ public final class AlternativeThumbnailsPatch {
             final boolean includeTracking;
             if (option.useDeArrow && canUseDeArrowAPI()) {
                 includeTracking = false; // Do not include view tracking parameters with API call.
-                final String fallbackUrl = option.useStillImages
-                        ? buildYoutubeVideoStillURL(decodedUrl, qualityToUse)
-                        : decodedUrl.sanitizedUrl;
+                String fallbackUrl = null;
+                if (option.useStillImages) {
+                    fallbackUrl = buildYouTubeVideoStillURL(decodedUrl, qualityToUse);
+                }
+                if (fallbackUrl == null) {
+                    fallbackUrl = decodedUrl.sanitizedUrl;
+                }
 
                 sanitizedReplacementUrl = buildDeArrowThumbnailURL(decodedUrl.videoId, fallbackUrl);
             } else if (option.useStillImages) {
                 includeTracking = true; // Include view tracking parameters if present.
-                sanitizedReplacementUrl = buildYoutubeVideoStillURL(decodedUrl, qualityToUse);
+                sanitizedReplacementUrl = buildYouTubeVideoStillURL(decodedUrl, qualityToUse);
+                if (sanitizedReplacementUrl == null) {
+                    return originalUrl; // Still capture is not available.  Return the untouched original url.
+                }
             } else {
                 return originalUrl; // Recently experienced DeArrow failure and video stills are not enabled.
             }
@@ -345,7 +353,7 @@ public final class AlternativeThumbnailsPatch {
                     return; // Not a thumbnail.
                 }
 
-                Logger.printDebug(() -> "handleCronetSuccess, image not available: " + url);
+                Logger.printDebug(() -> "handleCronetSuccess, image not available: " + decodedUrl.sanitizedUrl);
 
                 ThumbnailQuality quality = ThumbnailQuality.altImageNameToQuality(decodedUrl.imageQuality);
                 if (quality == null) {
@@ -627,14 +635,17 @@ public final class AlternativeThumbnailsPatch {
      * YouTube video thumbnail url, decoded into it's relevant parts.
      */
     private static class DecodedThumbnailUrl {
-        /**
-         * YouTube thumbnail URL prefix. Can be '/vi/' or '/vi_webp/'
-         */
-        private static final String YOUTUBE_THUMBNAIL_PREFIX = "https://i.ytimg.com/vi";
+        private static final String YOUTUBE_THUMBNAIL_DOMAIN = "https://i.ytimg.com/";
 
         @Nullable
         static DecodedThumbnailUrl decodeImageUrl(String url) {
-            final int videoIdStartIndex = url.indexOf('/', YOUTUBE_THUMBNAIL_PREFIX.length()) + 1;
+            final int urlPathStartIndex = url.indexOf('/', "https://".length()) + 1;
+            if (urlPathStartIndex <= 0) return null;
+
+            final int urlPathEndIndex = url.indexOf('/', urlPathStartIndex);
+            if (urlPathEndIndex < 0) return null;
+
+            final int videoIdStartIndex = url.indexOf('/', urlPathEndIndex) + 1;
             if (videoIdStartIndex <= 0) return null;
 
             final int videoIdEndIndex = url.indexOf('/', videoIdStartIndex);
@@ -647,15 +658,15 @@ public final class AlternativeThumbnailsPatch {
             int imageExtensionEndIndex = url.indexOf('?', imageSizeEndIndex);
             if (imageExtensionEndIndex < 0) imageExtensionEndIndex = url.length();
 
-            return new DecodedThumbnailUrl(url, videoIdStartIndex, videoIdEndIndex,
+            return new DecodedThumbnailUrl(url, urlPathStartIndex, urlPathEndIndex, videoIdStartIndex, videoIdEndIndex,
                     imageSizeStartIndex, imageSizeEndIndex, imageExtensionEndIndex);
         }
 
         final String originalFullUrl;
         /** Full usable url, but stripped of any tracking information. */
         final String sanitizedUrl;
-        /** Url up to the video ID. */
-        final String urlPrefix;
+        /** Url path, such as 'vi' or 'vi_webp' */
+        final String urlPath;
         final String videoId;
         /** Quality, such as hq720 or sddefault. */
         final String imageQuality;
@@ -664,11 +675,11 @@ public final class AlternativeThumbnailsPatch {
         /** User view tracking parameters, only present on some images. */
         final String viewTrackingParameters;
 
-        DecodedThumbnailUrl(String fullUrl, int videoIdStartIndex, int videoIdEndIndex,
+        DecodedThumbnailUrl(String fullUrl, int urlPathStartIndex, int urlPathEndIndex, int videoIdStartIndex, int videoIdEndIndex,
                             int imageSizeStartIndex, int imageSizeEndIndex, int imageExtensionEndIndex) {
             originalFullUrl = fullUrl;
             sanitizedUrl = fullUrl.substring(0, imageExtensionEndIndex);
-            urlPrefix = fullUrl.substring(0, videoIdStartIndex);
+            urlPath = fullUrl.substring(urlPathStartIndex, urlPathEndIndex);
             videoId = fullUrl.substring(videoIdStartIndex, videoIdEndIndex);
             imageQuality = fullUrl.substring(imageSizeStartIndex, imageSizeEndIndex);
             imageExtension = fullUrl.substring(imageSizeEndIndex + 1, imageExtensionEndIndex);
@@ -681,9 +692,12 @@ public final class AlternativeThumbnailsPatch {
             // Images could be upgraded to webp if they are not already, but this fails quite often,
             // especially for new videos uploaded in the last hour.
             // And even if alt webp images do exist, sometimes they can load much slower than the original jpg alt images.
-            // (as much as 4x slower has been observed, despite the alt webp image being a smaller file).
+            // (as much as 4x slower network response has been observed, despite the alt webp image being a smaller file).
             StringBuilder builder = new StringBuilder(originalFullUrl.length() + 2);
-            builder.append(urlPrefix);
+            // Many different "i.ytimage.com" domains exist such as "i9.ytimg.com",
+            // but still captures are frequently not available on the other domains (especially newly uploaded videos).
+            // So always use the primary domain for a higher success rate.
+            builder.append(YOUTUBE_THUMBNAIL_DOMAIN).append(urlPath).append('/');
             builder.append(videoId).append('/');
             builder.append(qualityToUse.getAltImageNameToUse());
             builder.append('.').append(imageExtension);

app/src/main/java/app/revanced/integrations/youtube/patches/BackgroundPlaybackPatch.java

@@ -3,7 +3,7 @@ package app.revanced.integrations.youtube.patches;
 import app.revanced.integrations.youtube.shared.PlayerType;
 
 @SuppressWarnings("unused")
-public class MinimizedPlaybackPatch {
+public class BackgroundPlaybackPatch {
 
     /**
      * Injection point.
@@ -35,7 +35,7 @@ public class MinimizedPlaybackPatch {
     /**
      * Injection point.
      */
-    public static boolean overrideMinimizedPlaybackAvailable() {
+    public static boolean overrideBackgroundPlaybackAvailable() {
         // This could be done entirely in the patch,
         // but having a unique method to search for makes manually inspecting the patched apk much easier.
         return true;

app/src/main/java/app/revanced/integrations/youtube/patches/BypassImageRegionRestrictionsPatch.java

@@ -0,0 +1,46 @@
+package app.revanced.integrations.youtube.patches;
+
+import static app.revanced.integrations.youtube.settings.Settings.BYPASS_IMAGE_REGION_RESTRICTIONS;
+
+import java.util.regex.Pattern;
+
+import app.revanced.integrations.shared.Logger;
+import app.revanced.integrations.youtube.settings.Settings;
+
+@SuppressWarnings("unused")
+public final class BypassImageRegionRestrictionsPatch {
+
+    private static final boolean BYPASS_IMAGE_REGION_RESTRICTIONS_ENABLED = BYPASS_IMAGE_REGION_RESTRICTIONS.get();
+
+    private static final String REPLACEMENT_IMAGE_DOMAIN = "https://yt4.ggpht.com";
+
+    /**
+     * YouTube static images domain.  Includes user and channel avatar images and community post images.
+     */
+    private static final Pattern YOUTUBE_STATIC_IMAGE_DOMAIN_PATTERN
+            = Pattern.compile("^https://(yt3|lh[3-6]|play-lh)\\.(ggpht|googleusercontent)\\.com");
+
+    /**
+     * Injection point.  Called off the main thread and by multiple threads at the same time.
+     *
+     * @param originalUrl Image url for all image urls loaded.
+     */
+    public static String overrideImageURL(String originalUrl) {
+        try {
+            if (BYPASS_IMAGE_REGION_RESTRICTIONS_ENABLED) {
+                String replacement = YOUTUBE_STATIC_IMAGE_DOMAIN_PATTERN
+                        .matcher(originalUrl).replaceFirst(REPLACEMENT_IMAGE_DOMAIN);
+
+                if (Settings.DEBUG.get() && !replacement.equals(originalUrl)) {
+                    Logger.printDebug(() -> "Replaced: '" + originalUrl + "' with: '" + replacement + "'");
+                }
+
+                return replacement;
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "overrideImageURL failure", ex);
+        }
+
+        return originalUrl;
+    }
+}

app/src/main/java/app/revanced/integrations/youtube/patches/CheckWatchHistoryDomainNameResolutionPatch.java

@@ -0,0 +1,84 @@
+package app.revanced.integrations.youtube.patches;
+
+import static app.revanced.integrations.shared.StringRef.str;
+
+import android.app.Activity;
+import android.text.Html;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+import app.revanced.integrations.shared.Logger;
+import app.revanced.integrations.shared.Utils;
+import app.revanced.integrations.youtube.settings.Settings;
+
+@SuppressWarnings("unused")
+public class CheckWatchHistoryDomainNameResolutionPatch {
+
+    private static final String HISTORY_TRACKING_ENDPOINT = "s.youtube.com";
+
+    private static final String SINKHOLE_IPV4 = "0.0.0.0";
+    private static final String SINKHOLE_IPV6 = "::";
+
+    private static boolean domainResolvesToValidIP(String host) {
+        try {
+            InetAddress address = InetAddress.getByName(host);
+            String hostAddress = address.getHostAddress();
+
+            if (address.isLoopbackAddress()) {
+                Logger.printDebug(() -> host + " resolves to localhost");
+            } else if (SINKHOLE_IPV4.equals(hostAddress) || SINKHOLE_IPV6.equals(hostAddress)) {
+                Logger.printDebug(() -> host + " resolves to sinkhole ip");
+            } else {
+                return true; // Domain is not blocked.
+            }
+        } catch (UnknownHostException e) {
+            Logger.printDebug(() -> host + " failed to resolve");
+        }
+
+        return false;
+    }
+
+    /**
+     * Injection point.
+     *
+     * Checks if s.youtube.com is blacklisted and playback history will fail to work.
+     */
+    public static void checkDnsResolver(Activity context) {
+        if (!Utils.isNetworkConnected() || !Settings.CHECK_WATCH_HISTORY_DOMAIN_NAME.get()) return;
+
+        Utils.runOnBackgroundThread(() -> {
+            try {
+                // If the user has a flaky DNS server, or they just lost internet connectivity
+                // and the isNetworkConnected() check has not detected it yet (it can take a few
+                // seconds after losing connection), then the history tracking endpoint will
+                // show a resolving error but it's actually an internet connection problem.
+                //
+                // Prevent this false positive by verify youtube.com resolves.
+                // If youtube.com does not resolve, then it's not a watch history domain resolving error
+                // because the entire app will not work since no domains are resolving.
+                if (domainResolvesToValidIP(HISTORY_TRACKING_ENDPOINT)
+                        || !domainResolvesToValidIP("youtube.com")) {
+                    return;
+                }
+
+                Utils.runOnMainThread(() -> {
+                    var alert = new android.app.AlertDialog.Builder(context)
+                            .setTitle(str("revanced_check_watch_history_domain_name_dialog_title"))
+                            .setMessage(Html.fromHtml(str("revanced_check_watch_history_domain_name_dialog_message")))
+                            .setIconAttribute(android.R.attr.alertDialogIcon)
+                            .setPositiveButton(android.R.string.ok, (dialog, which) -> {
+                                dialog.dismiss();
+                            }).setNegativeButton(str("revanced_check_watch_history_domain_name_dialog_ignore"), (dialog, which) -> {
+                                Settings.CHECK_WATCH_HISTORY_DOMAIN_NAME.save(false);
+                                dialog.dismiss();
+                            }).create();
+
+                    Utils.showDialog(context, alert, false, null);
+                });
+            } catch (Exception ex) {
+                Logger.printException(() -> "checkDnsResolver failure", ex);
+            }
+        });
+    }
+}

app/src/main/java/app/revanced/integrations/youtube/patches/CustomPlayerOverlayOpacityPatch.java

@@ -1,22 +1,33 @@
 package app.revanced.integrations.youtube.patches;
 
+import static app.revanced.integrations.shared.StringRef.str;
+
 import android.widget.ImageView;
 
-import app.revanced.integrations.youtube.settings.Settings;
 import app.revanced.integrations.shared.Utils;
+import app.revanced.integrations.youtube.settings.Settings;
 
 @SuppressWarnings("unused")
 public class CustomPlayerOverlayOpacityPatch {
 
-    public static void changeOpacity(ImageView imageView) {
+    private static final int PLAYER_OVERLAY_OPACITY_LEVEL;
+
+    static {
         int opacity = Settings.PLAYER_OVERLAY_OPACITY.get();
 
         if (opacity < 0 || opacity > 100) {
-            Utils.showToastLong("Player overlay opacity must be between 0-100");
+            Utils.showToastLong(str("revanced_player_overlay_opacity_invalid_toast"));
             Settings.PLAYER_OVERLAY_OPACITY.resetToDefault();
             opacity = Settings.PLAYER_OVERLAY_OPACITY.defaultValue;
         }
 
-        imageView.setImageAlpha((opacity * 255) / 100);
+        PLAYER_OVERLAY_OPACITY_LEVEL = (opacity * 255) / 100;
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void changeOpacity(ImageView imageView) {
+        imageView.setImageAlpha(PLAYER_OVERLAY_OPACITY_LEVEL);
     }
 }

app/src/main/java/app/revanced/integrations/youtube/patches/DisableAutoCaptionsPatch.java

@@ -1,6 +1,7 @@
 package app.revanced.integrations.youtube.patches;
 
 import app.revanced.integrations.youtube.settings.Settings;
+import app.revanced.integrations.youtube.shared.PlayerType;
 
 @SuppressWarnings("unused")
 public class DisableAutoCaptionsPatch {
@@ -11,7 +12,9 @@ public class DisableAutoCaptionsPatch {
     public static boolean captionsButtonDisabled;
 
     public static boolean autoCaptionsEnabled() {
-        return Settings.AUTO_CAPTIONS.get();
+        return Settings.AUTO_CAPTIONS.get()
+                // Do not use auto captions for Shorts.
+                && !PlayerType.getCurrent().isNoneHiddenOrSlidingMinimized();
     }
 
 }

app/src/main/java/app/revanced/integrations/youtube/patches/DisablePreciseSeekingGesturePatch.java

@@ -1,20 +1,10 @@
 package app.revanced.integrations.youtube.patches;
 
-import android.view.MotionEvent;
-import android.view.VelocityTracker;
-
 import app.revanced.integrations.youtube.settings.Settings;
 
 @SuppressWarnings("unused")
 public final class DisablePreciseSeekingGesturePatch {
-    /**
-     * Disables the gesture that is used to seek precisely.
-     * @param tracker The velocity tracker that is used to determine the gesture.
-     * @param event The motion event that is used to determine the gesture.
-     */
-    public static void disableGesture(VelocityTracker tracker, MotionEvent event) {
-        if (Settings.DISABLE_PRECISE_SEEKING_GESTURE.get()) return;
-
-        tracker.addMovement(event);
+    public static boolean isGestureDisabled() {
+        return Settings.DISABLE_PRECISE_SEEKING_GESTURE.get();
     }
 }

app/src/main/java/app/revanced/integrations/youtube/patches/DisableSuggestedVideoEndScreenPatch.java

@@ -1,13 +1,8 @@
 package app.revanced.integrations.youtube.patches;
 
 import android.annotation.SuppressLint;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.ViewTreeObserver;
 import android.widget.ImageView;
 
-import androidx.annotation.NonNull;
-import app.revanced.integrations.shared.Logger;
 import app.revanced.integrations.youtube.settings.Settings;
 
 /** @noinspection unused*/

app/src/main/java/app/revanced/integrations/youtube/patches/EnableTabletLayoutPatch.java

@@ -1,10 +0,0 @@
-package app.revanced.integrations.youtube.patches;
-
-import app.revanced.integrations.youtube.settings.Settings;
-
-@SuppressWarnings("unused")
-public final class EnableTabletLayoutPatch {
-    public static boolean enableTabletLayout() {
-        return Settings.TABLET_LAYOUT.get();
-    }
-}

app/src/main/java/app/revanced/integrations/youtube/patches/HideAutoplayButtonPatch.java

@@ -4,7 +4,13 @@ import app.revanced.integrations.youtube.settings.Settings;
 
 @SuppressWarnings("unused")
 public class HideAutoplayButtonPatch {
-    public static boolean isButtonShown() {
-        return !Settings.HIDE_AUTOPLAY_BUTTON.get();
+
+    private static final boolean HIDE_AUTOPLAY_BUTTON_ENABLED = Settings.HIDE_AUTOPLAY_BUTTON.get();
+
+    /**
+     * Injection point.
+     */
+    public static boolean hideAutoPlayButton() {
+        return HIDE_AUTOPLAY_BUTTON_ENABLED;
     }
 }