chore: Release v1.17.0-dev.6 [skip ci]

# [1.17.0-dev.6](https://github.com/ReVanced/revanced-integrations/compare/v1.17.0-dev.5...v1.17.0-dev.6) (2024-10-24)

### Bug Fixes

* **YouTube - Hide ads:** Hide new type of ad ([b94d2da](b94d2da0b2))

.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
@@ -49,5 +51,5 @@ jobs:
 
       - name: Release
         env:
-          GITHUB_TOKEN: ${{ secrets.REPOSITORY_PUSH_ACCESS }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: npm exec semantic-release

.releaserc

@@ -23,7 +23,8 @@
         "assets": [
           "CHANGELOG.md",
           "gradle.properties"
-        ]
+        ],
+        "message": "chore: Release v${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
       }
     ],
     [

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/Utils.java

@@ -1,6 +1,7 @@
 package app.revanced.integrations.shared;
 
 import android.annotation.SuppressLint;
+import android.app.*;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageInfo;
@@ -8,6 +9,7 @@ import android.content.pm.PackageManager;
 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;
@@ -104,7 +106,7 @@ public class Utils {
     }
 
     /**
-     * Hide a view by setting its layout height and width to 1dp.
+     * 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.
@@ -263,6 +265,20 @@ public class Utils {
         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.
@@ -273,7 +289,6 @@ public class Utils {
                                                   @NonNull MatchFilter<View> filter) {
         for (int i = 0, childCount = viewGroup.getChildCount(); i < childCount; i++) {
             View childAt = viewGroup.getChildAt(i);
-            Logger.printDebug(() -> "View id: " + childAt.getId() + " tag: " + childAt.getTag());
 
             if (filter.matches(childAt)) {
                 //noinspection unchecked
@@ -285,6 +300,7 @@ public class Utils {
                 if (match != null) return match;
             }
         }
+
         return null;
     }
 
@@ -363,6 +379,99 @@ public class Utils {
         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
      */
@@ -612,4 +721,21 @@ public class Utils {
             pref.setOrder(order);
         }
     }
+
+    /**
+     * 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);
+        }
+    }
 }

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/settings/Setting.java

@@ -208,6 +208,8 @@ public abstract class Setting<T> {
      * 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);

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

@@ -11,6 +11,7 @@ import androidx.annotation.Nullable;
 
 import app.revanced.integrations.shared.Logger;
 import app.revanced.integrations.shared.Utils;
+import app.revanced.integrations.shared.settings.BaseSettings;
 import app.revanced.integrations.shared.settings.BooleanSetting;
 import app.revanced.integrations.shared.settings.Setting;
 
@@ -141,8 +142,13 @@ public abstract class AbstractPreferenceFragment extends PreferenceFragment {
             } 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);
                 }
             }
         }

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

@@ -66,6 +66,8 @@ public class ImportExportPreference extends EditTextPreference implements Prefer
     @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());

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/shared/settings/preference/ResettableEditTextPreference.java

@@ -7,6 +7,8 @@ import android.preference.EditTextPreference;
 import android.util.AttributeSet;
 import android.widget.Button;
 import android.widget.EditText;
+
+import app.revanced.integrations.shared.Utils;
 import app.revanced.integrations.shared.settings.Setting;
 import app.revanced.integrations.shared.Logger;
 
@@ -33,6 +35,8 @@ public class ResettableEditTextPreference extends EditTextPreference {
     @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);

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

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

app/src/main/java/app/revanced/integrations/twitter/patches/links/ChangeLinkSharingDomainPatch.java

@@ -0,0 +1,16 @@
+package app.revanced.integrations.twitter.patches.links;
+
+public final class ChangeLinkSharingDomainPatch {
+    private static final String DOMAIN_NAME = "https://fxtwitter.com";
+    private static final String LINK_FORMAT = "%s/%s/status/%s";
+
+    public static String formatResourceLink(Object... formatArgs) {
+        String username = (String) formatArgs[0];
+        String tweetId = (String) formatArgs[1];
+        return String.format(LINK_FORMAT, DOMAIN_NAME, username, tweetId);
+    }
+
+    public static String formatLink(long tweetId, String username) {
+        return String.format(LINK_FORMAT, DOMAIN_NAME, username, tweetId);
+    }
+}

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

@@ -8,7 +8,9 @@ public class BackgroundPlaybackPatch {
     /**
      * Injection point.
      */
