chore(release): 1.11.1-dev.3 [skip ci]

## [1.11.1-dev.3](https://github.com/ReVanced/revanced-integrations/compare/v1.11.1-dev.2...v1.11.1-dev.3) (2024-07-05)

### Bug Fixes

* **YouTube - Hide ads:** Hide new types of home feed button ads ([#662](https://github.com/ReVanced/revanced-integrations/issues/662)) ([ff2637c](ff2637cb4c))
* **YouTube - Settings:** Move some settings to different menus, adjust default setting values ([#661](https://github.com/ReVanced/revanced-integrations/issues/661)) ([77533cf](77533cf3d6))

.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

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

@@ -1,32 +1,37 @@
 package app.revanced.integrations.shared;
 
+import static app.revanced.integrations.shared.StringRef.str;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.AlertDialog;
 import android.app.SearchManager;
+import android.content.Context;
+import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.net.Uri;
 import android.os.Build;
+import android.os.PowerManager;
+import android.provider.Settings;
+
 import androidx.annotation.RequiresApi;
 
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.util.Objects;
-
-import static app.revanced.integrations.shared.StringRef.str;
 
 /**
  * @noinspection unused
  */
 public class GmsCoreSupport {
     private static final String GMS_CORE_PACKAGE_NAME
-            = getGmsCoreVendor() + ".android.gms";
+            = getGmsCoreVendorGroupId() + ".android.gms";
+    private static final Uri GMS_CORE_PROVIDER
+            = Uri.parse("content://" + getGmsCoreVendorGroupId() + ".android.gsf.gservices/prefix");
     private static final String DONT_KILL_MY_APP_LINK
             = "https://dontkillmyapp.com";
-    private static final Uri GMS_CORE_PROVIDER
-            = Uri.parse("content://" + getGmsCoreVendor() + ".android.gsf.gservices/prefix");
-
-    private static void open(String queryOrLink, String message) {
-        Utils.showToastLong(message);
 
+    private static void open(String queryOrLink) {
         Intent intent;
         try {
             // Check if queryOrLink is a valid URL.
@@ -40,48 +45,101 @@ public class GmsCoreSupport {
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
         Utils.getContext().startActivity(intent);
 
-        // Gracefully exit, otherwise without Gms the app crashes and Android can nag the user.
+        // Gracefully exit, otherwise the broken app will continue to run.
         System.exit(0);
     }
 
+    private static void showBatteryOptimizationDialog(Activity context,
+                                                      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);
+    }
+
     /**
      * Injection point.
      */
     @RequiresApi(api = Build.VERSION_CODES.N)
-    public static void checkAvailability() {
-        var context = Objects.requireNonNull(Utils.getContext());
-
+    public static void checkGmsCore(Activity context) {
         try {
-            context.getPackageManager().getPackageInfo(GMS_CORE_PACKAGE_NAME, PackageManager.GET_ACTIVITIES);
-        } catch (PackageManager.NameNotFoundException exception) {
-            Logger.printInfo(() -> "GmsCore was not found", exception);
-            open(getGmsCoreDownload(), str("gms_core_not_installed_warning"));
-            return;
-        }
+            // Verify GmsCore is installed.
+            try {
+                PackageManager manager = context.getPackageManager();
+                manager.getPackageInfo(GMS_CORE_PACKAGE_NAME, PackageManager.GET_ACTIVITIES);
+            } catch (PackageManager.NameNotFoundException exception) {
+                Logger.printInfo(() -> "GmsCore was not found");
+                // Cannot show a dialog and must show a toast,
+                // because on some installations the app crashes before a dialog can be displayed.
+                Utils.showToastLong(str("gms_core_toast_not_installed_message"));
+                open(getGmsCoreDownload());
+                return;
+            }
 
-        try (var client = context.getContentResolver().acquireContentProviderClient(GMS_CORE_PROVIDER)) {
-            if (client != null) return;
+            // Check if GmsCore is running in the background.
+            try (var client = context.getContentResolver().acquireContentProviderClient(GMS_CORE_PROVIDER)) {
+                if (client == null) {
+                    Logger.printInfo(() -> "GmsCore is not running in the background");
 
-            Logger.printInfo(() -> "GmsCore is not running in the background");
-            open(DONT_KILL_MY_APP_LINK, str("gms_core_not_running_warning"));
+                    showBatteryOptimizationDialog(context,
+                            "gms_core_dialog_not_whitelisted_not_allowed_in_background_message",
+                            "gms_core_dialog_open_website_text",
+                            (dialog, id) -> open(DONT_KILL_MY_APP_LINK));
+                    return;
+                }
+            }
+
+            // Check if GmsCore is whitelisted from battery optimizations.
+            if (batteryOptimizationsEnabled(context)) {
+                Logger.printInfo(() -> "GmsCore is not whitelisted from battery optimizations");
+                showBatteryOptimizationDialog(context,
+                        "gms_core_dialog_not_whitelisted_using_battery_optimizations_message",
+                        "gms_core_dialog_continue_text",
+                        (dialog, id) -> openGmsCoreDisableBatteryOptimizationsIntent(context));
+            }
         } catch (Exception ex) {
-            Logger.printException(() -> "Could not check GmsCore background task", ex);
+            Logger.printException(() -> "checkGmsCore failure", ex);
         }
     }
 
+    @SuppressLint("BatteryLife") // Permission is part of GmsCore
+    private static void openGmsCoreDisableBatteryOptimizationsIntent(Activity activity) {
+        Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
+        intent.setData(Uri.fromParts("package", GMS_CORE_PACKAGE_NAME, null));
+        activity.startActivityForResult(intent, 0);
+    }
+
+    /**
+     * @return If GmsCore is not whitelisted from battery optimizations.
+     */
+    private static boolean batteryOptimizationsEnabled(Context context) {
+        var powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+        return !powerManager.isIgnoringBatteryOptimizations(GMS_CORE_PACKAGE_NAME);
+    }
+
     private static String getGmsCoreDownload() {
-        final var vendor = getGmsCoreVendor();
+        final var vendorGroupId = getGmsCoreVendorGroupId();
         //noinspection SwitchStatementWithTooFewBranches
-        switch (vendor) {
+        switch (vendorGroupId) {
             case "app.revanced":
                 return "https://github.com/revanced/gmscore/releases/latest";
             default:
-                return vendor + ".android.gms";
+                return vendorGroupId + ".android.gms";
         }
     }
 
     // Modified by a patch. Do not touch.
-    private static String getGmsCoreVendor() {
+    private static String getGmsCoreVendorGroupId() {
         return "app.revanced";
     }
 }

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
@@ -17,7 +19,7 @@ import java.util.Objects;
  * All saved JSON text is converted to lowercase to keep the output less obnoxious.
  */
 @SuppressWarnings("unused")
-public class EnumSetting<T extends Enum> extends Setting<T> {
+public class EnumSetting<T extends Enum<?>> extends Setting<T> {
     public EnumSetting(String key, T defaultValue) {
         super(key, defaultValue);
     }
@@ -72,7 +74,7 @@ public class EnumSetting<T extends Enum> extends Setting<T> {
     @NonNull
     private T getEnumFromString(String enumName) {
         //noinspection ConstantConditions
-        for (Enum value : defaultValue.getClass().getEnumConstants()) {
+        for (Enum<?> value : defaultValue.getClass().getEnumConstants()) {
             if (value.name().equalsIgnoreCase(enumName)) {
                 // noinspection unchecked
                 return (T) 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/Setting.java

@@ -224,6 +224,7 @@ public abstract class Setting<T> {
         if (!oldPrefs.preferences.contains(settingKey)) {
             return; // Nothing to do.
         }
+
         Object newValue = setting.get();
         final Object migratedValue;
         if (setting instanceof BooleanSetting) {
@@ -238,13 +239,17 @@ public abstract class Setting<T> {
             migratedValue = oldPrefs.getString(settingKey, (String) newValue);
         } else {
             Logger.printException(() -> "Unknown setting: " + setting);
+            // Remove otherwise it'll show a toast on every launch
+            oldPrefs.preferences.edit().remove(settingKey).apply();
             return;
         }
+
         oldPrefs.preferences.edit().remove(settingKey).apply(); // Remove the old setting.
         if (migratedValue.equals(newValue)) {
             Logger.printDebug(() -> "Value does not need migrating: " + settingKey);
             return; // Old value is already equal to the new setting value.
         }
+
         Logger.printDebug(() -> "Migrating old preference value into current preference: " + settingKey);
         //noinspection unchecked
         setting.save(migratedValue);

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

@@ -16,10 +16,7 @@ import app.revanced.integrations.shared.settings.Setting;
 
 import static app.revanced.integrations.shared.StringRef.str;
 
-/**
- *
- *
- * @noinspection deprecation, DataFlowIssue , unused */
+@SuppressWarnings({"unused", "deprecation"})
 public abstract class AbstractPreferenceFragment extends PreferenceFragment {
     /**
      * Indicates that if a preference changes,

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

@@ -15,7 +15,7 @@ import app.revanced.integrations.shared.Utils;
 
 import static app.revanced.integrations.shared.StringRef.str;
 
-/** @noinspection deprecation, unused */
+@SuppressWarnings({"unused", "deprecation"})
 public class ImportExportPreference extends EditTextPreference implements Preference.OnPreferenceClickListener {
 
     private String existingSettings;

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

@@ -14,7 +14,7 @@ import java.util.Objects;
 
 import static app.revanced.integrations.shared.StringRef.str;
 
-@SuppressWarnings("unused")
+@SuppressWarnings({"unused", "deprecation"})
 public class ResettableEditTextPreference extends EditTextPreference {
 
     public ResettableEditTextPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
@@ -33,7 +33,7 @@ public class ResettableEditTextPreference extends EditTextPreference {
     @Override
     protected void onPrepareDialogBuilder(AlertDialog.Builder builder) {
         super.onPrepareDialogBuilder(builder);
-        Setting setting = Setting.getSettingFromPath(getKey());
+        Setting<?> setting = Setting.getSettingFromPath(getKey());
         if (setting != null) {
             builder.setNeutralButton(str("revanced_settings_reset"), null);
         }
@@ -50,7 +50,7 @@ public class ResettableEditTextPreference extends EditTextPreference {
         }
         button.setOnClickListener(v -> {
             try {
-                Setting setting = Objects.requireNonNull(Setting.getSettingFromPath(getKey()));
+                Setting<?> setting = Objects.requireNonNull(Setting.getSettingFromPath(getKey()));
                 String defaultStringValue = setting.defaultValue.toString();
                 EditText editText = getEditText();
                 editText.setText(defaultStringValue);

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

@@ -53,7 +53,7 @@ public class SharedPrefCategory {
     /**
      * @param value a NULL parameter removes the value from the preferences
      */
-    public void saveEnumAsString(@NonNull String key, @Nullable Enum value) {
+    public void saveEnumAsString(@NonNull String key, @Nullable Enum<?> value) {
         saveObjectAsString(key, value);
     }
 
@@ -98,7 +98,7 @@ public class SharedPrefCategory {
     }
 
     @NonNull
-    public <T extends Enum> T getEnum(@NonNull String key, @NonNull T _default) {
+    public <T extends Enum<?>> T getEnum(@NonNull String key, @NonNull T _default) {
         Objects.requireNonNull(_default);
         try {
             String enumName = preferences.getString(key, null);

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

@@ -1,14 +1,24 @@
 package app.revanced.integrations.youtube;
 
 import android.app.Activity;
+import android.graphics.Color;
+
+import androidx.annotation.Nullable;
+
 import app.revanced.integrations.shared.Logger;
 import app.revanced.integrations.shared.Utils;
 
 public class ThemeHelper {
+    @Nullable
+    private static Integer darkThemeColor, lightThemeColor;
     private static int themeValue;
 
-    public static void setTheme(Object value) {
-        final int newOrdinalValue = ((Enum) value).ordinal();
+    /**
+     * Injection point.
+     */
+    @SuppressWarnings("unused")
+    public static void setTheme(Enum<?> value) {
+        final int newOrdinalValue = value.ordinal();
         if (themeValue != newOrdinalValue) {
             themeValue = newOrdinalValue;
             Logger.printDebug(() -> "Theme value: " + newOrdinalValue);
@@ -26,4 +36,50 @@ public class ThemeHelper {
         activity.setTheme(Utils.getResourceIdentifier(theme, "style"));
     }
 
+    /**
+     * Injection point.
+     */
+    @SuppressWarnings("SameReturnValue")
+    private static String darkThemeResourceName() {
+        // Value is changed by Theme patch, if included.
+        return "@color/yt_black3";
+    }
+
+    /**
+     * @return The dark theme color as specified by the Theme patch (if included),
+     *         or the dark mode background color unpatched YT uses.
+     */
+    public static int getDarkThemeColor() {
+        if (darkThemeColor == null) {
+            darkThemeColor = getColorInt(darkThemeResourceName());
+        }
+        return darkThemeColor;
+    }
+
+    /**
+     * Injection point.
+     */
+    @SuppressWarnings("SameReturnValue")
+    private static String lightThemeResourceName() {
+        // Value is changed by Theme patch, if included.
+        return "@color/yt_white1";
+    }
+
+    /**
+     * @return The light theme color as specified by the Theme patch (if included),
+     *         or the non dark mode background color unpatched YT uses.
+     */
+    public static int getLightThemeColor() {
+        if (lightThemeColor == null) {
+            lightThemeColor = getColorInt(lightThemeResourceName());
+        }
+        return lightThemeColor;
+    }
+
+    private static int getColorInt(String colorString) {
+        if (colorString.startsWith("#")) {
+            return Color.parseColor(colorString);
+        }
+        return Utils.getResourceColor(colorString);
+    }
 }

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

@@ -1,19 +1,15 @@
 package app.revanced.integrations.youtube.patches;
 
+import static app.revanced.integrations.shared.StringRef.str;
+import static app.revanced.integrations.youtube.settings.Settings.*;
+import static app.revanced.integrations.youtube.shared.NavigationBar.NavigationButton;
+
 import android.net.Uri;
+
 import androidx.annotation.GuardedBy;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
-import app.revanced.integrations.shared.settings.BaseSettings;
-import app.revanced.integrations.shared.settings.EnumSetting;
-import app.revanced.integrations.shared.settings.Setting;
-import app.revanced.integrations.youtube.settings.Settings;
-import app.revanced.integrations.shared.Logger;
-import app.revanced.integrations.shared.Utils;
-import app.revanced.integrations.youtube.shared.NavigationBar;
-import app.revanced.integrations.youtube.shared.PlayerType;
-
 import org.chromium.net.UrlRequest;
 import org.chromium.net.UrlResponseInfo;
 import org.chromium.net.impl.CronetUrlRequest;
@@ -26,13 +22,12 @@ import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
 
-import static app.revanced.integrations.shared.StringRef.str;
-import static app.revanced.integrations.youtube.settings.Settings.ALT_THUMBNAIL_HOME;
-import static app.revanced.integrations.youtube.settings.Settings.ALT_THUMBNAIL_LIBRARY;
-import static app.revanced.integrations.youtube.settings.Settings.ALT_THUMBNAIL_PLAYER;
-import static app.revanced.integrations.youtube.settings.Settings.ALT_THUMBNAIL_SEARCH;
-import static app.revanced.integrations.youtube.settings.Settings.ALT_THUMBNAIL_SUBSCRIPTIONS;
-import static app.revanced.integrations.youtube.shared.NavigationBar.NavigationButton;
+import app.revanced.integrations.shared.Logger;
+import app.revanced.integrations.shared.Utils;
+import app.revanced.integrations.shared.settings.Setting;
+import app.revanced.integrations.youtube.settings.Settings;
+import app.revanced.integrations.youtube.shared.NavigationBar;
+import app.revanced.integrations.youtube.shared.PlayerType;
 
 /**
  * Alternative YouTube thumbnails.
@@ -134,11 +129,6 @@ public final class AlternativeThumbnailsPatch {
      */
     private static volatile long timeToResumeDeArrowAPICalls;
 
-    /**
-     * Used only for debug logging.
-     */
-    private static volatile EnumSetting<ThumbnailOption> currentOptionSetting;
-
     static {
         dearrowApiUri = validateSettings();
         final int port = dearrowApiUri.getPort();
@@ -162,21 +152,38 @@ public final class AlternativeThumbnailsPatch {
         return apiUri;
     }
 
-    private static EnumSetting<ThumbnailOption> optionSettingForCurrentNavigation() {
-        if (NavigationBar.isSearchBarActive()) { // Must check search first.
-            return ALT_THUMBNAIL_SEARCH;
-        }
+    private static ThumbnailOption optionSettingForCurrentNavigation() {
+        // Must check player type first, as search bar can be active behind the player.
         if (PlayerType.getCurrent().isMaximizedOrFullscreen()) {
-            return ALT_THUMBNAIL_PLAYER;
+            return ALT_THUMBNAIL_PLAYER.get();
         }
-        if (NavigationButton.HOME.isSelected()) {
-            return ALT_THUMBNAIL_HOME;
+
+        // Must check second, as search can be from any tab.
+        if (NavigationBar.isSearchBarActive()) {
+            return ALT_THUMBNAIL_SEARCH.get();
         }
-        if (NavigationButton.SUBSCRIPTIONS.isSelected() || NavigationButton.NOTIFICATIONS.isSelected()) {
-            return ALT_THUMBNAIL_SUBSCRIPTIONS;
+
+        // Avoid checking which navigation button is selected, if all other settings are the same.
+        ThumbnailOption homeOption = ALT_THUMBNAIL_HOME.get();
+        ThumbnailOption subscriptionsOption = ALT_THUMBNAIL_SUBSCRIPTIONS.get();
+        ThumbnailOption libraryOption = ALT_THUMBNAIL_LIBRARY.get();
+        if ((homeOption == subscriptionsOption) && (homeOption == libraryOption)) {
+            return homeOption; // All are the same option.
+        }
+
+        NavigationButton selectedNavButton = NavigationButton.getSelectedNavigationButton();
+        if (selectedNavButton == null) {
+            // Unknown tab, treat as the home tab;
+            return homeOption;
+        }
+        if (selectedNavButton == NavigationButton.HOME) {
+            return homeOption;
+        }
+        if (selectedNavButton == NavigationButton.SUBSCRIPTIONS || selectedNavButton == NavigationButton.NOTIFICATIONS) {
+            return subscriptionsOption;
         }
         // A library tab variant is active.
-        return ALT_THUMBNAIL_LIBRARY;
+        return libraryOption;
     }
 
     /**
@@ -254,14 +261,7 @@ public final class AlternativeThumbnailsPatch {
      */
     public static String overrideImageURL(String originalUrl) {
         try {
-            EnumSetting<ThumbnailOption> optionSetting = optionSettingForCurrentNavigation();
-            ThumbnailOption option = optionSetting.get();
-            if (BaseSettings.DEBUG.get()) {
-                if (currentOptionSetting != optionSetting) {
-                    currentOptionSetting = optionSetting;
-                    Logger.printDebug(() -> "Changed to setting: " + optionSetting.key);
-                }
-            }
+            ThumbnailOption option = optionSettingForCurrentNavigation();
 
             if (option == ThumbnailOption.ORIGINAL) {
                 return originalUrl;

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/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/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;
     }
 }

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

@@ -1,29 +0,0 @@
-package app.revanced.integrations.youtube.patches;
-
-import android.view.View;
-
-import app.revanced.integrations.youtube.patches.spoof.SpoofAppVersionPatch;
-import app.revanced.integrations.youtube.settings.Settings;
-import app.revanced.integrations.shared.Utils;
-
-@SuppressWarnings("unused")
-public class HideBreakingNewsPatch {
-
-    /**
-     * When spoofing to app versions 17.31.00 and older, the watch history preview bar uses
-     * the same layout components as the breaking news shelf.
-     *
-     * Breaking news does not appear to be present in these older versions anyways.
-     */
-    private static final boolean isSpoofingOldVersionWithHorizontalCardListWatchHistory =
-            SpoofAppVersionPatch.isSpoofingToLessThan("18.01.00");
-
-    /**
-     * Injection point.
-     */
-    public static void hideBreakingNews(View view) {
-        if (!Settings.HIDE_BREAKING_NEWS.get()
-                || isSpoofingOldVersionWithHorizontalCardListWatchHistory) return;
-        Utils.hideViewByLayoutParams(view);
-    }
-}

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

@@ -2,7 +2,11 @@ package app.revanced.integrations.youtube.patches;
 
 import app.revanced.integrations.youtube.settings.Settings;
 
+/**
+ * Patch is obsolete and will be deleted in a future release
+ */
 @SuppressWarnings("unused")
+@Deprecated()
 public class HideEmailAddressPatch {
     //Used by app.revanced.patches.youtube.layout.personalinformation.patch.HideEmailAddressPatch
     public static int hideEmailAddress(int originalValue) {

app/src/main/java/app/revanced/integrations/youtube/patches/HideLoadMoreButtonPatch.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 HideLoadMoreButtonPatch {
-    public static void hideLoadMoreButton(View view){
-        if(!Settings.HIDE_LOAD_MORE_BUTTON.get()) return;
-        Utils.hideViewByLayoutParams(view);
-    }
-}

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

@@ -0,0 +1,166 @@
+package app.revanced.integrations.youtube.patches;
+
+import static app.revanced.integrations.shared.StringRef.str;
+import static app.revanced.integrations.youtube.patches.MiniplayerPatch.MiniplayerType.*;
+
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import androidx.annotation.Nullable;
+
+import app.revanced.integrations.shared.Logger;
+import app.revanced.integrations.shared.Utils;
+import app.revanced.integrations.youtube.settings.Settings;
+
+@SuppressWarnings("unused")
+public final class MiniplayerPatch {
+
+    /**
+     * Mini player type. Null fields indicates to use the original un-patched value.
+     */
+    public enum MiniplayerType {
+        /** Unmodified type, and same as un-patched. */
+        ORIGINAL(null, null),
+        PHONE(false, null),
+        TABLET(true, null),
+        MODERN_1(null, 1),
+        MODERN_2(null, 2),
+        MODERN_3(null, 3);
+
+        /**
+         * Legacy tablet hook value.
+         */
+        @Nullable
+        final Boolean legacyTabletOverride;
+
+        /**
+         * Modern player type used by YT.
+         */
+        @Nullable
+        final Integer modernPlayerType;
+
+        MiniplayerType(@Nullable Boolean legacyTabletOverride, @Nullable Integer modernPlayerType) {
+            this.legacyTabletOverride = legacyTabletOverride;
+            this.modernPlayerType = modernPlayerType;
+        }
+
+        public boolean isModern() {
+            return modernPlayerType != null;
+        }
+    }
+
+    /**
+     * Modern subtitle overlay for {@link MiniplayerType#MODERN_2}.
+     * Resource is not present in older targets, and this field will be zero.
+     */
+    private static final int MODERN_OVERLAY_SUBTITLE_TEXT
+            = Utils.getResourceIdentifier("modern_miniplayer_subtitle_text", "id");
+
+    private static final MiniplayerType CURRENT_TYPE = Settings.MINIPLAYER_TYPE.get();
+
+    private static final boolean HIDE_EXPAND_CLOSE_ENABLED =
+            (CURRENT_TYPE == MODERN_1 || CURRENT_TYPE == MODERN_3) && Settings.MINIPLAYER_HIDE_EXPAND_CLOSE.get();
+
+    private static final boolean HIDE_SUBTEXT_ENABLED =
+            (CURRENT_TYPE == MODERN_1 || CURRENT_TYPE == MODERN_3) && Settings.MINIPLAYER_HIDE_SUBTEXT.get();
+
+    private static final boolean HIDE_REWIND_FORWARD_ENABLED =
+            CURRENT_TYPE == MODERN_1 && Settings.MINIPLAYER_HIDE_REWIND_FORWARD.get();
+
+    private static final int OPACITY_LEVEL;
+
+    static {
+        int opacity = Settings.MINIPLAYER_OPACITY.get();
+
+        if (opacity < 0 || opacity > 100) {
+            Utils.showToastLong(str("revanced_miniplayer_opacity_invalid_toast"));
+            Settings.MINIPLAYER_OPACITY.resetToDefault();
+            opacity = Settings.MINIPLAYER_OPACITY.defaultValue;
+        }
+
+        OPACITY_LEVEL = (opacity * 255) / 100;
+    }
+
+    /**
+     * Injection point.
+     */
+    public static boolean getLegacyTabletMiniplayerOverride(boolean original) {
+        Boolean isTablet = CURRENT_TYPE.legacyTabletOverride;
+        return isTablet == null
+                ? original
+                : isTablet;
+    }
+
+    /**
+     * Injection point.
+     */
+    public static boolean getModernMiniplayerOverride(boolean original) {
+        return CURRENT_TYPE == ORIGINAL
+                ? original
+                : CURRENT_TYPE.isModern();
+    }
+
+    /**
+     * Injection point.
+     */
+    public static int getModernMiniplayerOverrideType(int original) {
+        Integer modernValue = CURRENT_TYPE.modernPlayerType;
+        return modernValue == null
+                ? original
+                : modernValue;
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void adjustMiniplayerOpacity(ImageView view) {
+        if (CURRENT_TYPE == MODERN_1) {
+            view.setImageAlpha(OPACITY_LEVEL);
+        }
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void hideMiniplayerExpandClose(ImageView view) {
+        Utils.hideViewByRemovingFromParentUnderCondition(HIDE_EXPAND_CLOSE_ENABLED, view);
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void hideMiniplayerRewindForward(ImageView view) {
+        Utils.hideViewByRemovingFromParentUnderCondition(HIDE_REWIND_FORWARD_ENABLED, view);
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void hideMiniplayerSubTexts(View view) {
+        // Different subviews are passed in, but only TextView and layouts are of interest here.
+        final boolean hideView = HIDE_SUBTEXT_ENABLED && (view instanceof TextView || view instanceof LinearLayout);
+        Utils.hideViewByRemovingFromParentUnderCondition(hideView, view);
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void playerOverlayGroupCreated(View group) {
+        // Modern 2 has an half broken subtitle that is always present.
+        // Always hide it to make the miniplayer mostly usable.
+        if (CURRENT_TYPE == MODERN_2 && MODERN_OVERLAY_SUBTITLE_TEXT != 0) {
+            if (group instanceof ViewGroup) {
+                View subtitleText = Utils.getChildView((ViewGroup) group, true,
+                        view -> view.getId() == MODERN_OVERLAY_SUBTITLE_TEXT);
+
+                if (subtitleText != null) {
+                    subtitleText.setVisibility(View.GONE);
+                    Logger.printDebug(() -> "Modern overlay subtitle view set to hidden");
+                }
+            }
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 package app.revanced.integrations.youtube.patches;
 
+import static app.revanced.integrations.shared.Utils.hideViewUnderCondition;
 import static app.revanced.integrations.youtube.shared.NavigationBar.NavigationButton;
 
 import android.view.View;
@@ -7,7 +8,7 @@ import android.view.View;
 import java.util.EnumMap;
 import java.util.Map;
 
-import app.revanced.integrations.shared.Logger;
+import android.widget.TextView;
 import app.revanced.integrations.youtube.settings.Settings;
 
 @SuppressWarnings("unused")
@@ -22,7 +23,7 @@ public final class NavigationButtonsPatch {
         }
     };
 
-    private static final Boolean SWITCH_CREATE_WITH_NOTIFICATIONS_BUTTON
+    private static final boolean SWITCH_CREATE_WITH_NOTIFICATIONS_BUTTON
             = Settings.SWITCH_CREATE_WITH_NOTIFICATIONS_BUTTON.get();
 
     /**
@@ -40,4 +41,11 @@ public final class NavigationButtonsPatch {
             tabView.setVisibility(View.GONE);
         }
     }
+
+    /**
+     * Injection point.
+     */
+    public static void hideNavigationButtonLabels(TextView navigationLabelsView) {
+        hideViewUnderCondition(Settings.HIDE_NAVIGATION_BUTTON_LABELS, navigationLabelsView);
+    }
 }

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

@@ -2,8 +2,6 @@ package app.revanced.integrations.youtube.patches;
 
 import android.view.ViewGroup;
 
-import androidx.annotation.Nullable;
-
 import app.revanced.integrations.youtube.shared.PlayerOverlays;
 
 @SuppressWarnings("unused")

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

@@ -176,12 +176,6 @@ public class ReturnYouTubeDislikePatch {
             textView.removeTextChangedListener(oldUiTextWatcher);
             textView.addTextChangedListener(oldUiTextWatcher);
 
-            /**
-             * If the patch is changed to include the dislikes button as a parameter to this method,
-             * then if the button is already selected the dislikes could be adjusted using
-             * {@link ReturnYouTubeDislike#setUserVote(Vote)}
-             */
-
             updateOldUIDislikesTextView();
 
         } catch (Exception ex) {
@@ -227,6 +221,10 @@ public class ReturnYouTubeDislikePatch {
 
             String conversionContextString = conversionContext.toString();
 
+            if (isRollingNumber && !conversionContextString.contains("video_action_bar.eml|")) {
+                return original;
+            }
+
             final CharSequence replacement;
             if (conversionContextString.contains("|segmented_like_dislike_button.eml|")) {
                 // Regular video.
@@ -241,7 +239,7 @@ public class ReturnYouTubeDislikePatch {
                         true, isRollingNumber);
             } else if (!isRollingNumber && conversionContextString.contains("|shorts_dislike_button.eml|")) {
                 // Litho Shorts player.
-                if (!Settings.RYD_SHORTS.get()) {
+                if (!Settings.RYD_SHORTS.get() || Settings.HIDE_SHORTS_DISLIKE_BUTTON.get()) {
                     // Must clear the current video here, otherwise if the user opens a regular video
                     // then opens a litho short (while keeping the regular video on screen), then closes the short,
                     // the original video may show the incorrect dislike value.
@@ -295,6 +293,7 @@ public class ReturnYouTubeDislikePatch {
                                                @NonNull String original) {
         try {
             CharSequence replacement = onLithoTextLoaded(conversionContext, original, true);
+
             String replacementString = replacement.toString();
             if (!replacementString.equals(original)) {
                 rollingNumberSpan = replacement;
@@ -314,19 +313,25 @@ public class ReturnYouTubeDislikePatch {
      */
     public static float onRollingNumberMeasured(String text, float measuredTextWidth) {
         try {
-            if (Settings.RYD_ENABLED.get() && !Settings.RYD_COMPACT_LAYOUT.get()) {
+            if (Settings.RYD_ENABLED.get()) {
                 if (ReturnYouTubeDislike.isPreviouslyCreatedSegmentedSpan(text)) {
                     // +1 pixel is needed for some foreign languages that measure
                     // the text different from what is used for layout (Greek in particular).
                     // Probably a bug in Android, but who knows.
                     // Single line mode is also used as an additional fix for this issue.
-                    return measuredTextWidth + ReturnYouTubeDislike.leftSeparatorBounds.right
-                            + ReturnYouTubeDislike.leftSeparatorShapePaddingPixels + 1;
+                    if (Settings.RYD_COMPACT_LAYOUT.get()) {
+                        return measuredTextWidth + 1;
+                    }
+
+                    return measuredTextWidth + 1
+                            + ReturnYouTubeDislike.leftSeparatorBounds.right
+                            + ReturnYouTubeDislike.leftSeparatorShapePaddingPixels;
                 }
             }
         } catch (Exception ex) {
             Logger.printException(() -> "onRollingNumberMeasured failure", ex);
         }
+
         return measuredTextWidth;
     }
 
@@ -344,10 +349,12 @@ public class ReturnYouTubeDislikePatch {
             } else {
                 view.setCompoundDrawables(separator, null, null, null);
             }
+
             // Disliking can cause the span to grow in size, which is ok and is laid out correctly,
             // but if the user then removes their dislike the layout will not adjust to the new shorter width.
             // Use a center alignment to take up any extra space.
             view.setTextAlignment(View.TEXT_ALIGNMENT_CENTER);
+
             // Single line mode does not clip words if the span is larger than the view bounds.
             // The styled span applied to the view should always have the same bounds,
             // but use this feature just in case the measurements are somehow off by a few pixels.
@@ -449,7 +456,7 @@ public class ReturnYouTubeDislikePatch {
             if (!Settings.RYD_ENABLED.get()) {
                 return false;
             }
-            if (!Settings.RYD_SHORTS.get()) {
+            if (!Settings.RYD_SHORTS.get() || Settings.HIDE_SHORTS_DISLIKE_BUTTON.get()) {
                 // Must clear the data here, in case a new video was loaded while PlayerType
                 // suggested the video was not a short (can happen when spoofing to an old app version).
                 clearData();