-    public static boolean playbackIsNotShort() {
+    public static boolean allowBackgroundPlayback(boolean original) {
+        if (original) return true;
+
         // Steps to verify most edge cases:
         // 1. Open a regular video
         // 2. Minimize app (PIP should appear)

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

@@ -1,21 +1,129 @@
 package app.revanced.integrations.youtube.patches;
 
+import static java.lang.Boolean.FALSE;
+import static java.lang.Boolean.TRUE;
+
 import android.content.Intent;
-import android.net.Uri;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import app.revanced.integrations.shared.Logger;
 import app.revanced.integrations.youtube.settings.Settings;
 
 @SuppressWarnings("unused")
 public final class ChangeStartPagePatch {
-    public static void changeIntent(final Intent intent) {
-        final var startPage = Settings.START_PAGE.get();
-        if (startPage.isEmpty()) return;
 
-        Logger.printDebug(() -> "Changing start page to " + startPage);
+    public enum StartPage {
+        /**
+         * Unmodified type, and same as un-patched.
+         */
+        ORIGINAL("", null),
 
-        if (startPage.startsWith("www"))
-            intent.setData(Uri.parse(startPage));
-        else
-            intent.setAction("com.google.android.youtube.action." + startPage);
+        /**
+         * Browse id.
+         */
+        BROWSE("FEguide_builder", TRUE),
+        EXPLORE("FEexplore", TRUE),
+        HISTORY("FEhistory", TRUE),
+        LIBRARY("FElibrary", TRUE),
+        MOVIE("FEstorefront", TRUE),
+        SUBSCRIPTIONS("FEsubscriptions", TRUE),
+        TRENDING("FEtrending", TRUE),
+
+        /**
+         * Channel id, this can be used as a browseId.
+         */
+        GAMING("UCOpNcN46UbXVtpKMrmU4Abg", TRUE),
+        LIVE("UC4R8DWoMoI7CAwX8_LjQHig", TRUE),
+        MUSIC("UC-9-kyTW8ZkZNDHQJ6FgpwQ", TRUE),
+        SPORTS("UCEgdi0XIXXZ-qJOFPf4JSKw", TRUE),
+
+        /**
+         * Playlist id, this can be used as a browseId.
+         */
+        LIKED_VIDEO("VLLL", TRUE),
+        WATCH_LATER("VLWL", TRUE),
+
+        /**
+         * Intent action.
+         */
+        SEARCH("com.google.android.youtube.action.open.search", FALSE),
+        SHORTS("com.google.android.youtube.action.open.shorts", FALSE);
+
+        @Nullable
+        final Boolean isBrowseId;
+
+        @NonNull
+        final String id;
+
+        StartPage(@NonNull String id, @Nullable Boolean isBrowseId) {
+            this.id = id;
+            this.isBrowseId = isBrowseId;
+        }
+
+        private boolean isBrowseId() {
+            return TRUE.equals(isBrowseId);
+        }
+
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+        private boolean isIntentAction() {
+            return FALSE.equals(isBrowseId);
+        }
+    }
+
+    /**
+     * Intent action when YouTube is cold started from the launcher.
+     * <p>
+     * If you don't check this, the hooking will also apply in the following cases:
+     * Case 1. The user clicked Shorts button on the YouTube shortcut.
+     * Case 2. The user clicked Shorts button on the YouTube widget.
+     * In this case, instead of opening Shorts, the start page specified by the user is opened.
+     */
+    private static final String ACTION_MAIN = "android.intent.action.MAIN";
+
+    private static final StartPage START_PAGE = Settings.CHANGE_START_PAGE.get();
+
+    /**
+     * There is an issue where the back button on the toolbar doesn't work properly.
+     * As a workaround for this issue, instead of overriding the browserId multiple times, just override it once.
+     */
+    private static boolean appLaunched = false;
+
+    public static String overrideBrowseId(@NonNull String original) {
+        if (!START_PAGE.isBrowseId()) {
+            return original;
+        }
+
+        if (appLaunched) {
+            Logger.printDebug(() -> "Ignore override browseId as the app already launched");
+            return original;
+        }
+        appLaunched = true;
+
+        Logger.printDebug(() -> "Changing browseId to " + START_PAGE.id);
+        return START_PAGE.id;
+    }
+
+    public static void overrideIntentAction(@NonNull Intent intent) {
+        if (!START_PAGE.isIntentAction()) {
+            return;
+        }
+
+        if (!ACTION_MAIN.equals(intent.getAction())) {
+            Logger.printDebug(() -> "Ignore override intent action" +
+                    " as the current activity is not the entry point of the application");
+            return;
+        }
+
+        if (appLaunched) {
+            Logger.printDebug(() -> "Ignore override intent action as the app already launched");
+            return;
+        }
+        appLaunched = true;
+
+        final String intentAction = START_PAGE.id;
+        Logger.printDebug(() -> "Changing intent action to " + intentAction);
+        intent.setAction(intentAction);
     }
 }

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/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/HideAlbumCardsPatch.java

@@ -1,14 +0,0 @@
-package app.revanced.integrations.youtube.patches;
-
-import android.view.View;
-
-import app.revanced.integrations.youtube.settings.Settings;
-import app.revanced.integrations.shared.Utils;
-
-@SuppressWarnings("unused")
-public class HideAlbumCardsPatch {
-    public static void hideAlbumCard(View view) {
-        if (!Settings.HIDE_ALBUM_CARDS.get()) return;
-        Utils.hideViewByLayoutParams(view);
-    }
-}

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

@@ -1,16 +0,0 @@
-package app.revanced.integrations.youtube.patches;
-
-import app.revanced.integrations.youtube.settings.Settings;
-
-@SuppressWarnings("unused")
-public class HideAutoplayButtonPatch {
-
-    private static final boolean HIDE_AUTOPLAY_BUTTON_ENABLED = Settings.HIDE_AUTOPLAY_BUTTON.get();
-
-    /**
-     * Injection point.
-     */
-    public static boolean hideAutoPlayButton() {
-        return HIDE_AUTOPLAY_BUTTON_ENABLED;
-    }
-}

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

@@ -1,13 +0,0 @@
-package app.revanced.integrations.youtube.patches;
-
-import android.widget.ImageView;
-
-import app.revanced.integrations.youtube.settings.Settings;
-
-@SuppressWarnings("unused")
-public class HideCaptionsButtonPatch {
-    //Used by app.revanced.patches.youtube.layout.hidecaptionsbutton.patch.HideCaptionsButtonPatch
-    public static void hideCaptionsButton(ImageView imageView) {
-        imageView.setVisibility(Settings.HIDE_CAPTIONS_BUTTON.get() ? ImageView.GONE : ImageView.VISIBLE);
-    }
-}

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

@@ -1,14 +0,0 @@
-package app.revanced.integrations.youtube.patches;
-
-import android.view.View;
-
-import app.revanced.integrations.youtube.settings.Settings;
-
-@SuppressWarnings("unused")
-public class HideCastButtonPatch {
-
-    // Used by app.revanced.patches.youtube.layout.castbutton.patch.HideCastButonPatch
-    public static int getCastButtonOverrideV2(int original) {
-        return Settings.HIDE_CAST_BUTTON.get() ? View.GONE : original;
-    }
-}

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

@@ -1,15 +0,0 @@
-package app.revanced.integrations.youtube.patches;
-
-import android.view.View;
-
-import app.revanced.integrations.youtube.settings.Settings;
-import app.revanced.integrations.shared.Utils;
-
-@SuppressWarnings("unused")
-public class HideCrowdfundingBoxPatch {
-    //Used by app.revanced.patches.youtube.layout.hidecrowdfundingbox.patch.HideCrowdfundingBoxPatch
-    public static void hideCrowdfundingBox(View view) {
-        if (!Settings.HIDE_CROWDFUNDING_BOX.get()) return;
-        Utils.hideViewByLayoutParams(view);
-    }
-}

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

@@ -1,27 +0,0 @@
-package app.revanced.integrations.youtube.patches;
-
-import android.view.View;
-
-import app.revanced.integrations.youtube.settings.Settings;
-import app.revanced.integrations.shared.Utils;
-
-@SuppressWarnings("unused")
-public final class HideFilterBarPatch {
-    public static int hideInFeed(final int height) {
-        if (Settings.HIDE_FILTER_BAR_FEED_IN_FEED.get()) return 0;
-
-        return height;
-    }
-
-    public static void hideInRelatedVideos(final View chipView) {
-        if (!Settings.HIDE_FILTER_BAR_FEED_IN_RELATED_VIDEOS.get()) return;
-
-        Utils.hideViewByLayoutParams(chipView);
-    }
-
-    public static int hideInSearch(final int height) {
-        if (Settings.HIDE_FILTER_BAR_FEED_IN_SEARCH.get()) return 0;
-
-        return height;
-    }
-}

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

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

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

@@ -1,17 +0,0 @@
-package app.revanced.integrations.youtube.patches;
-
-import app.revanced.integrations.youtube.settings.Settings;
-
-@SuppressWarnings("unused")
-public final class HidePlayerButtonsPatch {
-
-    /**
-     * Injection point.
-     */
-    public static boolean previousOrNextButtonIsVisible(boolean previousOrNextButtonVisible) {
-        if (Settings.HIDE_PLAYER_BUTTONS.get()) {
-            return false;
-        }
-        return previousOrNextButtonVisible;
-    }
-}

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

@@ -0,0 +1,72 @@
+package app.revanced.integrations.youtube.patches;
+
+import android.view.View;
+import android.widget.ImageView;
+
+import app.revanced.integrations.shared.Logger;
+import app.revanced.integrations.shared.Utils;
+import app.revanced.integrations.youtube.settings.Settings;
+
+@SuppressWarnings("unused")
+public final class HidePlayerOverlayButtonsPatch {
+
+    private static final boolean HIDE_AUTOPLAY_BUTTON_ENABLED = Settings.HIDE_AUTOPLAY_BUTTON.get();
+
+    /**
+     * Injection point.
+     */
+    public static boolean hideAutoPlayButton() {
+        return HIDE_AUTOPLAY_BUTTON_ENABLED;
+    }
+
+    /**
+     * Injection point.
+     */
+    public static int getCastButtonOverrideV2(int original) {
+        return Settings.HIDE_CAST_BUTTON.get() ? View.GONE : original;
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void hideCaptionsButton(ImageView imageView) {
+        imageView.setVisibility(Settings.HIDE_CAPTIONS_BUTTON.get() ? ImageView.GONE : ImageView.VISIBLE);
+    }
+
+    private static final boolean HIDE_PLAYER_PREVIOUS_NEXT_BUTTONS_ENABLED
+            = Settings.HIDE_PLAYER_PREVIOUS_NEXT_BUTTONS.get();
+
+    private static final int PLAYER_CONTROL_PREVIOUS_BUTTON_TOUCH_AREA_ID =
+            Utils.getResourceIdentifier("player_control_previous_button_touch_area", "id");
+
+    private static final int PLAYER_CONTROL_NEXT_BUTTON_TOUCH_AREA_ID =
+            Utils.getResourceIdentifier("player_control_next_button_touch_area", "id");
+
+    /**
+     * Injection point.
+     */
+    public static void hidePreviousNextButtons(View parentView) {
+        if (!HIDE_PLAYER_PREVIOUS_NEXT_BUTTONS_ENABLED) {
+            return;
+        }
+
+        // Must use a deferred call to main thread to hide the button.
+        // Otherwise the layout crashes if set to hidden now.
+        Utils.runOnMainThread(() -> {
+            hideView(parentView, PLAYER_CONTROL_PREVIOUS_BUTTON_TOUCH_AREA_ID);
+            hideView(parentView, PLAYER_CONTROL_NEXT_BUTTON_TOUCH_AREA_ID);
+        });
+    }
+
+    private static void hideView(View parentView, int resourceId) {
+        View nextPreviousButton = parentView.findViewById(resourceId);
+
+        if (nextPreviousButton == null) {
+            Logger.printException(() -> "Could not find player previous/next button");
+            return;
+        }
+
+        Logger.printDebug(() -> "Hiding previous/next button");
+        Utils.hideViewByRemovingFromParentUnderCondition(true, nextPreviousButton);
+    }
+}

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

@@ -0,0 +1,44 @@
+package app.revanced.integrations.youtube.patches;
+
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.widget.ImageView;
+
+import app.revanced.integrations.shared.Logger;
+
+@SuppressWarnings("unused")
+public class PlayerControlsPatch {
+    /**
+     * Injection point.
+     */
+    public static void setFullscreenCloseButton(ImageView imageButton) {
+        // Add a global listener, since the protected method
+        // View#onVisibilityChanged() does not have any call backs.
+        imageButton.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
+            int lastVisibility = View.VISIBLE;
+
+            @Override
+            public void onGlobalLayout() {
+                try {
+                    final int visibility = imageButton.getVisibility();
+                    if (lastVisibility != visibility) {
+                        lastVisibility = visibility;
+
+                        Logger.printDebug(() -> "fullscreen button visibility: "
+                                + (visibility == View.VISIBLE ? "VISIBLE" :
+                                        visibility == View.GONE ? "GONE" : "INVISIBLE"));
+
+                        fullscreenButtonVisibilityChanged(visibility == View.VISIBLE);
+                    }
+                } catch (Exception ex) {
+                    Logger.printDebug(() -> "OnGlobalLayoutListener failure", ex);
+                }
+            }
+        });
+    }
+
+    // noinspection EmptyMethod
+    public static void fullscreenButtonVisibilityChanged(boolean isVisible) {
+        // Code added during patching.
+    }
+}