chore: Release v5.26.0-dev.5 [skip ci]

# [5.26.0-dev.5](https://github.com/ReVanced/revanced-patches/compare/v5.26.0-dev.4...v5.26.0-dev.5) (2025-06-03)

### Bug Fixes

* **Spotify - Custom theme:** Apply accent color in more places ([#5039](https://github.com/ReVanced/revanced-patches/issues/5039)) ([bc45433](bc45433dcb))

CHANGELOG.md

@@ -1,3 +1,162 @@
+# [5.26.0-dev.5](https://github.com/ReVanced/revanced-patches/compare/v5.26.0-dev.4...v5.26.0-dev.5) (2025-06-03)
+
+
+### Bug Fixes
+
+* **Spotify - Custom theme:** Apply accent color in more places ([#5039](https://github.com/ReVanced/revanced-patches/issues/5039)) ([9357887](https://github.com/ReVanced/revanced-patches/commit/9357887b6fca7aaf34dfb0163645b6a998e1db76))
+
+# [5.26.0-dev.4](https://github.com/ReVanced/revanced-patches/compare/v5.26.0-dev.3...v5.26.0-dev.4) (2025-06-03)
+
+
+### Features
+
+* **Spotify:** Add `Hide Create button` patch ([#5062](https://github.com/ReVanced/revanced-patches/issues/5062)) ([3201681](https://github.com/ReVanced/revanced-patches/commit/32016819d2adbdfdd5e028941d56feda36d20b00))
+
+# [5.26.0-dev.3](https://github.com/ReVanced/revanced-patches/compare/v5.26.0-dev.2...v5.26.0-dev.3) (2025-06-01)
+
+
+### Features
+
+* **YouTube - Playback Speed:** Use modern custom speed dialog ([#5069](https://github.com/ReVanced/revanced-patches/issues/5069)) ([9a1e6ca](https://github.com/ReVanced/revanced-patches/commit/9a1e6ca178d9833ee2c681fb130b9290a4e89cd8))
+
+# [5.26.0-dev.2](https://github.com/ReVanced/revanced-patches/compare/v5.26.0-dev.1...v5.26.0-dev.2) (2025-06-01)
+
+
+### Bug Fixes
+
+* **YouTube:** Support A/B Shorts layout for RYD and component hiding ([#5081](https://github.com/ReVanced/revanced-patches/issues/5081)) ([8ecacaa](https://github.com/ReVanced/revanced-patches/commit/8ecacaad27162d9380014a9a13ac9220b12257b2))
+
+# [5.26.0-dev.1](https://github.com/ReVanced/revanced-patches/compare/v5.25.0...v5.26.0-dev.1) (2025-05-30)
+
+
+### Features
+
+* **Proton Mail:** Add `Remove free accounts limit` patch ([#4970](https://github.com/ReVanced/revanced-patches/issues/4970)) ([b0440ad](https://github.com/ReVanced/revanced-patches/commit/b0440ad6af0e190e516974ce896dcc54c8d2e122))
+
+# [5.25.0](https://github.com/ReVanced/revanced-patches/compare/v5.24.0...v5.25.0) (2025-05-29)
+
+
+### Bug Fixes
+
+* **Disable Pairip license check:** Change patch to default off ([74b6a94](https://github.com/ReVanced/revanced-patches/commit/74b6a94577ac3f73b04bd0cce98fb7011a6607fd))
+* **Hide ADB status:** Resolve app crash on startup ([#5029](https://github.com/ReVanced/revanced-patches/issues/5029)) ([1abebd5](https://github.com/ReVanced/revanced-patches/commit/1abebd5f3b73250c6638d2d8a274b92ea8268924))
+* **Messenger:** Remove outdated `Disable switching emoji to sticker` patch ([#5044](https://github.com/ReVanced/revanced-patches/issues/5044)) ([7b182ca](https://github.com/ReVanced/revanced-patches/commit/7b182cab825ee3a4a3ca528c744c9d2a351c7cf8))
+* **Spotify Lite:** Remove obsolete `Enable on demand` patch ([#5046](https://github.com/ReVanced/revanced-patches/issues/5046)) ([4886d47](https://github.com/ReVanced/revanced-patches/commit/4886d47506c94b03c1f190ecc4947d3d91df6a47))
+* **YouTube - GmsCore support:** Restore patch functionality from prior merge ([7686bbe](https://github.com/ReVanced/revanced-patches/commit/7686bbe975644e1e582fa52f166879da5694ed93))
+* **YouTube - Hide ads:** Hide new type of general ad ([#5004](https://github.com/ReVanced/revanced-patches/issues/5004)) ([37e59d2](https://github.com/ReVanced/revanced-patches/commit/37e59d2771528c631dc13e73dac095fec95c6485))
+* **YouTube - Open Shorts in regular player:** Do not exit app when pressing back button in regular player ([#5020](https://github.com/ReVanced/revanced-patches/issues/5020)) ([3384f8d](https://github.com/ReVanced/revanced-patches/commit/3384f8dd0ff2a345f2e387f4ed1570079a83ccb6))
+* **YouTube:** Better handle incorrect duplicate translations ([20abac5](https://github.com/ReVanced/revanced-patches/commit/20abac52121fbecb65d87d0982f3380e1cf4e20e))
+* **Yuka - Unlock premium:** Remove broken patch that is no longer supported ([#5018](https://github.com/ReVanced/revanced-patches/issues/5018)) ([fac6e59](https://github.com/ReVanced/revanced-patches/commit/fac6e59d281e21e57abdcfc899cd1aeb18e5c2b8))
+
+
+### Features
+
+* Add `Disable pairip license check` patch ([#4927](https://github.com/ReVanced/revanced-patches/issues/4927)) ([42d2c27](https://github.com/ReVanced/revanced-patches/commit/42d2c277982ef63e6ad42d85e46f13c3ab50243c))
+* **Messenger:** Add `Remove Meta AI` patch ([#4945](https://github.com/ReVanced/revanced-patches/issues/4945)) ([012dff7](https://github.com/ReVanced/revanced-patches/commit/012dff7b6511b9e519ccac96f6713cf1a1b327b4))
+* **Prime Video:** Add `Rename shared permissions` patch ([#5049](https://github.com/ReVanced/revanced-patches/issues/5049)) ([80f1fc6](https://github.com/ReVanced/revanced-patches/commit/80f1fc629e30e391bd5877f07dbdf4b6613bd1cf))
+* **Spotify:** Add `Fix Facebook login` patch ([#5023](https://github.com/ReVanced/revanced-patches/issues/5023)) ([34932dc](https://github.com/ReVanced/revanced-patches/commit/34932dc43933d346a5a3adadc62c0dbd38a633b5))
+* **Threads:** Hide Ads ([#5064](https://github.com/ReVanced/revanced-patches/issues/5064)) ([3c4cecb](https://github.com/ReVanced/revanced-patches/commit/3c4cecb966c2f99bfde99552686dda19ade5f67e))
+* **YouTube - Enable debugging:** Add settings menu to share debug logs ([#5021](https://github.com/ReVanced/revanced-patches/issues/5021)) ([1ec4a88](https://github.com/ReVanced/revanced-patches/commit/1ec4a88464a2a2810c02cf072950b618d183779a))
+* **YouTube - Settings:** Add a color picker ([#4981](https://github.com/ReVanced/revanced-patches/issues/4981)) ([1e0e398](https://github.com/ReVanced/revanced-patches/commit/1e0e398574329173aff11a4dc9acfc3fcdeabe16))
+* **YouTube - Swipe controls:** Add separate color settings for the brightness and volume bars ([#5043](https://github.com/ReVanced/revanced-patches/issues/5043)) ([80f50e8](https://github.com/ReVanced/revanced-patches/commit/80f50e8c50ca6a8366b7fd7b01459fb16fa1074a))
+* **YouTube:** Add `Disable haptic feedback` patch ([#5033](https://github.com/ReVanced/revanced-patches/issues/5033)) ([bbe7974](https://github.com/ReVanced/revanced-patches/commit/bbe79744a513c96f9016476e8435f999e94c45d7))
+
+# [5.25.0-dev.14](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.13...v5.25.0-dev.14) (2025-05-29)
+
+
+### Features
+
+* **Threads:** Hide Ads ([#5064](https://github.com/ReVanced/revanced-patches/issues/5064)) ([3c4cecb](https://github.com/ReVanced/revanced-patches/commit/3c4cecb966c2f99bfde99552686dda19ade5f67e))
+
+# [5.25.0-dev.13](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.12...v5.25.0-dev.13) (2025-05-28)
+
+
+### Features
+
+* **Prime Video:** Add `Rename shared permissions` patch ([#5049](https://github.com/ReVanced/revanced-patches/issues/5049)) ([80f1fc6](https://github.com/ReVanced/revanced-patches/commit/80f1fc629e30e391bd5877f07dbdf4b6613bd1cf))
+
+# [5.25.0-dev.12](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.11...v5.25.0-dev.12) (2025-05-28)
+
+
+### Features
+
+* **YouTube - Swipe controls:** Add separate color settings for the brightness and volume bars ([#5043](https://github.com/ReVanced/revanced-patches/issues/5043)) ([80f50e8](https://github.com/ReVanced/revanced-patches/commit/80f50e8c50ca6a8366b7fd7b01459fb16fa1074a))
+
+# [5.25.0-dev.11](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.10...v5.25.0-dev.11) (2025-05-27)
+
+
+### Features
+
+* **YouTube - Enable debugging:** Add settings menu to share debug logs ([#5021](https://github.com/ReVanced/revanced-patches/issues/5021)) ([1ec4a88](https://github.com/ReVanced/revanced-patches/commit/1ec4a88464a2a2810c02cf072950b618d183779a))
+* **YouTube:** Add `Disable haptic feedback` patch ([#5033](https://github.com/ReVanced/revanced-patches/issues/5033)) ([bbe7974](https://github.com/ReVanced/revanced-patches/commit/bbe79744a513c96f9016476e8435f999e94c45d7))
+
+# [5.25.0-dev.10](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.9...v5.25.0-dev.10) (2025-05-27)
+
+
+### Bug Fixes
+
+* **Messenger:** Remove outdated `Disable switching emoji to sticker` patch ([#5044](https://github.com/ReVanced/revanced-patches/issues/5044)) ([7b182ca](https://github.com/ReVanced/revanced-patches/commit/7b182cab825ee3a4a3ca528c744c9d2a351c7cf8))
+* **Spotify Lite:** Remove obsolete `Enable on demand` patch ([#5046](https://github.com/ReVanced/revanced-patches/issues/5046)) ([4886d47](https://github.com/ReVanced/revanced-patches/commit/4886d47506c94b03c1f190ecc4947d3d91df6a47))
+
+# [5.25.0-dev.9](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.8...v5.25.0-dev.9) (2025-05-26)
+
+
+### Features
+
+* **Spotify:** Add `Fix Facebook login` patch ([#5023](https://github.com/ReVanced/revanced-patches/issues/5023)) ([34932dc](https://github.com/ReVanced/revanced-patches/commit/34932dc43933d346a5a3adadc62c0dbd38a633b5))
+* **YouTube - Settings:** Add a color picker ([#4981](https://github.com/ReVanced/revanced-patches/issues/4981)) ([1e0e398](https://github.com/ReVanced/revanced-patches/commit/1e0e398574329173aff11a4dc9acfc3fcdeabe16))
+
+# [5.25.0-dev.9](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.8...v5.25.0-dev.9) (2025-05-26)
+
+
+### Features
+
+* **Spotify:** Add `Fix Facebook login` patch ([#5023](https://github.com/ReVanced/revanced-patches/issues/5023)) ([34932dc](https://github.com/ReVanced/revanced-patches/commit/34932dc43933d346a5a3adadc62c0dbd38a633b5))
+* **YouTube - Settings:** Add a color picker ([#4981](https://github.com/ReVanced/revanced-patches/issues/4981)) ([1e0e398](https://github.com/ReVanced/revanced-patches/commit/1e0e398574329173aff11a4dc9acfc3fcdeabe16))
+
+# [5.25.0-dev.9](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.8...v5.25.0-dev.9) (2025-05-26)
+
+
+### Features
+
+* **Spotify:** Add `Fix Facebook login` patch ([#5023](https://github.com/ReVanced/revanced-patches/issues/5023)) ([34932dc](https://github.com/ReVanced/revanced-patches/commit/34932dc43933d346a5a3adadc62c0dbd38a633b5))
+* **YouTube - Settings:** Add a color picker ([#4981](https://github.com/ReVanced/revanced-patches/issues/4981)) ([1e0e398](https://github.com/ReVanced/revanced-patches/commit/1e0e398574329173aff11a4dc9acfc3fcdeabe16))
+
+# [5.25.0-dev.8](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.7...v5.25.0-dev.8) (2025-05-25)
+
+
+### Bug Fixes
+
+* **Hide ADB status:** Resolve app crash on startup ([#5029](https://github.com/ReVanced/revanced-patches/issues/5029)) ([1abebd5](https://github.com/ReVanced/revanced-patches/commit/1abebd5f3b73250c6638d2d8a274b92ea8268924))
+
+# [5.25.0-dev.7](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.6...v5.25.0-dev.7) (2025-05-24)
+
+
+### Bug Fixes
+
+* **YouTube - Open Shorts in regular player:** Do not exit app when pressing back button in regular player ([#5020](https://github.com/ReVanced/revanced-patches/issues/5020)) ([3384f8d](https://github.com/ReVanced/revanced-patches/commit/3384f8dd0ff2a345f2e387f4ed1570079a83ccb6))
+
+# [5.25.0-dev.6](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.5...v5.25.0-dev.6) (2025-05-23)
+
+
+### Bug Fixes
+
+* **Yuka - Unlock premium:** Remove broken patch that is no longer supported ([#5018](https://github.com/ReVanced/revanced-patches/issues/5018)) ([fac6e59](https://github.com/ReVanced/revanced-patches/commit/fac6e59d281e21e57abdcfc899cd1aeb18e5c2b8))
+
+# [5.25.0-dev.5](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.4...v5.25.0-dev.5) (2025-05-22)
+
+
+### Bug Fixes
+
+* **YouTube:** Better handle incorrect duplicate translations ([20abac5](https://github.com/ReVanced/revanced-patches/commit/20abac52121fbecb65d87d0982f3380e1cf4e20e))
+
+# [5.25.0-dev.4](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.3...v5.25.0-dev.4) (2025-05-22)
+
+
+### Bug Fixes
+
+* **YouTube - GmsCore support:** Restore patch functionality from prior merge ([7686bbe](https://github.com/ReVanced/revanced-patches/commit/7686bbe975644e1e582fa52f166879da5694ed93))
+
 # [5.25.0-dev.3](https://github.com/ReVanced/revanced-patches/compare/v5.25.0-dev.2...v5.25.0-dev.3) (2025-05-22)
 
 

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

@@ -1,15 +1,26 @@
 package app.revanced.extension.shared;
 
+import static app.revanced.extension.shared.settings.BaseSettings.DEBUG;
+import static app.revanced.extension.shared.settings.BaseSettings.DEBUG_STACKTRACE;
+import static app.revanced.extension.shared.settings.BaseSettings.DEBUG_TOAST_ON_ERROR;
+
 import android.util.Log;
+
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import app.revanced.extension.shared.settings.BaseSettings;
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
 
-import static app.revanced.extension.shared.settings.BaseSettings.*;
+import app.revanced.extension.shared.settings.BaseSettings;
+import app.revanced.extension.shared.settings.preference.LogBufferManager;
 
+/**
+ * ReVanced specific logger.  Logging is done to standard device log (accessible thru ADB),
+ * and additionally accessible thru {@link LogBufferManager}.
+ *
+ * All methods are thread safe.
+ */
 public class Logger {
 
     /**
@@ -17,99 +28,159 @@ public class Logger {
      */
     @FunctionalInterface
     public interface LogMessage {
+        /**
+         * @return Logger string message. This method is only called if logging is enabled.
+         */
         @NonNull
         String buildMessageString();
+    }
 
-        /**
+    private enum LogLevel {
-         * @return For outer classes, this returns {@link Class#getSimpleName()}.
+        DEBUG,
-         * For static, inner, or anonymous classes, this returns the simple name of the enclosing class.
+        INFO,
-         * <br>
+        ERROR
-         * For example, each of these classes return 'SomethingView':
+    }
-         * <code>
-         * com.company.SomethingView
-         * com.company.SomethingView$StaticClass
-         * com.company.SomethingView$1
-         * </code>
-         */
-        private String findOuterClassSimpleName() {
-            var selfClass = this.getClass();
 
-            String fullClassName = selfClass.getName();
+    /**
-            final int dollarSignIndex = fullClassName.indexOf('$');
+     * Log tag prefix. Only used for system logging.
-            if (dollarSignIndex < 0) {
+     */
-                return selfClass.getSimpleName(); // Already an outer class.
+    private static final String REVANCED_LOG_TAG_PREFIX = "revanced: ";
+
+    private static final String LOGGER_CLASS_NAME = Logger.class.getName();
+
+    /**
+     * @return For outer classes, this returns {@link Class#getSimpleName()}.
+     * For static, inner, or anonymous classes, this returns the simple name of the enclosing class.
+     * <br>
+     * For example, each of these classes returns 'SomethingView':
+     * <code>
+     * com.company.SomethingView
+     * com.company.SomethingView$StaticClass
+     * com.company.SomethingView$1
+     * </code>
+     */
+    private static String getOuterClassSimpleName(Object obj) {
+        Class<?> logClass = obj.getClass();
+        String fullClassName = logClass.getName();
+        final int dollarSignIndex = fullClassName.indexOf('$');
+        if (dollarSignIndex < 0) {
+            return logClass.getSimpleName(); // Already an outer class.
+        }
+
+        // Class is inner, static, or anonymous.
+        // Parse the simple name full name.
+        // A class with no package returns index of -1, but incrementing gives index zero which is correct.
+        final int simpleClassNameStartIndex = fullClassName.lastIndexOf('.') + 1;
+        return fullClassName.substring(simpleClassNameStartIndex, dollarSignIndex);
+    }
+
+    /**
+     * Internal method to handle logging to Android Log and {@link LogBufferManager}.
+     * Appends the log message, stack trace (if enabled), and exception (if present) to logBuffer
+     * with class name but without 'revanced:' prefix.
+     *
+     * @param logLevel          The log level.
+     * @param message           Log message object.
+     * @param ex                Optional exception.
+     * @param includeStackTrace If the current stack should be included.
+     * @param showToast         If a toast is to be shown.
+     */
+    private static void logInternal(LogLevel logLevel, LogMessage message, @Nullable Throwable ex,
+                                    boolean includeStackTrace, boolean showToast) {
+        // It's very important that no Settings are used in this method,
+        // as this code is used when a context is not set and thus referencing
+        // a setting will crash the app.
+        String messageString = message.buildMessageString();
+        String className = getOuterClassSimpleName(message);
+
+        String logText = messageString;
+
+        // Append exception message if present.
+        if (ex != null) {
+            var exceptionMessage = ex.getMessage();
+            if (exceptionMessage != null) {
+                logText += "\nException: " + exceptionMessage;
             }
+        }
 
-            // Class is inner, static, or anonymous.
+        if (includeStackTrace) {
-            // Parse the simple name full name.
+            var sw = new StringWriter();
-            // A class with no package returns index of -1, but incrementing gives index zero which is correct.
+            new Throwable().printStackTrace(new PrintWriter(sw));
-            final int simpleClassNameStartIndex = fullClassName.lastIndexOf('.') + 1;
+            String stackTrace = sw.toString();
-            return fullClassName.substring(simpleClassNameStartIndex, dollarSignIndex);
+            // Remove the stacktrace elements of this class.
+            final int loggerIndex = stackTrace.lastIndexOf(LOGGER_CLASS_NAME);
+            final int loggerBegins = stackTrace.indexOf('\n', loggerIndex);
+            logText += stackTrace.substring(loggerBegins);
+        }
+
+        // Do not include "revanced:" prefix in clipboard logs.
+        String managerToastString = className + ": " + logText;
+        LogBufferManager.appendToLogBuffer(managerToastString);
+
+        String logTag = REVANCED_LOG_TAG_PREFIX + className;
+        switch (logLevel) {
+            case DEBUG:
+                if (ex == null) Log.d(logTag, logText);
+                else Log.d(logTag, logText, ex);
+                break;
+            case INFO:
+                if (ex == null) Log.i(logTag, logText);
+                else Log.i(logTag, logText, ex);
+                break;
+            case ERROR:
+                if (ex == null) Log.e(logTag, logText);
+                else Log.e(logTag, logText, ex);
+                break;
+        }
+
+        if (showToast) {
+            Utils.showToastLong(managerToastString);
         }
     }
 
-    private static final String REVANCED_LOG_PREFIX = "revanced: ";
-
     /**
      * Logs debug messages under the outer class name of the code calling this method.
-     * Whenever possible, the log string should be constructed entirely inside {@link LogMessage#buildMessageString()}
+     * <p>
-     * so the performance cost of building strings is paid only if {@link BaseSettings#DEBUG} is enabled.
+     * 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) {
+    public static void printDebug(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()}
+     * <p>
-     * so the performance cost of building strings is paid only if {@link BaseSettings#DEBUG} is enabled.
+     * 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) {
+    public static void printDebug(LogMessage message, @Nullable Exception ex) {
         if (DEBUG.get()) {
-            String logMessage = message.buildMessageString();
+            logInternal(LogLevel.DEBUG, message, ex, DEBUG_STACKTRACE.get(), false);
-            String logTag = REVANCED_LOG_PREFIX + message.findOuterClassSimpleName();
-
-            if (DEBUG_STACKTRACE.get()) {
-                var builder = new StringBuilder(logMessage);
-                var sw = new StringWriter();
-                new Throwable().printStackTrace(new PrintWriter(sw));
-
-                builder.append('\n').append(sw);
-                logMessage = builder.toString();
-            }
-
-            if (ex == null) {
-                Log.d(logTag, logMessage);
-            } else {
-                Log.d(logTag, logMessage, ex);
-            }
         }
     }
 
     /**
      * Logs information messages using the outer class name of the code calling this method.
      */
-    public static void printInfo(@NonNull LogMessage message) {
+    public static void printInfo(LogMessage message) {
         printInfo(message, null);
     }
 
     /**
      * Logs information messages using the outer class name of the code calling this method.
      */
-    public static void printInfo(@NonNull LogMessage message, @Nullable Exception ex) {
+    public static void printInfo(LogMessage message, @Nullable Exception ex) {
-        String logTag = REVANCED_LOG_PREFIX + message.findOuterClassSimpleName();
+        logInternal(LogLevel.INFO, message, ex, DEBUG_STACKTRACE.get(), false);
-        String logMessage = message.buildMessageString();
-        if (ex == null) {
-            Log.i(logTag, logMessage);
-        } else {
-            Log.i(logTag, logMessage, ex);
-        }
     }
 
     /**
      * Logs exceptions under the outer class name of the code calling this method.
+     * Appends the log message, exception (if present), and toast message (if enabled) to logBuffer.
      */
-    public static void printException(@NonNull LogMessage message) {
+    public static void printException(LogMessage message) {
         printException(message, null);
     }
 
@@ -122,35 +193,23 @@ public class Logger {
      * @param message          log message
      * @param ex               exception (optional)
      */
-    public static void printException(@NonNull LogMessage message, @Nullable Throwable ex) {
+    public static void printException(LogMessage message, @Nullable Throwable ex) {
-        String messageString = message.buildMessageString();
+        logInternal(LogLevel.ERROR, message, ex, DEBUG_STACKTRACE.get(), DEBUG_TOAST_ON_ERROR.get());
-        String outerClassSimpleName = message.findOuterClassSimpleName();
-        String logMessage = REVANCED_LOG_PREFIX + outerClassSimpleName;
-        if (ex == null) {
-            Log.e(logMessage, messageString);
-        } else {
-            Log.e(logMessage, messageString, ex);
-        }
-        if (DEBUG_TOAST_ON_ERROR.get()) {
-            Utils.showToastLong(outerClassSimpleName + ": " + messageString);
-        }
     }
 
     /**
      * Logging to use if {@link BaseSettings#DEBUG} or {@link Utils#getContext()} may not be initialized.
      * Normally this method should not be used.
      */
-    public static void initializationInfo(@NonNull Class<?> callingClass, @NonNull String message) {
+    public static void initializationInfo(LogMessage message) {
-        Log.i(REVANCED_LOG_PREFIX + callingClass.getSimpleName(), message);
+        logInternal(LogLevel.INFO, message, null, false, false);
     }
 
     /**
      * Logging to use if {@link BaseSettings#DEBUG} or {@link Utils#getContext()} may not be initialized.
      * Normally this method should not be used.
      */
-    public static void initializationException(@NonNull Class<?> callingClass, @NonNull String message,
+    public static void initializationException(LogMessage message, @Nullable Exception ex) {
-                                               @Nullable Exception ex) {
+        logInternal(LogLevel.ERROR, message, ex, false, false);
-        Log.e(REVANCED_LOG_PREFIX + callingClass.getSimpleName(), message, ex);
     }
-
 }

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

@@ -1,7 +1,11 @@
 package app.revanced.extension.shared;
 
 import android.annotation.SuppressLint;
-import android.app.*;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.app.Fragment;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ApplicationInfo;
@@ -18,6 +22,8 @@ import android.os.Looper;
 import android.preference.Preference;
 import android.preference.PreferenceGroup;
 import android.preference.PreferenceScreen;
+import android.util.Pair;
+import android.util.TypedValue;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewParent;
@@ -357,15 +363,17 @@ public class Utils {
 
     public static Context getContext() {
         if (context == null) {
-            Logger.initializationException(Utils.class, "Context is not set by extension hook, returning null",  null);
+            Logger.initializationException(() -> "Context is not set by extension hook, returning null",  null);
         }
         return context;
     }
 
     public static void setContext(Context appContext) {
+        // Intentionally use logger before context is set,
+        // to expose any bugs in the 'no context available' logger method.
+        Logger.initializationInfo(() -> "Set context: " + appContext);
         // Must initially set context to check the app language.
         context = appContext;
-        Logger.initializationInfo(Utils.class, "Set context: " + appContext);
 
         AppLanguage language = BaseSettings.REVANCED_LANGUAGE.get();
         if (language != AppLanguage.DEFAULT) {
@@ -377,8 +385,9 @@ public class Utils {
         }
     }
 
-    public static void setClipboard(@NonNull String text) {
+    public static void setClipboard(CharSequence text) {
-        android.content.ClipboardManager clipboard = (android.content.ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
+        android.content.ClipboardManager clipboard = (android.content.ClipboardManager) context
+                .getSystemService(Context.CLIPBOARD_SERVICE);
         android.content.ClipData clip = android.content.ClipData.newPlainText("ReVanced", text);
         clipboard.setPrimaryClip(clip);
     }
@@ -542,24 +551,25 @@ public class Utils {
     private static void showToast(@NonNull String messageToToast, int toastDuration) {
         Objects.requireNonNull(messageToToast);
         runOnMainThreadNowOrLater(() -> {
-                    if (context == null) {
+            Context currentContext = context;
-                        Logger.initializationException(Utils.class, "Cannot show toast (context is null): " + messageToToast, null);
+
-                    } else {
+            if (currentContext == null) {
-                        Logger.printDebug(() -> "Showing toast: " + messageToToast);
+                Logger.initializationException(() -> "Cannot show toast (context is null): " + messageToToast, null);
-                        Toast.makeText(context, messageToToast, toastDuration).show();
+            } else {
-                    }
+                Logger.printDebug(() -> "Showing toast: " + messageToToast);
-                }
+                Toast.makeText(currentContext, messageToToast, toastDuration).show();
-        );
+            }
+        });
     }
 
-    public static boolean isDarkModeEnabled(Context context) {
+    public static boolean isDarkModeEnabled() {
-        Configuration config = context.getResources().getConfiguration();
+        Configuration config = Resources.getSystem().getConfiguration();
         final int currentNightMode = config.uiMode & Configuration.UI_MODE_NIGHT_MASK;
         return currentNightMode == Configuration.UI_MODE_NIGHT_YES;
     }
 
     public static boolean isLandscapeOrientation() {
-        final int orientation = context.getResources().getConfiguration().orientation;
+        final int orientation = Resources.getSystem().getConfiguration().orientation;
         return orientation == Configuration.ORIENTATION_LANDSCAPE;
     }
 
@@ -573,7 +583,7 @@ public class Utils {
     }
 
     /**
-     * Automatically logs any exceptions the runnable throws
+     * Automatically logs any exceptions the runnable throws.
      */
     public static void runOnMainThreadDelayed(@NonNull Runnable runnable, long delayMillis) {
         Runnable loggingRunnable = () -> {
@@ -599,14 +609,14 @@ public class Utils {
     }
 
     /**
-     * @return if the calling thread is on the main thread
+     * @return if the calling thread is on the main thread.
      */
     public static boolean isCurrentlyOnMainThread() {
         return Looper.getMainLooper().isCurrentThread();
     }
 
     /**
-     * @throws IllegalStateException if the calling thread is _off_ the main thread
+     * @throws IllegalStateException if the calling thread is _off_ the main thread.
      */
     public static void verifyOnMainThread() throws IllegalStateException {
         if (!isCurrentlyOnMainThread()) {
@@ -615,7 +625,7 @@ public class Utils {
     }
 
     /**
-     * @throws IllegalStateException if the calling thread is _on_ the main thread
+     * @throws IllegalStateException if the calling thread is _on_ the main thread.
      */
     public static void verifyOffMainThread() throws IllegalStateException {
         if (isCurrentlyOnMainThread()) {
@@ -629,13 +639,23 @@ public class Utils {
         OTHER,
     }
 
+    /**
+     * Calling extension code must ensure the un-patched app has the permission
+     * <code>android.permission.ACCESS_NETWORK_STATE</code>, otherwise the app will crash
+     * if this method is used.
+     */
     public static boolean isNetworkConnected() {
         NetworkType networkType = getNetworkType();
         return networkType == NetworkType.MOBILE
                 || networkType == NetworkType.OTHER;
     }
 
-    @SuppressLint({"MissingPermission", "deprecation"}) // Permission already included in YouTube.
+    /**
+     * Calling extension code must ensure the un-patched app has the permission
+     * <code>android.permission.ACCESS_NETWORK_STATE</code>, otherwise the app will crash
+     * if this method is used.
+     */
+    @SuppressLint({"MissingPermission", "deprecation"})
     public static NetworkType getNetworkType() {
         Context networkContext = getContext();
         if (networkContext == null) {
@@ -738,9 +758,9 @@ public class Utils {
      * then the preferences are left unsorted.
      */
     @SuppressWarnings("deprecation")
-    public static void sortPreferenceGroups(@NonNull PreferenceGroup group) {
+    public static void sortPreferenceGroups(PreferenceGroup group) {
         Sort groupSort = Sort.fromKey(group.getKey(), Sort.UNSORTED);
-        SortedMap<String, Preference> preferences = new TreeMap<>();
+        List<Pair<String, Preference>> preferences = new ArrayList<>();
 
         for (int i = 0, prefCount = group.getPreferenceCount(); i < prefCount; i++) {
             Preference preference = group.getPreference(i);
@@ -769,17 +789,22 @@ public class Utils {
                     throw new IllegalStateException();
             }
 
-            preferences.put(sortValue, preference);
+            preferences.add(new Pair<>(sortValue, preference));
         }
 
+        //noinspection ComparatorCombinators
+        Collections.sort(preferences, (pair1, pair2)
+                -> pair1.first.compareTo(pair2.first));
+
         int index = 0;
-        for (Preference pref : preferences.values()) {
+        for (Pair<String, Preference> pair : preferences) {
             int order = index++;
+            Preference pref = pair.second;
 
             // Move any screens, intents, and the one off About preference to the top.
             if (pref instanceof PreferenceScreen || pref instanceof ReVancedAboutPreference
                     || pref.getIntent() != null) {
-                // Arbitrary high number.
+                // Any arbitrary large number.
                 order -= 1000;
             }
 
@@ -843,6 +868,20 @@ public class Utils {
         return getResourceColor(colorString);
     }
 
+    /**
+     * Converts dip value to actual device pixels.
+     *
+     * @param dip The density-independent pixels value
+     * @return The device pixel value
+     */
+    public static int dipToPixels(float dip) {
+        return (int) TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_DIP,
+                dip,
+                Resources.getSystem().getDisplayMetrics()
+        );
+    }
+
     public static int clamp(int value, int lower, int upper) {
         return Math.max(lower, Math.min(value, upper));
     }

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

@@ -0,0 +1,442 @@
+package app.revanced.extension.shared.settings.preference;
+
+import static app.revanced.extension.shared.StringRef.str;
+import static app.revanced.extension.shared.Utils.getResourceIdentifier;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.Typeface;
+import android.os.Build;
+import android.os.Bundle;
+import android.preference.EditTextPreference;
+import android.text.Editable;
+import android.text.InputType;
+import android.text.SpannableString;
+import android.text.Spanned;
+import android.text.TextWatcher;
+import android.text.style.ForegroundColorSpan;
+import android.text.style.RelativeSizeSpan;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import androidx.annotation.ColorInt;
+
+import java.util.Locale;
+import java.util.regex.Pattern;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.settings.Setting;
+import app.revanced.extension.shared.settings.StringSetting;
+
+/**
+ * A custom preference for selecting a color via a hexadecimal code or a color picker dialog.
+ * Extends {@link EditTextPreference} to display a colored dot in the widget area,
+ * reflecting the currently selected color. The dot is dimmed when the preference is disabled.
+ */
+@SuppressWarnings({"unused", "deprecation"})
+public class ColorPickerPreference extends EditTextPreference {
+
+    /**
+     * Character to show the color appearance.
+     */
+    public static final String COLOR_DOT_STRING = "⬤";
+
+    /**
+     * Length of a valid color string of format #RRGGBB.
+     */
+    public static final int COLOR_STRING_LENGTH = 7;
+
+    /**
+     * Matches everything that is not a hex number/letter.
+     */
+    private static final Pattern PATTERN_NOT_HEX = Pattern.compile("[^0-9A-Fa-f]");
+
+    /**
+     * Alpha for dimming when the preference is disabled.
+     */
+    private static final float DISABLED_ALPHA = 0.5f; // 50%
+
+    /**
+     * View displaying a colored dot in the widget area.
+     */
+    private View widgetColorDot;
+
+    /**
+     * Current color in RGB format (without alpha).
+     */
+    @ColorInt
+    private int currentColor;
+
+    /**
+     * Associated setting for storing the color value.
+     */
+    private StringSetting colorSetting;
+
+    /**
+     * Dialog TextWatcher for the EditText to monitor color input changes.
+     */
+    private TextWatcher colorTextWatcher;
+
+    /**
+     * Dialog TextView displaying a colored dot for the selected color preview in the dialog.
+     */
+    private TextView dialogColorPreview;
+
+    /**
+     * Dialog color picker view.
+     */
+    private ColorPickerView dialogColorPickerView;
+
+    /**
+     * Removes non valid hex characters, converts to all uppercase,
+     * and adds # character to the start if not present.
+     */
+    public static String cleanupColorCodeString(String colorString) {
+        // Remove non-hex chars, convert to uppercase, and ensure correct length
+        String result = "#" + PATTERN_NOT_HEX.matcher(colorString)
+                .replaceAll("").toUpperCase(Locale.ROOT);
+
+        if (result.length() < COLOR_STRING_LENGTH) {
+            return result;
+        }
+
+        return result.substring(0, COLOR_STRING_LENGTH);
+    }
+
+    /**
+     * @param color RGB color, without an alpha channel.
+     * @return #RRGGBB hex color string
+     */
+    public static String getColorString(@ColorInt int color) {
+        String colorString = String.format("#%06X", color);
+        if ((color & 0xFF000000) != 0) {
+            // Likely a bug somewhere.
+            Logger.printException(() -> "getColorString: color has alpha channel: " + colorString);
+        }
+        return colorString;
+    }
+
+    /**
+     * Creates a Spanned object for a colored dot using SpannableString.
+     *
+     * @param color The RGB color (without alpha).
+     * @return A Spanned object with the colored dot.
+     */
+    public static Spanned getColorDot(@ColorInt int color) {
+        SpannableString spannable = new SpannableString(COLOR_DOT_STRING);
+        spannable.setSpan(new ForegroundColorSpan(color | 0xFF000000), 0, COLOR_DOT_STRING.length(),
+                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+        spannable.setSpan(new RelativeSizeSpan(1.5f), 0, 1,
+                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+        return spannable;
+    }
+
+    public ColorPickerPreference(Context context) {
+        super(context);
+        init();
+    }
+
+    public ColorPickerPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    public ColorPickerPreference(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init();
+    }
+
+    /**
+     * Initializes the preference by setting up the EditText, loading the color, and set the widget layout.
+     */
+    private void init() {
+        colorSetting = (StringSetting) Setting.getSettingFromPath(getKey());
+        if (colorSetting == null) {
+            Logger.printException(() -> "Could not find color setting for: " + getKey());
+        }
+
+        EditText editText = getEditText();
+        editText.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS
+                | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            editText.setAutofillHints((String) null);
+        }
+
+        // Set the widget layout to a custom layout containing the colored dot.
+        setWidgetLayoutResource(getResourceIdentifier("revanced_color_dot_widget", "layout"));
+    }
+
+    /**
+     * Sets the selected color and updates the UI and settings.
+     *
+     * @param colorString The color in hexadecimal format (e.g., "#RRGGBB").
+     * @throws IllegalArgumentException If the color string is invalid.
+     */
+    @Override
+    public final void setText(String colorString)  {
+        try {
+            Logger.printDebug(() -> "setText: " + colorString);
+            super.setText(colorString);
+
+            currentColor = Color.parseColor(colorString) & 0x00FFFFFF;
+            if (colorSetting != null) {
+                colorSetting.save(getColorString(currentColor));
+            }
+            updateColorPreview();
+            updateWidgetColorDot();
+        } catch (IllegalArgumentException ex) {
+            // This code is reached if the user pastes settings json with an invalid color
+            // since this preference is updated with the new setting text.
+            Logger.printDebug(() -> "Parse color error: " + colorString, ex);
+            Utils.showToastShort(str("revanced_settings_color_invalid"));
+            setText(colorSetting.resetToDefault());
+        } catch (Exception ex) {
+            Logger.printException(() -> "setText failure: " + colorString, ex);
+        }
+    }
+
+    @Override
+    protected void onBindView(View view) {
+        super.onBindView(view);
+
+        widgetColorDot = view.findViewById(getResourceIdentifier(
+                "revanced_color_dot_widget", "id"));
+        widgetColorDot.setBackgroundResource(getResourceIdentifier(
+                "revanced_settings_circle_background", "drawable"));
+        widgetColorDot.getBackground().setTint(currentColor | 0xFF000000);
+        widgetColorDot.setAlpha(isEnabled() ? 1.0f : DISABLED_ALPHA);
+    }
+
+    /**
+     * Creates a layout with a color preview and EditText for hex color input.
+     *
+     * @param context The context for creating the layout.
+     * @return A LinearLayout containing the color preview and EditText.
+     */
+    private LinearLayout createDialogLayout(Context context) {
+        LinearLayout layout = new LinearLayout(context);
+        layout.setOrientation(LinearLayout.VERTICAL);
+        layout.setPadding(70, 0, 70, 0);
+
+        // Inflate color picker.
+        View colorPicker = LayoutInflater.from(context).inflate(
+                getResourceIdentifier("revanced_color_picker", "layout"), null);
+        dialogColorPickerView = colorPicker.findViewById(
+                getResourceIdentifier("color_picker_view", "id"));
+        dialogColorPickerView.setColor(currentColor);
+        layout.addView(colorPicker);
+
+        // Horizontal layout for preview and EditText.
+        LinearLayout inputLayout = new LinearLayout(context);
+        inputLayout.setOrientation(LinearLayout.HORIZONTAL);
+        inputLayout.setPadding(0, 20, 0, 0);
+
+        dialogColorPreview = new TextView(context);
+        inputLayout.addView(dialogColorPreview);
+        updateColorPreview();
+
+        EditText editText = getEditText();
+        ViewParent parent = editText.getParent();
+        if (parent instanceof ViewGroup parentViewGroup) {
+            parentViewGroup.removeView(editText);
+        }
+        editText.setLayoutParams(new LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.WRAP_CONTENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT
+        ));
+        String currentColorString = getColorString(currentColor);
+        editText.setText(currentColorString);
+        editText.setSelection(currentColorString.length());
+        editText.setTypeface(Typeface.MONOSPACE);
+        colorTextWatcher = createColorTextWatcher(dialogColorPickerView);
+        editText.addTextChangedListener(colorTextWatcher);
+        inputLayout.addView(editText);
+
+        // Add a dummy view to take up remaining horizontal space,
+        // otherwise it will show an oversize underlined text view.
+        View paddingView = new View(context);
+        LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
+                0,
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                1f
+        );
+        paddingView.setLayoutParams(params);
+        inputLayout.addView(paddingView);
+
+        layout.addView(inputLayout);
+
+        // Set up color picker listener with debouncing.
+        // Add listener last to prevent callbacks from set calls above.
+        dialogColorPickerView.setOnColorChangedListener(color -> {
+            // Check if it actually changed, since this callback
+            // can be caused by updates in afterTextChanged().
+            if (currentColor == color) {
+                return;
+            }
+
+            String updatedColorString = getColorString(color);
+            Logger.printDebug(() -> "onColorChanged: " + updatedColorString);
+            currentColor = color;
+            editText.setText(updatedColorString);
+            editText.setSelection(updatedColorString.length());
+
+            updateColorPreview();
+            updateWidgetColorDot();
+        });
+
+        return layout;
+    }
+
+    /**
+     * Updates the color preview TextView with a colored dot.
+     */
+    private void updateColorPreview() {
+        if (dialogColorPreview != null) {
+            dialogColorPreview.setText(getColorDot(currentColor));
+        }
+    }
+
+    private void updateWidgetColorDot() {
+        if (widgetColorDot != null) {
+            widgetColorDot.getBackground().setTint(currentColor | 0xFF000000);
+            widgetColorDot.setAlpha(isEnabled() ? 1.0f : DISABLED_ALPHA);
+        }
+    }
+
+    /**
+     * Creates a TextWatcher to monitor changes in the EditText for color input.
+     *
+     * @return A TextWatcher that updates the color preview on valid input.
+     */
+    private TextWatcher createColorTextWatcher(ColorPickerView colorPickerView) {
+        return new TextWatcher() {
+            @Override
+            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+            }
+
+            @Override
+            public void onTextChanged(CharSequence s, int start, int before, int count) {
+            }
+
+            @Override
+            public void afterTextChanged(Editable edit) {
+                try {
+                    String colorString = edit.toString();
+
+                    String sanitizedColorString = cleanupColorCodeString(colorString);
+                    if (!sanitizedColorString.equals(colorString)) {
+                        edit.replace(0, colorString.length(), sanitizedColorString);
+                        return;
+                    }
+
+                    if (sanitizedColorString.length() != COLOR_STRING_LENGTH) {
+                        // User is still typing out the color.
+                        return;
+                    }
+
+                    final int newColor = Color.parseColor(colorString);
+                    if (currentColor != newColor) {
+                        Logger.printDebug(() -> "afterTextChanged: " + sanitizedColorString);
+                        currentColor = newColor;
+                        updateColorPreview();
+                        updateWidgetColorDot();
+                        colorPickerView.setColor(newColor);
+                    }
+                } catch (Exception ex) {
+                    // Should never be reached since input is validated before using.
+                    Logger.printException(() -> "afterTextChanged failure", ex);
+                }
+            }
+        };
+    }
+
+    /**
+     * Prepares the dialog builder with a custom view and reset button.
+     *
+     * @param builder The AlertDialog.Builder to configure.
+     */
+    @Override
+    protected void onPrepareDialogBuilder(AlertDialog.Builder builder) {
+        Utils.setEditTextDialogTheme(builder);
+        LinearLayout dialogLayout = createDialogLayout(builder.getContext());
+        builder.setView(dialogLayout);
+        final int originalColor = currentColor;
+
+        builder.setNeutralButton(str("revanced_settings_reset_color"), null);
+
+        builder.setPositiveButton(android.R.string.ok, (dialog, which) -> {
+            try {
+                String colorString = getEditText().getText().toString();
+
+                if (colorString.length() != COLOR_STRING_LENGTH) {
+                    Utils.showToastShort(str("revanced_settings_color_invalid"));
+                    setText(getColorString(originalColor));
+                    return;
+                }
+
+                setText(colorString);
+            } catch (Exception ex) {
+                // Should never happen due to a bad color string,
+                // since the text is validated and fixed while the user types.
+                Logger.printException(() -> "setPositiveButton failure", ex);
+            }
+        });
+
+        builder.setNegativeButton(android.R.string.cancel, (dialog, which) -> {
+            try {
+                // Restore the original color.
+                setText(getColorString(originalColor));
+            } catch (Exception ex) {
+                Logger.printException(() -> "setNegativeButton failure", ex);
+            }
+        });
+    }
+
+    @Override
+    protected void showDialog(Bundle state) {
+        super.showDialog(state);
+
+        AlertDialog dialog = (AlertDialog) getDialog();
+        dialog.setCanceledOnTouchOutside(false);
+
+        // Do not close dialog when reset is pressed.
+        Button button = dialog.getButton(AlertDialog.BUTTON_NEUTRAL);
+        button.setOnClickListener(view -> {
+            try {
+                final int defaultColor = Color.parseColor(colorSetting.defaultValue) & 0x00FFFFFF;
+                // Setting view color causes listener callback into this class.
+                dialogColorPickerView.setColor(defaultColor);
+            } catch (Exception ex) {
+                Logger.printException(() -> "setOnClickListener failure", ex);
+            }
+        });
+    }
+
+    @Override
+    protected void onDialogClosed(boolean positiveResult) {
+        super.onDialogClosed(positiveResult);
+
+        if (colorTextWatcher != null) {
+            getEditText().removeTextChangedListener(colorTextWatcher);
+            colorTextWatcher = null;
+        }
+
+        dialogColorPreview = null;
+        dialogColorPickerView = null;
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+        super.setEnabled(enabled);
+        updateWidgetColorDot();
+    }
+}

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

@@ -0,0 +1,500 @@
+package app.revanced.extension.shared.settings.preference;
+
+import static app.revanced.extension.shared.Utils.dipToPixels;
+import static app.revanced.extension.shared.settings.preference.ColorPickerPreference.getColorString;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ComposeShader;
+import android.graphics.LinearGradient;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+
+import androidx.annotation.ColorInt;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+
+/**
+ * A custom color picker view that allows the user to select a color using a hue slider and a saturation-value selector.
+ * This implementation is density-independent and responsive across different screen sizes and DPIs.
+ *
+ * <p>
+ * This view displays two main components for color selection:
+ * <ul>
+ *     <li><b>Hue Bar:</b> A vertical bar on the right that allows the user to select the hue component of the color.
+ *     <li><b>Saturation-Value Selector:</b> A rectangular area that allows the user to select the saturation and value (brightness)
+ *     components of the color based on the selected hue.
+ * </ul>
+ *
+ * <p>
+ * The view uses {@link LinearGradient} and {@link ComposeShader} to create the color gradients for the hue bar and the
+ * saturation-value selector. It also uses {@link Paint} to draw the selectors (draggable handles).
+ *
+ * <p>
+ * The selected color can be retrieved using {@link #getColor()} and can be set using {@link #setColor(int)}.
+ * An {@link OnColorChangedListener} can be registered to receive notifications when the selected color changes.
+ */
+public class ColorPickerView extends View {
+
+    /**
+     * Interface definition for a callback to be invoked when the selected color changes.
+     */
+    public interface OnColorChangedListener {
+        /**
+         * Called when the selected color has changed.
+         *
+         * Important: Callback color uses RGB format with zero alpha channel.
+         *
+         * @param color The new selected color.
+         */
+        void onColorChanged(@ColorInt int color);
+    }
+
+    /** Expanded touch area for the hue bar to increase the touch-sensitive area. */
+    public static final float TOUCH_EXPANSION = dipToPixels(20f);
+
+    private static final float MARGIN_BETWEEN_AREAS = dipToPixels(24);
+    private static final float VIEW_PADDING = dipToPixels(16);
+    private static final float HUE_BAR_WIDTH = dipToPixels(12);
+    private static final float HUE_CORNER_RADIUS = dipToPixels(6);
+    private static final float SELECTOR_RADIUS = dipToPixels(12);
+    private static final float SELECTOR_STROKE_WIDTH = 8;
+    /**
+     * Hue fill radius.  Use slightly smaller radius for the selector handle fill,
+     * otherwise the anti-aliasing causes the fill color to bleed past the selector outline.
+     */
+    private static final float SELECTOR_FILL_RADIUS = SELECTOR_RADIUS - SELECTOR_STROKE_WIDTH / 2;
+    /** Thin dark outline stroke width for the selector rings. */
+    private static final float SELECTOR_EDGE_STROKE_WIDTH = 1;
+    public static final float SELECTOR_EDGE_RADIUS =
+            SELECTOR_RADIUS + SELECTOR_STROKE_WIDTH / 2 + SELECTOR_EDGE_STROKE_WIDTH / 2;
+
+    /** Selector outline inner color. */
+    @ColorInt
+    private static final int SELECTOR_OUTLINE_COLOR = Color.WHITE;
+
+    /** Dark edge color for the selector rings. */
+    @ColorInt
+    private static final int SELECTOR_EDGE_COLOR = Color.parseColor("#CFCFCF");
+
+    private static final int[] HUE_COLORS = new int[361];
+    static {
+        for (int i = 0; i < 361; i++) {
+            HUE_COLORS[i] = Color.HSVToColor(new float[]{i, 1, 1});
+        }
+    }
+
+    /** Hue bar. */
+    private final Paint huePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    /** Saturation-value selector. */
+    private final Paint saturationValuePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    /** Draggable selector. */
+    private final Paint selectorPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    {
+        selectorPaint.setStrokeWidth(SELECTOR_STROKE_WIDTH);
+    }
+
+    /** Bounds of the hue bar. */
+    private final RectF hueRect = new RectF();
+    /** Bounds of the saturation-value selector. */
+    private final RectF saturationValueRect = new RectF();
+
+    /** HSV color calculations to avoid allocations during drawing. */
+    private final float[] hsvArray = {1, 1, 1};
+
+    /** Current hue value (0-360). */
+    private float hue = 0f;
+    /** Current saturation value (0-1). */
+    private float saturation = 1f;
+    /** Current value (brightness) value (0-1). */
+    private float value = 1f;
+
+    /** The currently selected color in RGB format with no alpha channel. */
+    @ColorInt
+    private int selectedColor;
+
+    private OnColorChangedListener colorChangedListener;
+
+    /** Track if we're currently dragging the hue or saturation handle. */
+    private boolean isDraggingHue;
+    private boolean isDraggingSaturation;
+
+    public ColorPickerView(Context context) {
+        super(context);
+    }
+
+    public ColorPickerView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public ColorPickerView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final float DESIRED_ASPECT_RATIO = 0.8f; // height = width * 0.8
+
+        final int minWidth = Utils.dipToPixels(250);
+        final int minHeight = (int) (minWidth * DESIRED_ASPECT_RATIO);
+
+        int width = resolveSize(minWidth, widthMeasureSpec);
+        int height = resolveSize(minHeight, heightMeasureSpec);
+
+        // Ensure minimum dimensions for usability
+        width = Math.max(width, minWidth);
+        height = Math.max(height, minHeight);
+
+        // Adjust height to maintain desired aspect ratio if possible
+        final int desiredHeight = (int) (width * DESIRED_ASPECT_RATIO);
+        if (MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY) {
+            height = desiredHeight;
+        }
+
+        setMeasuredDimension(width, height);
+    }
+
+    /**
+     * Called when the size of the view changes.
+     * This method calculates and sets the bounds of the hue bar and saturation-value selector.
+     * It also creates the necessary shaders for the gradients.
+     */
+    @Override
+    protected void onSizeChanged(int width, int height, int oldWidth, int oldHeight) {
+        super.onSizeChanged(width, height, oldWidth, oldHeight);
+
+        // Calculate bounds with hue bar on the right
+        final float effectiveWidth = width - (2 * VIEW_PADDING);
+        final float selectorWidth = effectiveWidth - HUE_BAR_WIDTH - MARGIN_BETWEEN_AREAS;
+
+        // Adjust rectangles to account for padding and density-independent dimensions
+        saturationValueRect.set(
+                VIEW_PADDING,
+                VIEW_PADDING,
+                VIEW_PADDING + selectorWidth,
+                height - VIEW_PADDING
+        );
+
+        hueRect.set(
+                width - VIEW_PADDING - HUE_BAR_WIDTH,
+                VIEW_PADDING,
+                width - VIEW_PADDING,
+                height - VIEW_PADDING
+        );
+
+        // Update the shaders.
+        updateHueShader();
+        updateSaturationValueShader();
+    }
+
+    /**
+     * Updates the hue full spectrum (0-360 degrees).
+     */
+    private void updateHueShader() {
+        LinearGradient hueShader = new LinearGradient(
+                hueRect.left, hueRect.top,
+                hueRect.left, hueRect.bottom,
+                HUE_COLORS,
+                null,
+                Shader.TileMode.CLAMP
+        );
+
+        huePaint.setShader(hueShader);
+    }
+
+    /**
+     * Updates the shader for the saturation-value selector based on the currently selected hue.
+     * This method creates a combined shader that blends a saturation gradient with a value gradient.
+     */
+    private void updateSaturationValueShader() {
+        // Create a saturation-value gradient based on the current hue.
+        // Calculate the start color (white with the selected hue) for the saturation gradient.
+        final int startColor = Color.HSVToColor(new float[]{hue, 0f, 1f});
+
+        // Calculate the middle color (fully saturated color with the selected hue) for the saturation gradient.
+        final int midColor = Color.HSVToColor(new float[]{hue, 1f, 1f});
+
+        // Create a linear gradient for the saturation from startColor to midColor (horizontal).
+        LinearGradient satShader = new LinearGradient(
+                saturationValueRect.left, saturationValueRect.top,
+                saturationValueRect.right, saturationValueRect.top,
+                startColor,
+                midColor,
+                Shader.TileMode.CLAMP
+        );
+
+        // Create a linear gradient for the value (brightness) from white to black (vertical).
+        //noinspection ExtractMethodRecommender
+        LinearGradient valShader = new LinearGradient(
+                saturationValueRect.left, saturationValueRect.top,
+                saturationValueRect.left, saturationValueRect.bottom,
+                Color.WHITE,
+                Color.BLACK,
+                Shader.TileMode.CLAMP
+        );
+
+        // Combine the saturation and value shaders using PorterDuff.Mode.MULTIPLY to create the final color.
+        ComposeShader combinedShader = new ComposeShader(satShader, valShader, PorterDuff.Mode.MULTIPLY);
+
+        // Set the combined shader for the saturation-value paint.
+        saturationValuePaint.setShader(combinedShader);
+    }
+
+    /**
+     * Draws the color picker view on the canvas.
+     * This method draws the saturation-value selector, the hue bar with rounded corners,
+     * and the draggable handles.
+     *
+     * @param canvas The canvas on which to draw.
+     */
+    @Override
+    protected void onDraw(Canvas canvas) {
+        // Draw the saturation-value selector rectangle.
+        canvas.drawRect(saturationValueRect, saturationValuePaint);
+
+        // Draw the hue bar.
+        canvas.drawRoundRect(hueRect, HUE_CORNER_RADIUS, HUE_CORNER_RADIUS, huePaint);
+
+        final float hueSelectorX = hueRect.centerX();
+        final float hueSelectorY = hueRect.top + (hue / 360f) * hueRect.height();
+
+        final float satSelectorX = saturationValueRect.left + saturation * saturationValueRect.width();
+        final float satSelectorY = saturationValueRect.top + (1 - value) * saturationValueRect.height();
+
+        // Draw the saturation and hue selector handle filled with the selected color.
+        hsvArray[0] = hue;
+        final int hueHandleColor = Color.HSVToColor(0xFF, hsvArray);
+        selectorPaint.setStyle(Paint.Style.FILL_AND_STROKE);
+
+        selectorPaint.setColor(hueHandleColor);
+        canvas.drawCircle(hueSelectorX, hueSelectorY, SELECTOR_FILL_RADIUS, selectorPaint);
+
+        selectorPaint.setColor(selectedColor | 0xFF000000);
+        canvas.drawCircle(satSelectorX, satSelectorY, SELECTOR_FILL_RADIUS, selectorPaint);
+
+        // Draw white outlines for the handles.
+        selectorPaint.setColor(SELECTOR_OUTLINE_COLOR);
+        selectorPaint.setStyle(Paint.Style.STROKE);
+        selectorPaint.setStrokeWidth(SELECTOR_STROKE_WIDTH);
+        canvas.drawCircle(hueSelectorX, hueSelectorY, SELECTOR_RADIUS, selectorPaint);
+        canvas.drawCircle(satSelectorX, satSelectorY, SELECTOR_RADIUS, selectorPaint);
+
+        // Draw thin dark outlines for the handles at the outer edge of the white outline.
+        selectorPaint.setColor(SELECTOR_EDGE_COLOR);
+        selectorPaint.setStrokeWidth(SELECTOR_EDGE_STROKE_WIDTH);
+        canvas.drawCircle(hueSelectorX, hueSelectorY, SELECTOR_EDGE_RADIUS, selectorPaint);
+        canvas.drawCircle(satSelectorX, satSelectorY, SELECTOR_EDGE_RADIUS, selectorPaint);
+    }
+
+    /**
+     * Handles touch events on the view.
+     * This method determines whether the touch event occurred within the hue bar or the saturation-value selector,
+     * updates the corresponding values (hue, saturation, value), and invalidates the view to trigger a redraw.
+     * <p>
+     * In addition to testing if the touch is within the strict rectangles, an expanded hit area (by selectorRadius)
+     * is used so that the draggable handles remain active even when half of the handle is outside the drawn bounds.
+     *
+     * @param event The motion event.
+     * @return True if the event was handled, false otherwise.
+     */
+    @SuppressLint("ClickableViewAccessibility") // performClick is not overridden, but not needed in this case.
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        try {
+            final float x = event.getX();
+            final float y = event.getY();
+            final int action = event.getAction();
+            Logger.printDebug(() -> "onTouchEvent action: " + action + " x: " + x + " y: " + y);
+
+            // Define touch expansion for the hue bar.
+            RectF expandedHueRect = new RectF(
+                    hueRect.left - TOUCH_EXPANSION,
+                    hueRect.top,
+                    hueRect.right + TOUCH_EXPANSION,
+                    hueRect.bottom
+            );
+
+            switch (action) {
+                case MotionEvent.ACTION_DOWN:
+                    // Calculate current handle positions.
+                    final float hueSelectorX = hueRect.centerX();
+                    final float hueSelectorY = hueRect.top + (hue / 360f) * hueRect.height();
+
+                    final float satSelectorX = saturationValueRect.left + saturation * saturationValueRect.width();
+                    final float valSelectorY = saturationValueRect.top + (1 - value) * saturationValueRect.height();
+
+                    // Create hit areas for both handles.
+                    RectF hueHitRect = new RectF(
+                            hueSelectorX - SELECTOR_RADIUS,
+                            hueSelectorY - SELECTOR_RADIUS,
+                            hueSelectorX + SELECTOR_RADIUS,
+                            hueSelectorY + SELECTOR_RADIUS
+                    );
+                    RectF satValHitRect = new RectF(
+                            satSelectorX - SELECTOR_RADIUS,
+                            valSelectorY - SELECTOR_RADIUS,
+                            satSelectorX + SELECTOR_RADIUS,
+                            valSelectorY + SELECTOR_RADIUS
+                    );
+
+                    // Check if the touch started on a handle or within the expanded hue bar area.
+                    if (hueHitRect.contains(x, y)) {
+                        isDraggingHue = true;
+                        updateHueFromTouch(y);
+                    } else if (satValHitRect.contains(x, y)) {
+                        isDraggingSaturation = true;
+                        updateSaturationValueFromTouch(x, y);
+                    } else if (expandedHueRect.contains(x, y)) {
+                        // Handle touch within the expanded hue bar area.
+                        isDraggingHue = true;
+                        updateHueFromTouch(y);
+                    } else if (saturationValueRect.contains(x, y)) {
+                        isDraggingSaturation = true;
+                        updateSaturationValueFromTouch(x, y);
+                    }
+                    break;
+
+                case MotionEvent.ACTION_MOVE:
+                    // Continue updating values even if touch moves outside the view.
+                    if (isDraggingHue) {
+                        updateHueFromTouch(y);
+                    } else if (isDraggingSaturation) {
+                        updateSaturationValueFromTouch(x, y);
+                    }
+                    break;
+
+                case MotionEvent.ACTION_UP:
+                case MotionEvent.ACTION_CANCEL:
+                    isDraggingHue = false;
+                    isDraggingSaturation = false;
+                    break;
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "onTouchEvent failure", ex);
+        }
+
+        return true;
+    }
+
+    /**
+     * Updates the hue value based on touch position, clamping to valid range.
+     *
+     * @param y The y-coordinate of the touch position.
+     */
+    private void updateHueFromTouch(float y) {
+        // Clamp y to the hue rectangle bounds.
+        final float clampedY = Utils.clamp(y, hueRect.top, hueRect.bottom);
+        final float updatedHue = ((clampedY - hueRect.top) / hueRect.height()) * 360f;
+        if (hue == updatedHue) {
+            return;
+        }
+
+        hue = updatedHue;
+        updateSaturationValueShader();
+        updateSelectedColor();
+    }
+
+    /**
+     * Updates saturation and value based on touch position, clamping to valid range.
+     *
+     * @param x The x-coordinate of the touch position.
+     * @param y The y-coordinate of the touch position.
+     */
+    private void updateSaturationValueFromTouch(float x, float y) {
+        // Clamp x and y to the saturation-value rectangle bounds.
+        final float clampedX = Utils.clamp(x, saturationValueRect.left, saturationValueRect.right);
+        final float clampedY = Utils.clamp(y, saturationValueRect.top, saturationValueRect.bottom);
+
+        final float updatedSaturation = (clampedX - saturationValueRect.left) / saturationValueRect.width();
+        final float updatedValue = 1 - ((clampedY - saturationValueRect.top) / saturationValueRect.height());
+
+        if (saturation == updatedSaturation && value == updatedValue) {
+            return;
+        }
+        saturation = updatedSaturation;
+        value = updatedValue;
+        updateSelectedColor();
+    }
+
+    /**
+     * Updates the selected color and notifies listeners.
+     */
+    private void updateSelectedColor() {
+        final int updatedColor = Color.HSVToColor(0, new float[]{hue, saturation, value});
+
+        if (selectedColor != updatedColor) {
+            selectedColor = updatedColor;
+
+            if (colorChangedListener != null) {
+                colorChangedListener.onColorChanged(updatedColor);
+            }
+        }
+
+        // Must always redraw, otherwise if saturation is pure grey or black
+        // then the hue slider cannot be changed.
+        invalidate();
+    }
+
+    /**
+     * Sets the currently selected color.
+     *
+     * @param color The color to set in either ARGB or RGB format.
+     */
+    public void setColor(@ColorInt int color) {
+        color &= 0x00FFFFFF;
+        if (selectedColor == color) {
+            return;
+        }
+
+        // Update the selected color.
+        selectedColor = color;
+        Logger.printDebug(() -> "setColor: " + getColorString(selectedColor));
+
+        // Convert the ARGB color to HSV values.
+        float[] hsv = new float[3];
+        Color.colorToHSV(color, hsv);
+
+        // Update the hue, saturation, and value.
+        hue = hsv[0];
+        saturation = hsv[1];
+        value = hsv[2];
+
+        // Update the saturation-value shader based on the new hue.
+        updateSaturationValueShader();
+
+        // Notify the listener if it's set.
+        if (colorChangedListener != null) {
+            colorChangedListener.onColorChanged(selectedColor);
+        }
+
+        // Invalidate the view to trigger a redraw.
+        invalidate();
+    }
+
+    /**
+     * Gets the currently selected color.
+     *
+     * @return The selected color in RGB format with no alpha channel.
+     */
+    @ColorInt
+    public int getColor() {
+        return selectedColor;
+    }
+
+    /**
+     * Sets the listener to be notified when the selected color changes.
+     *
+     * @param listener The listener to set.
+     */
+    public void setOnColorChangedListener(OnColorChangedListener listener) {
+        colorChangedListener = listener;
+    }
+}

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

@@ -70,7 +70,7 @@ public class ImportExportPreference extends EditTextPreference implements Prefer
 
             // Show the user the settings in JSON format.
             builder.setNeutralButton(str("revanced_settings_import_copy"), (dialog, which) -> {
-                Utils.setClipboard(getEditText().getText().toString());
+                Utils.setClipboard(getEditText().getText());
             }).setPositiveButton(str("revanced_settings_import"), (dialog, which) -> {
                 importSettings(builder.getContext(), getEditText().getText().toString());
             });

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

@@ -0,0 +1,113 @@
+package app.revanced.extension.shared.settings.preference;
+
+import static app.revanced.extension.shared.StringRef.str;
+
+import java.util.Deque;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.settings.BaseSettings;
+
+/**
+ * Manages a buffer for storing debug logs from {@link Logger}.
+ * Stores just under 1MB of the most recent log data.
+ *
+ * All methods are thread-safe.
+ */
+public final class LogBufferManager {
+    /** Maximum byte size of all buffer entries. Must be less than Android's 1 MB Binder transaction limit. */
+    private static final int BUFFER_MAX_BYTES = 900_000;
+    /** Limit number of log lines. */
+    private static final int BUFFER_MAX_SIZE = 10_000;
+
+    private static final Deque<String> logBuffer = new ConcurrentLinkedDeque<>();
+    private static final AtomicInteger logBufferByteSize = new AtomicInteger();
+
+    /**
+     * Appends a log message to the internal buffer if debugging is enabled.
+     * The buffer is limited to approximately {@link #BUFFER_MAX_BYTES} or {@link #BUFFER_MAX_SIZE}
+     * to prevent excessive memory usage.
+     *
+     * @param message The log message to append.
+     */
+    public static void appendToLogBuffer(String message) {
+        Objects.requireNonNull(message);
+
+        // It's very important that no Settings are used in this method,
+        // as this code is used when a context is not set and thus referencing
+        // a setting will crash the app.
+        logBuffer.addLast(message);
+        int newSize = logBufferByteSize.addAndGet(message.length());
+
+        // Remove oldest entries if over the log size limits.
+        while (newSize > BUFFER_MAX_BYTES || logBuffer.size() > BUFFER_MAX_SIZE) {
+            String removed = logBuffer.pollFirst();
+            if (removed == null) {
+                // Thread race of two different calls to this method, and the other thread won.
+                return;
+            }
+
+            newSize = logBufferByteSize.addAndGet(-removed.length());
+        }
+    }
+
+    /**
+     * Exports all logs from the internal buffer to the clipboard.
+     * Displays a toast with the result.
+     */
+    public static void exportToClipboard() {
+        try {
+            if (!BaseSettings.DEBUG.get()) {
+                Utils.showToastShort(str("revanced_debug_logs_disabled"));
+                return;
+            }
+
+            if (logBuffer.isEmpty()) {
+                Utils.showToastShort(str("revanced_debug_logs_none_found"));
+                clearLogBufferData(); // Clear toast log entry that was just created.
+                return;
+            }
+
+            // Most (but not all) Android 13+ devices always show a "copied to clipboard" toast
+            // and there is no way to programmatically detect if a toast will show or not.
+            // Show a toast even if using Android 13+, but show ReVanced toast first (before copying to clipboard).
+            Utils.showToastShort(str("revanced_debug_logs_copied_to_clipboard"));
+
+            Utils.setClipboard(String.join("\n", logBuffer));
+        } catch (Exception ex) {
+            // Handle security exception if clipboard access is denied.
+            String errorMessage = String.format(str("revanced_debug_logs_failed_to_export"), ex.getMessage());
+            Utils.showToastLong(errorMessage);
+            Logger.printDebug(() -> errorMessage, ex);
+        }
+    }
+
+    private static void clearLogBufferData() {
+        // Cannot simply clear the log buffer because there is no
+        // write lock for both the deque and the atomic int.
+        // Instead pop off log entries and decrement the size one by one.
+        while (!logBuffer.isEmpty()) {
+            String removed = logBuffer.pollFirst();
+            if (removed != null) {
+                logBufferByteSize.addAndGet(-removed.length());
+            }
+        }
+    }
+
+    /**
+     * Clears the internal log buffer and displays a toast with the result.
+     */
+    public static void clearLogBuffer() {
+        if (!BaseSettings.DEBUG.get()) {
+            Utils.showToastShort(str("revanced_debug_logs_disabled"));
+            return;
+        }
+
+        // Show toast before clearing, otherwise toast log will still remain.
+        Utils.showToastShort(str("revanced_debug_logs_clear_toast"));
+        clearLogBufferData();
+    }
+}

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

@@ -8,7 +8,6 @@ import android.app.Dialog;
 import android.app.ProgressDialog;
 import android.content.Context;
 import android.content.Intent;
-import android.content.res.Configuration;
 import android.graphics.Color;
 import android.net.Uri;
 import android.os.Bundle;
@@ -54,7 +53,7 @@ public class ReVancedAboutPreference extends Preference {
     }
 
     protected boolean isDarkModeEnabled() {
-        return Utils.isDarkModeEnabled(getContext());
+        return Utils.isDarkModeEnabled();
     }
 
     /**

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

@@ -6,9 +6,8 @@ import android.util.AttributeSet;
 import android.util.Pair;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
-import java.util.SortedMap;
-import java.util.TreeMap;
 
 import app.revanced.extension.shared.Utils;
 
@@ -46,17 +45,25 @@ public class SortedListPreference extends ListPreference {
         }
 
         List<Pair<CharSequence, CharSequence>> firstEntries = new ArrayList<>(firstEntriesToPreserve);
-        SortedMap<String, Pair<CharSequence, CharSequence>> lastEntries = new TreeMap<>();
+
+        // Android does not have a triple class like Kotlin, So instead use a nested pair.
+        // Cannot easily use a SortedMap, because if two entries incorrectly have
+        // identical names then the duplicates entries are not preserved.
+        List<Pair<String, Pair<CharSequence, CharSequence>>> lastEntries = new ArrayList<>();
 
         for (int i = 0; i < entrySize; i++) {
             Pair<CharSequence, CharSequence> pair = new Pair<>(entries[i], entryValues[i]);
             if (i < firstEntriesToPreserve) {
                 firstEntries.add(pair);
             } else {
-                lastEntries.put(Utils.removePunctuationToLowercase(pair.first), pair);
+                lastEntries.add(new Pair<>(Utils.removePunctuationToLowercase(pair.first), pair));
             }
         }
 
+        //noinspection ComparatorCombinators
+        Collections.sort(lastEntries, (pair1, pair2)
+                -> pair1.first.compareTo(pair2.first));
+
         CharSequence[] sortedEntries = new CharSequence[entrySize];
         CharSequence[] sortedEntryValues = new CharSequence[entrySize];
 
@@ -67,9 +74,10 @@ public class SortedListPreference extends ListPreference {
             i++;
         }
 
-        for (Pair<CharSequence, CharSequence> pair : lastEntries.values()) {
+        for (Pair<String, Pair<CharSequence, CharSequence>> outer : lastEntries) {
-            sortedEntries[i] = pair.first;
+            Pair<CharSequence, CharSequence> inner = outer.second;
-            sortedEntryValues[i] = pair.second;
+            sortedEntries[i] = inner.first;
+            sortedEntryValues[i] = inner.second;
             i++;
         }
 

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

@@ -71,9 +71,7 @@ final class PlayerRoutes {
         return innerTubeBody.toString();
     }
 
-    /**
+    @SuppressWarnings("SameParameterValue")
-     * @noinspection SameParameterValue
-     */
     static HttpURLConnection getPlayerResponseConnectionFromRoute(Route.CompiledRoute route, ClientType clientType) throws IOException {
         var connection = Requester.getConnectionFromCompiledRoute(YT_API_URL, route);
 

extensions/spotify/build.gradle.kts

@@ -10,7 +10,7 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_1_8
     }
 }

extensions/spotify/src/main/java/app/revanced/extension/spotify/layout/hide/createbutton/HideCreateButtonPatch.java

@@ -0,0 +1,51 @@
+package app.revanced.extension.spotify.layout.hide.createbutton;
+
+import java.util.List;
+
+import app.revanced.extension.shared.Utils;
+
+@SuppressWarnings("unused")
+public final class HideCreateButtonPatch {
+
+    /**
+     * A list of ids of resources which contain the Create button title.
+     */
+    private static final List<String> CREATE_BUTTON_TITLE_RES_ID_LIST = List.of(
+            Integer.toString(Utils.getResourceIdentifier("navigationbar_musicappitems_create_title", "string"))
+    );
+
+    /**
+     * The old id of the resource which contained the Create button title. Used in older versions of the app.
+     */
+    private static final int OLD_CREATE_BUTTON_TITLE_RES_ID =
+            Utils.getResourceIdentifier("bottom_navigation_bar_create_tab_title", "string");
+
+    /**
+     * Injection point. This method is called on every navigation bar item to check whether it is the Create button.
+     * If the navigation bar item is the Create button, it returns null to erase it.
+     * The method fingerprint used to patch ensures we can safely return null here.
+     */
+    public static Object returnNullIfIsCreateButton(Object navigationBarItem) {
+        if (navigationBarItem == null) {
+            return null;
+        }
+
+        String stringifiedNavigationBarItem = navigationBarItem.toString();
+        boolean isCreateButton = CREATE_BUTTON_TITLE_RES_ID_LIST.stream()
+                .anyMatch(stringifiedNavigationBarItem::contains);
+
+        if (isCreateButton) {
+            return null;
+        }
+
+        return navigationBarItem;
+    }
+
+    /**
+     * Injection point. Called in older versions of the app. Returns whether the old navigation bar item is the old
+     * Create button.
+     */
+    public static boolean isOldCreateButton(int oldNavigationBarItemTitleResId) {
+        return oldNavigationBarItemTitleResId == OLD_CREATE_BUTTON_TITLE_RES_ID;
+    }
+}

extensions/spotify/src/main/java/app/revanced/extension/spotify/layout/theme/CustomThemePatch.java

@@ -8,15 +8,54 @@ import app.revanced.extension.shared.Utils;
 @SuppressWarnings("unused")
 public final class CustomThemePatch {
 
+    private static final int BACKGROUND_COLOR = getColorFromString("@color/gray_7");
+    private static final int BACKGROUND_COLOR_SECONDARY = getColorFromString("@color/gray_15");
+    private static final int ACCENT_COLOR = getColorFromString("@color/spotify_green_157");
+    private static final int ACCENT_PRESSED_COLOR =
+            getColorFromString("@color/dark_brightaccent_background_press");
+
     /**
-     * Injection point.
+     * Returns an int representation of the color resource or hex code.
      */
-    public static long getThemeColor(String colorString) {
+    private static int getColorFromString(String colorString) {
         try {
             return Utils.getColorFromString(colorString);
         } catch (Exception ex) {
-            Logger.printException(() -> "Invalid custom color: " + colorString, ex);
+            Logger.printException(() -> "Invalid color string: " + colorString, ex);
             return Color.BLACK;
         }
     }
+
+    /**
+     * Injection point. Returns an int representation of the replaced color from the original color.
+     */
+    public static int replaceColor(int originalColor) {
+        switch (originalColor) {
+            // Playlist background color.
+            case 0xFF121212:
+                return BACKGROUND_COLOR;
+
+            // Share menu background color.
+            case 0xFF1F1F1F:
+            // Home category pills background color.
+            case 0xFF333333:
+            // Settings header background color.
+            case 0xFF282828:
+             // Spotify Connect device list background color.
+            case 0xFF2A2A2A:
+                return BACKGROUND_COLOR_SECONDARY;
+
+            // Some Lottie animations have a color that's slightly off due to rounding errors.
+            case 0xFF1ED760: case 0xFF1ED75F:
+            // Intermediate color used in some animations, same rounding issue.
+            case 0xFF1DB954: case 0xFF1CB854:
+                return ACCENT_COLOR;
+
+            case 0xFF1ABC54:
+                return ACCENT_PRESSED_COLOR;
+
+            default:
+                return originalColor;
+        }
+    }
 }

extensions/spotify/stub/build.gradle.kts

@@ -7,11 +7,11 @@ android {
     compileSdk = 34
 
     defaultConfig {
-        minSdk = 26
+        minSdk = 24
     }
 
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
+        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_1_8
     }
 }

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

@@ -2,7 +2,6 @@ package app.revanced.extension.tiktok;
 
 import static app.revanced.extension.shared.Utils.isDarkModeEnabled;
 
-import android.content.Context;
 import android.graphics.Color;
 import android.view.View;
 import android.widget.TextView;
@@ -43,8 +42,8 @@ public class Utils {
     private static final @ColorInt int TEXT_LIGHT_MODE_SUMMARY
             = Color.argb(255, 80, 80, 80);
 
-    public static void setTitleAndSummaryColor(Context context, View view) {
+    public static void setTitleAndSummaryColor(View view) {
-        final boolean darkModeEnabled = isDarkModeEnabled(context);
+        final boolean darkModeEnabled = isDarkModeEnabled();
 
         TextView title = view.findViewById(android.R.id.title);
         title.setTextColor(darkModeEnabled

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

@@ -101,7 +101,7 @@ public class DownloadPathPreference extends DialogPreference {
     protected void onBindView(View view) {
         super.onBindView(view);
 
-        Utils.setTitleAndSummaryColor(getContext(), view);
+        Utils.setTitleAndSummaryColor(view);
     }
 
     @Override

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

@@ -22,6 +22,6 @@ public class InputTextPreference extends EditTextPreference {
     protected void onBindView(View view) {
         super.onBindView(view);
 
-        Utils.setTitleAndSummaryColor(getContext(), view);
+        Utils.setTitleAndSummaryColor(view);
     }
 }

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

@@ -127,7 +127,7 @@ public class RangeValuePreference extends DialogPreference {
     protected void onBindView(View view) {
         super.onBindView(view);
 
-        Utils.setTitleAndSummaryColor(getContext(), view);
+        Utils.setTitleAndSummaryColor(view);
     }
 
     @Override

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

@@ -48,6 +48,6 @@ public class ReVancedTikTokAboutPreference extends ReVancedAboutPreference {
     protected void onBindView(View view) {
         super.onBindView(view);
 
-        Utils.setTitleAndSummaryColor(getContext(), view);
+        Utils.setTitleAndSummaryColor(view);
     }
 }

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

@@ -22,6 +22,6 @@ public class TogglePreference extends SwitchPreference {
     protected void onBindView(View view) {
         super.onBindView(view);
 
-        Utils.setTitleAndSummaryColor(getContext(), view);
+        Utils.setTitleAndSummaryColor(view);
     }
 }

extensions/tiktok/src/main/java/app/revanced/extension/tiktok/spoof/sim/SpoofSimPatch.java

@@ -16,9 +16,7 @@ public class SpoofSimPatch {
             return false;
         }
 
-        Logger.initializationException(SpoofSimPatch.class,
+        Logger.initializationException(() -> "Context is not yet set, cannot spoof: " + fieldSpoofed, null);
-                "Context is not yet set, cannot spoof: " + fieldSpoofed, null);
-
         return true;
     }
 

extensions/youtube/src/main/java/app/revanced/extension/youtube/ThemeHelper.java

@@ -105,6 +105,14 @@ public class ThemeHelper {
         return isDarkTheme() ? getLightThemeColor() : getDarkThemeColor();
     }
 
+    public static int getDialogBackgroundColor() {
+        final String colorName = isDarkTheme()
+                ? "yt_black1"
+                : "yt_white1";
+
+        return Utils.getColorFromString(colorName);
+    }
+
     public static int getToolbarBackgroundColor() {
         final String colorName = isDarkTheme()
                 ? "yt_black3"

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/AlternativeThumbnailsPatch.java

@@ -686,7 +686,7 @@ public final class AlternativeThumbnailsPatch {
                     ? "" : fullUrl.substring(imageExtensionEndIndex);
         }
 
-        /** @noinspection SameParameterValue */
+        @SuppressWarnings("SameParameterValue")
         String createStillsUrl(@NonNull ThumbnailQuality qualityToUse, boolean includeViewTracking) {
             // Images could be upgraded to webp if they are not already, but this fails quite often,
             // especially for new videos uploaded in the last hour.

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/DisableHapticFeedbackPatch.java

@@ -0,0 +1,35 @@
+package app.revanced.extension.youtube.patches;
+
+import app.revanced.extension.youtube.settings.Settings;
+
+@SuppressWarnings("unused")
+public class DisableHapticFeedbackPatch {
+
+    /**
+     * Injection point.
+     */
+    public static boolean disableChapterVibrate() {
+        return Settings.DISABLE_HAPTIC_FEEDBACK_CHAPTERS.get();
+    }
+
+    /**
+     * Injection point.
+     */
+    public static boolean disableSeekUndoVibrate() {
+        return Settings.DISABLE_HAPTIC_FEEDBACK_SEEK_UNDO.get();
+    }
+
+    /**
+     * Injection point.
+     */
+    public static boolean disablePreciseSeekingVibrate() {
+        return Settings.DISABLE_HAPTIC_FEEDBACK_PRECISE_SEEKING.get();
+    }
+
+    /**
+     * Injection point.
+     */
+    public static boolean disableZoomVibrate() {
+        return Settings.DISABLE_HAPTIC_FEEDBACK_ZOOM.get();
+    }
+}

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/NavigationButtonsPatch.java

@@ -95,7 +95,7 @@ public final class NavigationButtonsPatch {
             return false;
         }
 
-        return Utils.isDarkModeEnabled(Utils.getContext())
+        return Utils.isDarkModeEnabled()
                 ? !DISABLE_TRANSLUCENT_NAVIGATION_BAR_DARK
                 : !DISABLE_TRANSLUCENT_NAVIGATION_BAR_LIGHT;
     }

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/OpenShortsInRegularPlayerPatch.java

@@ -31,6 +31,8 @@ public class OpenShortsInRegularPlayerPatch {
 
     private static WeakReference<Activity> mainActivityRef = new WeakReference<>(null);
 
+    private static volatile boolean overrideBackPressToExit;
+
     /**
      * Injection point.
      */
@@ -38,6 +40,18 @@ public class OpenShortsInRegularPlayerPatch {
         mainActivityRef = new WeakReference<>(activity);
     }
 
+    /**
+     * Injection point.
+     */
+    public static boolean overrideBackPressToExit(boolean original) {
+        if (overrideBackPressToExit) {
+            Logger.printDebug(() -> "Overriding back press to exit activity");
+            return false;
+        }
+
+        return original;
+    }
+
     /**
      * Injection point.
      */
@@ -45,6 +59,7 @@ public class OpenShortsInRegularPlayerPatch {
         try {
             ShortsPlayerType type = Settings.SHORTS_PLAYER_TYPE.get();
             if (type == ShortsPlayerType.SHORTS_PLAYER) {
+                overrideBackPressToExit = false;
                 return false; // Default unpatched behavior.
             }
 
@@ -61,13 +76,17 @@ public class OpenShortsInRegularPlayerPatch {
                 // set to open in the regular player, so it's ignored as
                 // checking the map makes the patch more complicated.
                 Logger.printDebug(() -> "Ignoring Short with no videoId");
+                overrideBackPressToExit = false;
                 return false;
             }
             
             if (NavigationButton.getSelectedNavigationButton() == NavigationButton.SHORTS) {
+                overrideBackPressToExit = false;
                 return false; // Always use Shorts player for the Shorts nav button.
             }
 
+            overrideBackPressToExit = true;
+
             final boolean forceFullScreen = (type == ShortsPlayerType.REGULAR_PLAYER_FULLSCREEN);
             OpenVideosFullscreenHookPatch.setOpenNextVideoFullscreen(forceFullScreen);
 

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/OpenVideosFullscreenHookPatch.java

@@ -33,7 +33,7 @@ public class OpenVideosFullscreenHookPatch {
         }
 
         if (!isFullScreenPatchIncluded()) {
-            return false;
+            return original;
         }
 
         return Settings.OPEN_VIDEOS_FULLSCREEN_PORTRAIT.get();

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/ReturnYouTubeDislikePatch.java

@@ -152,11 +152,15 @@ public class ReturnYouTubeDislikePatch {
                 return original; // No need to check for Shorts in the context.
             }
 
-            if (conversionContextString.contains("|shorts_dislike_button.eml")) {
+            if (Utils.containsAny(conversionContextString,
+                    "|shorts_dislike_button.eml", "|reel_dislike_button.eml"
+            )) {
                 return getShortsSpan(original, true);
             }
 
-            if (conversionContextString.contains("|shorts_like_button.eml")) {
+            if (Utils.containsAny(conversionContextString,
+                    "|shorts_like_button.eml", "|reel_like_button.eml"
+            )) {
                 if (!Utils.containsNumber(original)) {
                     Logger.printDebug(() -> "Replacing hidden likes count");
                     return getShortsSpan(original, false);
@@ -361,6 +365,11 @@ public class ReturnYouTubeDislikePatch {
             if (videoId.equals(lastPrefetchedVideoId)) {
                 return;
             }
+            if (!Utils.isNetworkConnected()) {
+                Logger.printDebug(() -> "Cannot pre-fetch RYD, network is not connected");
+                lastPrefetchedVideoId = null;
+                return;
+            }
 
             final boolean videoIdIsShort = VideoInformation.lastPlayerResponseIsShort();
             // Shorts shelf in home and subscription feed causes player response hook to be called,
@@ -415,6 +424,12 @@ public class ReturnYouTubeDislikePatch {
             }
             Logger.printDebug(() -> "New video id: " + videoId + " playerType: " + currentPlayerType);
 
+            if (!Utils.isNetworkConnected()) {
+                Logger.printDebug(() -> "Cannot fetch RYD, network is not connected");
+                currentVideoData = null;
+                return;
+            }
+
             ReturnYouTubeDislike data = ReturnYouTubeDislike.getFetchForVideoId(videoId);
             // Pre-emptively set the data to short status.
             // Required to prevent Shorts data from being used on a minimized video in incognito mode.

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/VideoInformation.java

@@ -354,4 +354,23 @@ public final class VideoInformation {
         return videoTime >= videoLength && videoLength > 0;
     }
 
+    /**
+     * Overrides the current playback speed.
+     * Rest of the implementation added by patch.
+     */
+    public static void overridePlaybackSpeed(float speedOverride) {
+        Logger.printDebug(() -> "Overriding playback speed to: " + speedOverride);
+    }
+
+    /**
+     * Injection point.
+     *
+     * @param newlyLoadedPlaybackSpeed The current playback speed.
+     */
+    public static void setPlaybackSpeed(float newlyLoadedPlaybackSpeed) {
+        if (playbackSpeed != newlyLoadedPlaybackSpeed) {
+            Logger.printDebug(() -> "Video speed changed: " + newlyLoadedPlaybackSpeed);
+            playbackSpeed = newlyLoadedPlaybackSpeed;
+        }
+    }
 }

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/WideSearchbarPatch.java

@@ -1,7 +1,5 @@
 package app.revanced.extension.youtube.patches;
 
-import android.content.res.Resources;
-import android.util.TypedValue;
 import android.view.View;
 
 import app.revanced.extension.shared.Logger;
@@ -33,8 +31,7 @@ public final class WideSearchbarPatch {
             final int paddingRight = searchBarView.getPaddingRight();
             final int paddingTop = searchBarView.getPaddingTop();
             final int paddingBottom = searchBarView.getPaddingBottom();
-            final int paddingStart = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
+            final int paddingStart = Utils.dipToPixels(8);
-                    8, Resources.getSystem().getDisplayMetrics());
 
             if (Utils.isRightToLeftLocale()) {
                 searchBarView.setPadding(paddingLeft, paddingTop, paddingStart, paddingBottom);

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/ZoomHapticsPatch.java

@@ -1,10 +0,0 @@
-package app.revanced.extension.youtube.patches;
-
-import app.revanced.extension.youtube.settings.Settings;
-
-@SuppressWarnings("unused")
-public class ZoomHapticsPatch {
-    public static boolean shouldVibrate() {
-        return !Settings.DISABLE_ZOOM_HAPTICS.get();
-    }
-}

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/components/PlaybackSpeedMenuFilterPatch.java

@@ -10,18 +10,11 @@ import app.revanced.extension.youtube.settings.Settings;
  */
 public final class PlaybackSpeedMenuFilterPatch extends Filter {
 
-    /**
-     * Old litho based speed selection menu.
-     */
-    public static volatile boolean isOldPlaybackSpeedMenuVisible;
-
     /**
      * 0.05x speed selection menu.
      */
     public static volatile boolean isPlaybackRateSelectorMenuVisible;
 
-    private final StringFilterGroup oldPlaybackMenuGroup;
-
     public PlaybackSpeedMenuFilterPatch() {
         // 0.05x litho speed menu.
         var playbackRateSelectorGroup = new StringFilterGroup(
@@ -29,22 +22,13 @@ public final class PlaybackSpeedMenuFilterPatch extends Filter {
                 "playback_rate_selector_menu_sheet.eml-js"
         );
 
-        // Old litho based speed menu.
+        addPathCallbacks(playbackRateSelectorGroup);
-        oldPlaybackMenuGroup = new StringFilterGroup(
-                Settings.CUSTOM_SPEED_MENU,
-                "playback_speed_sheet_content.eml-js");
-
-        addPathCallbacks(playbackRateSelectorGroup, oldPlaybackMenuGroup);
     }
 
     @Override
     boolean isFiltered(@Nullable String identifier, String path, byte[] protobufBufferArray,
                        StringFilterGroup matchedGroup, FilterContentType contentType, int contentIndex) {
-        if (matchedGroup == oldPlaybackMenuGroup) {
+        isPlaybackRateSelectorMenuVisible = true;
-            isOldPlaybackSpeedMenuVisible = true;
-        } else {
-            isPlaybackRateSelectorMenuVisible = true;
-        }
 
         return false;
     }

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/components/ShortsFilter.java

@@ -143,12 +143,14 @@ public final class ShortsFilter extends Filter {
 
         StringFilterGroup likeButton = new StringFilterGroup(
                 Settings.HIDE_SHORTS_LIKE_BUTTON,
-                "shorts_like_button.eml"
+                "shorts_like_button.eml",
+                "reel_like_button.eml"
         );
 
         StringFilterGroup dislikeButton = new StringFilterGroup(
                 Settings.HIDE_SHORTS_DISLIKE_BUTTON,
-                "shorts_dislike_button.eml"
+                "shorts_dislike_button.eml",
+                "reel_dislike_button.eml"
         );
 
         joinButton = new StringFilterGroup(
@@ -168,12 +170,13 @@ public final class ShortsFilter extends Filter {
 
         shortsActionBar = new StringFilterGroup(
                 null,
-                "shorts_action_bar.eml"
+                "shorts_action_bar.eml",
+                "reel_action_bar.eml"
         );
 
         actionButton = new StringFilterGroup(
                 null,
-                // Can be simply 'button.eml' or 'shorts_video_action_button.eml'
+                // Can be simply 'button.eml', 'shorts_video_action_button.eml' or 'reel_action_button.eml'
                 "button.eml"
         );
 
@@ -195,15 +198,18 @@ public final class ShortsFilter extends Filter {
         videoActionButtonGroupList.addAll(
                 new ByteArrayFilterGroup(
                         Settings.HIDE_SHORTS_COMMENTS_BUTTON,
-                        "reel_comment_button"
+                        "reel_comment_button",
+                        "youtube_shorts_comment_outline"
                 ),
                 new ByteArrayFilterGroup(
                         Settings.HIDE_SHORTS_SHARE_BUTTON,
-                        "reel_share_button"
+                        "reel_share_button",
+                        "youtube_shorts_share_outline"
                 ),
                 new ByteArrayFilterGroup(
                         Settings.HIDE_SHORTS_REMIX_BUTTON,
-                        "reel_remix_button"
+                        "reel_remix_button",
+                        "youtube_shorts_remix_outline"
                 )
         );
 

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/playback/speed/CustomPlaybackSpeedPatch.java

@@ -1,24 +1,57 @@
 package app.revanced.extension.youtube.patches.playback.speed;
 
 import static app.revanced.extension.shared.StringRef.str;
+import static app.revanced.extension.shared.Utils.dipToPixels;
 
+import android.annotation.SuppressLint;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.PorterDuff;
+import android.graphics.Rect;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.RoundRectShape;
+import android.icu.text.NumberFormat;
 import android.support.v7.widget.RecyclerView;
+import android.view.animation.Animation;
+import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewParent;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.Button;
+import android.widget.FrameLayout;
+import android.widget.GridLayout;
+import android.widget.LinearLayout;
+import android.widget.SeekBar;
+import android.widget.TextView;
 
+import java.lang.ref.WeakReference;
 import java.util.Arrays;
+import java.util.function.Function;
 
 import app.revanced.extension.shared.Logger;
 import app.revanced.extension.shared.Utils;
+import app.revanced.extension.youtube.ThemeHelper;
+import app.revanced.extension.youtube.patches.VideoInformation;
 import app.revanced.extension.youtube.patches.components.PlaybackSpeedMenuFilterPatch;
 import app.revanced.extension.youtube.settings.Settings;
+import app.revanced.extension.youtube.shared.PlayerType;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
 
 @SuppressWarnings("unused")
 public class CustomPlaybackSpeedPatch {
 
     /**
-     * Maximum playback speed, exclusive value.  Custom speeds must be less than this value.
+     * Maximum playback speed, inclusive.  Custom speeds must be this or less.
      * <p>
      * Going over 8x does not increase the actual playback speed any higher,
      * and the UI selector starts flickering and acting weird.
@@ -26,6 +59,11 @@ public class CustomPlaybackSpeedPatch {
      */
     public static final float PLAYBACK_SPEED_MAXIMUM = 8;
 
+    /**
+     * Scale used to convert user speed to {@link android.widget.ProgressBar#setProgress(int)}.
+     */
+    private static final float PROGRESS_BAR_VALUE_SCALE = 100;
+
     /**
      * Tap and hold speed.
      */
@@ -34,16 +72,28 @@ public class CustomPlaybackSpeedPatch {
     /**
      * Custom playback speeds.
      */
-    public static float[] customPlaybackSpeeds;
+    public static final float[] customPlaybackSpeeds;
 
     /**
-     * The last time the old playback menu was forcefully called.
+     * Formats speeds to UI strings.
      */
-    private static long lastTimeOldPlaybackMenuInvoked;
+    private static final NumberFormat speedFormatter = NumberFormat.getNumberInstance();
+
+    /**
+     * Weak reference to the currently open dialog.
+     */
+    private static WeakReference<Dialog> currentDialog = new WeakReference<>(null);
+
+    /**
+     * Minimum and maximum custom playback speeds of {@link #customPlaybackSpeeds}.
+     */
+    private static final float customPlaybackSpeedsMin, customPlaybackSpeedsMax;
 
     static {
-        final float holdSpeed = Settings.SPEED_TAP_AND_HOLD.get();
+        // Cap at 2 decimals (rounds automatically).
+        speedFormatter.setMaximumFractionDigits(2);
 
+        final float holdSpeed = Settings.SPEED_TAP_AND_HOLD.get();
         if (holdSpeed > 0 && holdSpeed <= PLAYBACK_SPEED_MAXIMUM) {
             TAP_AND_HOLD_SPEED = holdSpeed;
         } else {
@@ -51,7 +101,9 @@ public class CustomPlaybackSpeedPatch {
             TAP_AND_HOLD_SPEED = Settings.SPEED_TAP_AND_HOLD.resetToDefault();
         }
 
-        loadCustomSpeeds();
+        customPlaybackSpeeds = loadCustomSpeeds();
+        customPlaybackSpeedsMin = customPlaybackSpeeds[0];
+        customPlaybackSpeedsMax = customPlaybackSpeeds[customPlaybackSpeeds.length - 1];
     }
 
     /**
@@ -65,37 +117,41 @@ public class CustomPlaybackSpeedPatch {
         Utils.showToastLong(str("revanced_custom_playback_speeds_invalid", PLAYBACK_SPEED_MAXIMUM));
     }
 
-    private static void loadCustomSpeeds() {
+    private static float[] loadCustomSpeeds() {
         try {
-            String[] speedStrings = Settings.CUSTOM_PLAYBACK_SPEEDS.get().split("\\s+");
+            // Automatically replace commas with periods,
+            // if the user added speeds in a localized format.
+            String[] speedStrings = Settings.CUSTOM_PLAYBACK_SPEEDS.get()
+                    .replace(',', '.').split("\\s+");
             Arrays.sort(speedStrings);
             if (speedStrings.length == 0) {
                 throw new IllegalArgumentException();
             }
 
-            customPlaybackSpeeds = new float[speedStrings.length];
+            float[] speeds = new float[speedStrings.length];
 
             int i = 0;
             for (String speedString : speedStrings) {
                 final float speedFloat = Float.parseFloat(speedString);
-                if (speedFloat <= 0 || arrayContains(customPlaybackSpeeds, speedFloat)) {
+                if (speedFloat <= 0 || arrayContains(speeds, speedFloat)) {
                     throw new IllegalArgumentException();
                 }
 
-                if (speedFloat >= PLAYBACK_SPEED_MAXIMUM) {
+                if (speedFloat > PLAYBACK_SPEED_MAXIMUM) {
                     showInvalidCustomSpeedToast();
                     Settings.CUSTOM_PLAYBACK_SPEEDS.resetToDefault();
-                    loadCustomSpeeds();
+                    return loadCustomSpeeds();
-                    return;
                 }
 
-                customPlaybackSpeeds[i++] = speedFloat;
+                speeds[i++] = speedFloat;
             }
+
+            return speeds;
         } catch (Exception ex) {
-            Logger.printInfo(() -> "parse error", ex);
+            Logger.printInfo(() -> "Parse error", ex);
-            Utils.showToastLong(str("revanced_custom_playback_speeds_parse_exception"));
+            Utils.showToastShort(str("revanced_custom_playback_speeds_parse_exception"));
             Settings.CUSTOM_PLAYBACK_SPEEDS.resetToDefault();
-            loadCustomSpeeds();
+            return loadCustomSpeeds();
         }
     }
 
@@ -113,38 +169,28 @@ public class CustomPlaybackSpeedPatch {
         recyclerView.getViewTreeObserver().addOnDrawListener(() -> {
             try {
                 if (PlaybackSpeedMenuFilterPatch.isPlaybackRateSelectorMenuVisible) {
-                    if (hideLithoMenuAndShowOldSpeedMenu(recyclerView, 5)) {
+                    if (hideLithoMenuAndShowCustomSpeedMenu(recyclerView, 5)) {
                         PlaybackSpeedMenuFilterPatch.isPlaybackRateSelectorMenuVisible = false;
                     }
-                    return;
                 }
             } catch (Exception ex) {
-                Logger.printException(() -> "isPlaybackRateSelectorMenuVisible failure", ex);
+                Logger.printException(() -> "onFlyoutMenuCreate failure", ex);
-            }
-
-            try {
-                if (PlaybackSpeedMenuFilterPatch.isOldPlaybackSpeedMenuVisible) {
-                    if (hideLithoMenuAndShowOldSpeedMenu(recyclerView, 8)) {
-                        PlaybackSpeedMenuFilterPatch.isOldPlaybackSpeedMenuVisible = false;
-                    }
-                }
-            } catch (Exception ex) {
-                Logger.printException(() -> "isOldPlaybackSpeedMenuVisible failure", ex);
             }
         });
     }
 
-    private static boolean hideLithoMenuAndShowOldSpeedMenu(RecyclerView recyclerView, int expectedChildCount) {
+    @SuppressWarnings("SameParameterValue")
+    private static boolean hideLithoMenuAndShowCustomSpeedMenu(RecyclerView recyclerView, int expectedChildCount) {
         if (recyclerView.getChildCount() == 0) {
             return false;
         }
 
         View firstChild = recyclerView.getChildAt(0);
-        if (!(firstChild instanceof ViewGroup PlaybackSpeedParentView)) {
+        if (!(firstChild instanceof ViewGroup playbackSpeedParentView)) {
             return false;
         }
 
-        if (PlaybackSpeedParentView.getChildCount() != expectedChildCount) {
+        if (playbackSpeedParentView.getChildCount() != expectedChildCount) {
             return false;
         }
 
@@ -168,23 +214,418 @@ public class CustomPlaybackSpeedPatch {
         ((ViewGroup) parentView3rd).setVisibility(View.GONE);
         ((ViewGroup) parentView4th).setVisibility(View.GONE);
 
-        // Close the litho speed menu and show the old one.
+        // Close the litho speed menu and show the modern custom speed dialog.
-        showOldPlaybackSpeedMenu();
+        showModernCustomPlaybackSpeedDialog(recyclerView.getContext());
+        Logger.printDebug(() -> "Modern playback speed dialog shown");
 
         return true;
     }
 
-    public static void showOldPlaybackSpeedMenu() {
+    /**
-        // This method is sometimes used multiple times.
+     * Displays a modern custom dialog for adjusting video playback speed.
-        // To prevent this, ignore method reuse within 1 second.
+     * <p>
-        final long now = System.currentTimeMillis();
+     * This method creates a dialog with a slider, plus/minus buttons, and preset speed buttons
-        if (now - lastTimeOldPlaybackMenuInvoked < 1000) {
+     * to allow the user to modify the video playback speed. The dialog is styled with rounded
-            Logger.printDebug(() -> "Ignoring call to showOldPlaybackSpeedMenu");
+     * corners and themed colors, positioned at the bottom of the screen. The playback speed
-            return;
+     * can be adjusted in 0.05 increments using the slider or buttons, or set directly to preset
-        }
+     * values. The dialog updates the displayed speed in real-time and applies changes to the
-        lastTimeOldPlaybackMenuInvoked = now;
+     * video playback. The dialog is dismissed if the player enters Picture-in-Picture (PiP) mode.
-        Logger.printDebug(() -> "Old video quality menu shown");
+     */
+    @SuppressLint("SetTextI18n")
+    public static void showModernCustomPlaybackSpeedDialog(Context context) {
+        // Create a dialog without a theme for custom appearance.
+        Dialog dialog = new Dialog(context);
+        dialog.requestWindowFeature(Window.FEATURE_NO_TITLE); // Remove default title bar.
 
-        // Rest of the implementation added by patch.
+        // Store the dialog reference.
+        currentDialog = new WeakReference<>(dialog);
+
+        // Create main vertical LinearLayout for dialog content.
+        LinearLayout mainLayout = new LinearLayout(context);
+        mainLayout.setOrientation(LinearLayout.VERTICAL);
+
+        // Preset size constants.
+        final int dip4 = dipToPixels(4);   // Height for handle bar.
+        final int dip5 = dipToPixels(5);
+        final int dip6 = dipToPixels(6);   // Padding for mainLayout from bottom.
+        final int dip8 = dipToPixels(8);   // Padding for mainLayout from left and right.
+        final int dip20 = dipToPixels(20);
+        final int dip32 = dipToPixels(32); // Height for in-rows speed buttons.
+        final int dip36 = dipToPixels(36); // Height for minus and plus buttons.
+        final int dip40 = dipToPixels(40); // Width for handle bar.
+        final int dip60 = dipToPixels(60); // Height for speed button container.
+
+        mainLayout.setPadding(dip5, dip8, dip5, dip8);
+
+        // Set rounded rectangle background for the main layout.
+        RoundRectShape roundRectShape = new RoundRectShape(
+                createCornerRadii(12), null, null);
+        ShapeDrawable background = new ShapeDrawable(roundRectShape);
+        background.getPaint().setColor(ThemeHelper.getDialogBackgroundColor());
+        mainLayout.setBackground(background);
+
+        // Add handle bar at the top.
+        View handleBar = new View(context);
+        ShapeDrawable handleBackground = new ShapeDrawable(new RoundRectShape(
+                createCornerRadii(4), null, null));
+        handleBackground.getPaint().setColor(getAdjustedBackgroundColor(true));
+        handleBar.setBackground(handleBackground);
+        LinearLayout.LayoutParams handleParams = new LinearLayout.LayoutParams(
+                dip40, // handle bar width.
+                dip4   // handle bar height.
+        );
+        handleParams.gravity = Gravity.CENTER_HORIZONTAL; // Center horizontally.
+        handleParams.setMargins(0, 0, 0, dip20); // 20dp bottom margins.
+        handleBar.setLayoutParams(handleParams);
+        // Add handle bar view to main layout.
+        mainLayout.addView(handleBar);
+
+        // Display current playback speed.
+        TextView currentSpeedText = new TextView(context);
+        float currentSpeed = VideoInformation.getPlaybackSpeed();
+        // Initially show with only 0 minimum digits, so 1.0 shows as 1x
+        currentSpeedText.setText(formatSpeedStringX(currentSpeed, 0));
+        currentSpeedText.setTextColor(ThemeHelper.getForegroundColor());
+        currentSpeedText.setTextSize(16);
+        currentSpeedText.setTypeface(Typeface.DEFAULT_BOLD);
+        currentSpeedText.setGravity(Gravity.CENTER);
+        LinearLayout.LayoutParams textParams = new LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+        textParams.setMargins(0, 0, 0, 0);
+        currentSpeedText.setLayoutParams(textParams);
+        // Add current speed text view to main layout.
+        mainLayout.addView(currentSpeedText);
+
+        // Create horizontal layout for slider and +/- buttons.
+        LinearLayout sliderLayout = new LinearLayout(context);
+        sliderLayout.setOrientation(LinearLayout.HORIZONTAL);
+        sliderLayout.setGravity(Gravity.CENTER_VERTICAL);
+        sliderLayout.setPadding(dip5, dip5, dip5, dip5); // 5dp padding.
+
+        // Create minus button.
+        Button minusButton = new Button(context, null, 0); // Disable default theme style.
+        minusButton.setText(""); // No text on button.
+        ShapeDrawable minusBackground = new ShapeDrawable(new RoundRectShape(createCornerRadii(20), null, null));
+        minusBackground.getPaint().setColor(getAdjustedBackgroundColor(false));
+        minusButton.setBackground(minusBackground);
+        OutlineSymbolDrawable minusDrawable = new OutlineSymbolDrawable(false); // Minus symbol.
+        minusButton.setForeground(minusDrawable);
+        LinearLayout.LayoutParams minusParams = new LinearLayout.LayoutParams(dip36, dip36);
+        minusParams.setMargins(0, 0, dip5, 0); // 5dp to slider.
+        minusButton.setLayoutParams(minusParams);
+
+        // Create slider for speed adjustment.
+        SeekBar speedSlider = new SeekBar(context);
+        speedSlider.setMax(speedToProgressValue(customPlaybackSpeedsMax));
+        speedSlider.setProgress(speedToProgressValue(currentSpeed));
+        speedSlider.getProgressDrawable().setColorFilter(
+                ThemeHelper.getForegroundColor(), PorterDuff.Mode.SRC_IN); // Theme progress bar.
+        speedSlider.getThumb().setColorFilter(
+                ThemeHelper.getForegroundColor(), PorterDuff.Mode.SRC_IN); // Theme slider thumb.
+        LinearLayout.LayoutParams sliderParams = new LinearLayout.LayoutParams(
+                0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f);
+        sliderParams.setMargins(dip5, 0, dip5, 0); // 5dp to -/+ buttons.
+        speedSlider.setLayoutParams(sliderParams);
+
+        // Create plus button.
+        Button plusButton = new Button(context, null, 0); // Disable default theme style.
+        plusButton.setText(""); // No text on button.
+        ShapeDrawable plusBackground = new ShapeDrawable(new RoundRectShape(
+                createCornerRadii(20), null, null));
+        plusBackground.getPaint().setColor(getAdjustedBackgroundColor(false));
+        plusButton.setBackground(plusBackground);
+        OutlineSymbolDrawable plusDrawable = new OutlineSymbolDrawable(true); // Plus symbol.
+        plusButton.setForeground(plusDrawable);
+        LinearLayout.LayoutParams plusParams = new LinearLayout.LayoutParams(dip36, dip36);
+        plusParams.setMargins(dip5, 0, 0, 0); // 5dp to slider.
+        plusButton.setLayoutParams(plusParams);
+
+        // Add -/+ and slider views to slider layout.
+        sliderLayout.addView(minusButton);
+        sliderLayout.addView(speedSlider);
+        sliderLayout.addView(plusButton);
+
+        LinearLayout.LayoutParams sliderLayoutParams = new LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+        sliderLayoutParams.setMargins(0, 0, 0, dip5); // 5dp bottom margin.
+        sliderLayout.setLayoutParams(sliderLayoutParams);
+
+        // Add slider layout to main layout.
+        mainLayout.addView(sliderLayout);
+
+        Function<Float, Void> userSelectedSpeed = newSpeed -> {
+            final float roundedSpeed = roundSpeedToNearestIncrement(newSpeed);
+            if (VideoInformation.getPlaybackSpeed() == roundedSpeed) {
+                // Nothing has changed. New speed rounds to the current speed.
+                return null;
+            }
+
+            VideoInformation.overridePlaybackSpeed(roundedSpeed);
+            RememberPlaybackSpeedPatch.userSelectedPlaybackSpeed(roundedSpeed);
+            currentSpeedText.setText(formatSpeedStringX(roundedSpeed, 2)); // Update display.
+            speedSlider.setProgress(speedToProgressValue(roundedSpeed)); // Update slider.
+            return null;
+        };
+
+        // Set listener for slider to update playback speed.
+        speedSlider.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
+            @Override
+            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+                if (fromUser) {
+                    // Convert from progress value to video playback speed.
+                    userSelectedSpeed.apply(customPlaybackSpeedsMin + (progress / PROGRESS_BAR_VALUE_SCALE));
+                }
+            }
+
+            @Override
+            public void onStartTrackingTouch(SeekBar seekBar) {}
+
+            @Override
+            public void onStopTrackingTouch(SeekBar seekBar) {}
+        });
+
+        minusButton.setOnClickListener(v -> userSelectedSpeed.apply(
+                VideoInformation.getPlaybackSpeed() - 0.05f));
+        plusButton.setOnClickListener(v -> userSelectedSpeed.apply(
+                VideoInformation.getPlaybackSpeed() + 0.05f));
+
+        // Create GridLayout for preset speed buttons.
+        GridLayout gridLayout = new GridLayout(context);
+        gridLayout.setColumnCount(5); // 5 columns for speed buttons.
+        gridLayout.setAlignmentMode(GridLayout.ALIGN_BOUNDS);
+        gridLayout.setRowCount((int) Math.ceil(customPlaybackSpeeds.length / 5.0));
+        LinearLayout.LayoutParams gridParams = new LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+        gridParams.setMargins(0, 0, 0, 0); // No margins around GridLayout.
+        gridLayout.setLayoutParams(gridParams);
+
+        // For all buttons show at least 1 zero in decimal (2 -> "2.0").
+        speedFormatter.setMinimumFractionDigits(1);
+
+        // Add buttons for each preset playback speed.
+        for (float speed : customPlaybackSpeeds) {
+            // Container for button and optional label.
+            FrameLayout buttonContainer = new FrameLayout(context);
+
+            // Set layout parameters for each grid cell.
+            GridLayout.LayoutParams containerParams = new GridLayout.LayoutParams();
+            containerParams.width = 0; // Equal width for columns.
+            containerParams.columnSpec = GridLayout.spec(GridLayout.UNDEFINED, 1, 1f);
+            containerParams.setMargins(dip5, 0, dip5, 0); // Button margins.
+            containerParams.height = dip60; // Fixed height for button and label.
+            buttonContainer.setLayoutParams(containerParams);
+
+            // Create speed button.
+            Button speedButton = new Button(context, null, 0);
+            speedButton.setText(speedFormatter.format(speed)); // Do not use 'x' speed format.
+            speedButton.setTextColor(ThemeHelper.getForegroundColor());
+            speedButton.setTextSize(12);
+            speedButton.setAllCaps(false);
+            speedButton.setGravity(Gravity.CENTER);
+
+            ShapeDrawable buttonBackground = new ShapeDrawable(new RoundRectShape(
+                    createCornerRadii(20), null, null));
+            buttonBackground.getPaint().setColor(getAdjustedBackgroundColor(false));
+            speedButton.setBackground(buttonBackground);
+            speedButton.setPadding(dip5, dip5, dip5, dip5);
+
+            // Center button vertically and stretch horizontally in container.
+            FrameLayout.LayoutParams buttonParams = new FrameLayout.LayoutParams(
+                    FrameLayout.LayoutParams.MATCH_PARENT, dip32, Gravity.CENTER);
+            speedButton.setLayoutParams(buttonParams);
+
+            // Add speed buttons view to buttons container layout.
+            buttonContainer.addView(speedButton);
+
+            // Add "Normal" label for 1.0x speed.
+            if (speed == 1.0f) {
+                TextView normalLabel = new TextView(context);
+                // Use same 'Normal' string as stock YouTube.
+                normalLabel.setText(str("normal_playback_rate_label"));
+                normalLabel.setTextColor(ThemeHelper.getForegroundColor());
+                normalLabel.setTextSize(10);
+                normalLabel.setGravity(Gravity.CENTER);
+
+                FrameLayout.LayoutParams labelParams = new FrameLayout.LayoutParams(
+                        FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT,
+                        Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL);
+                labelParams.bottomMargin = 0; // Position label below button.
+                normalLabel.setLayoutParams(labelParams);
+
+                buttonContainer.addView(normalLabel);
+            }
+
+            speedButton.setOnClickListener(v -> userSelectedSpeed.apply(speed));
+
+            gridLayout.addView(buttonContainer);
+        }
+
+        // Add in-rows speed buttons layout to main layout.
+        mainLayout.addView(gridLayout);
+
+        // Wrap mainLayout in another LinearLayout for side margins.
+        LinearLayout wrapperLayout = new LinearLayout(context);
+        wrapperLayout.setOrientation(LinearLayout.VERTICAL);
+        wrapperLayout.setPadding(dip8, 0, dip8, 0); // 8dp side margins.
+        wrapperLayout.addView(mainLayout);
+        dialog.setContentView(wrapperLayout);
+
+        // Configure dialog window to appear at the bottom.
+        Window window = dialog.getWindow();
+        if (window != null) {
+            WindowManager.LayoutParams params = window.getAttributes();
+            params.gravity = Gravity.BOTTOM; // Position at bottom of screen.
+            params.y = dip6; // 6dp margin from bottom.
+            // In landscape, use the smaller dimension (height) as portrait width.
+            int portraitWidth = context.getResources().getDisplayMetrics().widthPixels;
+            if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
+                portraitWidth = Math.min(
+                        portraitWidth,
+                        context.getResources().getDisplayMetrics().heightPixels);
+            }
+            params.width = portraitWidth; // Use portrait width.
+            params.height = WindowManager.LayoutParams.WRAP_CONTENT;
+            window.setAttributes(params);
+            window.setBackgroundDrawable(null); // Remove default dialog background.
+        }
+
+        // Create observer for PlayerType changes.
+        Function1<PlayerType, Unit> playerTypeObserver = new Function1<>() {
+            @Override
+            public Unit invoke(PlayerType type) {
+                Dialog current = currentDialog.get();
+                if (current == null || !current.isShowing()) {
+                    // Should never happen.
+                    PlayerType.getOnChange().removeObserver(this);
+                    Logger.printException(() -> "Removing player type listener as dialog is null or closed");
+                } else if (type == PlayerType.WATCH_WHILE_PICTURE_IN_PICTURE) {
+                    current.dismiss();
+                    Logger.printDebug(() -> "Playback speed dialog dismissed due to PiP mode");
+                }
+                return Unit.INSTANCE;
+            }
+        };
+
+        // Add observer to dismiss dialog when entering PiP mode.
+        PlayerType.getOnChange().addObserver(playerTypeObserver);
+
+        // Remove observer when dialog is dismissed.
+        dialog.setOnDismissListener(d -> {
+            PlayerType.getOnChange().removeObserver(playerTypeObserver);
+            Logger.printDebug(() -> "PlayerType observer removed on dialog dismiss");
+        });
+
+        // Apply slide-in animation when showing the dialog.
+        final int fadeDurationFast = Utils.getResourceInteger("fade_duration_fast");
+        Animation slideInABottomAnimation = Utils.getResourceAnimation("slide_in_bottom");
+        slideInABottomAnimation.setDuration(fadeDurationFast);
+        mainLayout.startAnimation(slideInABottomAnimation);
+
+        dialog.show(); // Display the dialog.
+    }
+
+    /**
+     * Creates an array of corner radii for a rounded rectangle shape.
+     *
+     * @param dp The radius in density-independent pixels (dp) to apply to all corners.
+     * @return An array of eight float values representing the corner radii
+     * (top-left, top-right, bottom-right, bottom-left).
+     */
+    private static float[] createCornerRadii(float dp) {
+        final float radius = dipToPixels(dp);
+        return new float[]{radius, radius, radius, radius, radius, radius, radius, radius};
+    }
+
+    /**
+     * @param speed The playback speed value to format.
+     * @return A string representation of the speed with 'x' (e.g. "1.25x" or "1.00x").
+     */
+    private static String formatSpeedStringX(float speed, int minimumFractionDigits) {
+        speedFormatter.setMinimumFractionDigits(minimumFractionDigits);
+        return speedFormatter.format(speed) + 'x';
+    }
+
+    /**
+     * @return user speed converted to a value for {@link SeekBar#setProgress(int)}.
+     */
+    private static int speedToProgressValue(float speed) {
+        return (int) ((speed - customPlaybackSpeedsMin) * PROGRESS_BAR_VALUE_SCALE);
+    }
+
+    /**
+     * Rounds the given playback speed to the nearest 0.05 increment and ensures it is within valid bounds.
+     *
+     * @param speed The playback speed to round.
+     * @return The rounded speed, constrained to the specified bounds.
+     */
+    private static float roundSpeedToNearestIncrement(float speed) {
+        // Round to nearest 0.05 speed.
+        final float roundedSpeed = Math.round(speed / 0.05f) * 0.05f;
+        return Utils.clamp(roundedSpeed, 0.05f, PLAYBACK_SPEED_MAXIMUM);
+    }
+
+    /**
+     * Adjusts the background color based on the current theme.
+     *
+     * @param isHandleBar If true, applies a stronger darkening factor (0.9) for the handle bar in light theme;
+     *                    if false, applies a standard darkening factor (0.95) for other elements in light theme.
+     * @return A modified background color, lightened by 20% for dark themes or darkened by 5% (or 10% for handle bar)
+     *         for light themes to ensure visual contrast.
+     */
+    public static int getAdjustedBackgroundColor(boolean isHandleBar) {
+        final int baseColor = ThemeHelper.getDialogBackgroundColor();
+        float darkThemeFactor = isHandleBar ? 1.25f : 1.115f; // 1.25f for handleBar, 1.115f for others in dark theme.
+        float lightThemeFactor = isHandleBar ? 0.9f : 0.95f; // 0.9f for handleBar, 0.95f for others in light theme.
+        return ThemeHelper.isDarkTheme()
+                ? ThemeHelper.adjustColorBrightness(baseColor, darkThemeFactor)  // Lighten for dark theme.
+                : ThemeHelper.adjustColorBrightness(baseColor, lightThemeFactor); // Darken for light theme.
+    }
+}
+
+/**
+ * Custom Drawable for rendering outlined plus and minus symbols on buttons.
+ */
+class OutlineSymbolDrawable extends Drawable {
+    private final boolean isPlus; // Determines if the symbol is a plus or minus.
+    private final Paint paint;
+
+    OutlineSymbolDrawable(boolean isPlus) {
+        this.isPlus = isPlus;
+        paint = new Paint(Paint.ANTI_ALIAS_FLAG); // Enable anti-aliasing for smooth rendering.
+        paint.setColor(ThemeHelper.getForegroundColor());
+        paint.setStyle(Paint.Style.STROKE); // Use stroke style for outline.
+        paint.setStrokeWidth(dipToPixels(1)); // 1dp stroke width.
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        Rect bounds = getBounds();
+        final int width = bounds.width();
+        final int height = bounds.height();
+        final float centerX = width / 2f; // Center X coordinate.
+        final float centerY = height / 2f; // Center Y coordinate.
+        final float size = Math.min(width, height) * 0.25f; // Symbol size is 25% of button dimensions.
+
+        // Draw horizontal line for both plus and minus symbols.
+        canvas.drawLine(centerX - size, centerY, centerX + size, centerY, paint);
+        if (isPlus) {
+            // Draw vertical line for plus symbol.
+            canvas.drawLine(centerX, centerY - size, centerX, centerY + size, paint);
+        }
+    }
+
+    @Override
+    public void setAlpha(int alpha) {
+        paint.setAlpha(alpha);
+    }
+
+    @Override
+    public void setColorFilter(ColorFilter colorFilter) {
+        paint.setColorFilter(colorFilter);
+    }
+
+    @Override
+    public int getOpacity() {
+        return PixelFormat.TRANSLUCENT;
     }
 }

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/playback/speed/RememberPlaybackSpeedPatch.java

@@ -33,10 +33,10 @@ public final class RememberPlaybackSpeedPatch {
     public static void userSelectedPlaybackSpeed(float playbackSpeed) {
         try {
             if (Settings.REMEMBER_PLAYBACK_SPEED_LAST_SELECTED.get()) {
-                // With the 0.05x menu, if the speed is set by integrations to higher than 2.0x
+                // With the 0.05x menu, if the speed is set by a patch to higher than 2.0x
                 // then the menu will allow increasing without bounds but the max speed is
-                // still capped to under 8.0x.
+                // still capped to 8.0x.
-                playbackSpeed = Math.min(playbackSpeed, CustomPlaybackSpeedPatch.PLAYBACK_SPEED_MAXIMUM - 0.05f);
+                playbackSpeed = Math.min(playbackSpeed, CustomPlaybackSpeedPatch.PLAYBACK_SPEED_MAXIMUM);
 
                 // Prevent toast spamming if using the 0.05x adjustments.
                 // Show exactly one toast after the user stops interacting with the speed menu.
@@ -57,7 +57,7 @@ public final class RememberPlaybackSpeedPatch {
                     }
                     Settings.PLAYBACK_SPEED_DEFAULT.save(finalPlaybackSpeed);
 
-                    Utils.showToastLong(str("revanced_remember_playback_speed_toast", (finalPlaybackSpeed + "x")));
+                    Utils.showToastShort(str("revanced_remember_playback_speed_toast", (finalPlaybackSpeed + "x")));
                 }, TOAST_DELAY_MILLISECONDS);
             }
         } catch (Exception ex) {

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/theme/ProgressBarDrawable.java

@@ -20,13 +20,16 @@ import app.revanced.extension.youtube.settings.Settings;
 public class ProgressBarDrawable extends Drawable {
 
     private final Paint paint = new Paint();
+    {
+        paint.setColor(SeekbarColorPatch.getSeekbarColor());
+    }
 
     @Override
     public void draw(@NonNull Canvas canvas) {
         if (Settings.HIDE_SEEKBAR_THUMBNAIL.get()) {
             return;
         }
-        paint.setColor(SeekbarColorPatch.getSeekbarColor());
+
         canvas.drawRect(getBounds(), paint);
     }
 

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/theme/SeekbarColorPatch.java

@@ -60,7 +60,7 @@ public final class SeekbarColorPatch {
      * this is the color value of {@link Settings#SEEKBAR_CUSTOM_COLOR_PRIMARY}.
      * Otherwise this is {@link #ORIGINAL_SEEKBAR_COLOR}.
      */
-    private static int customSeekbarColor = ORIGINAL_SEEKBAR_COLOR;
+    private static final int customSeekbarColor;
 
     /**
      * Custom seekbar hue, saturation, and brightness values.
@@ -77,24 +77,25 @@ public final class SeekbarColorPatch {
         Color.colorToHSV(ORIGINAL_SEEKBAR_COLOR, hsv);
         ORIGINAL_SEEKBAR_COLOR_BRIGHTNESS = hsv[2];
 
-        if (SEEKBAR_CUSTOM_COLOR_ENABLED) {
+        customSeekbarColor = SEEKBAR_CUSTOM_COLOR_ENABLED
-            loadCustomSeekbarColor();
+                ? loadCustomSeekbarColor()
-        }
+                : ORIGINAL_SEEKBAR_COLOR;
     }
 
-    private static void loadCustomSeekbarColor() {
+    private static int loadCustomSeekbarColor() {
         try {
-            customSeekbarColor = Color.parseColor(Settings.SEEKBAR_CUSTOM_COLOR_PRIMARY.get());
+            final int color = Color.parseColor(Settings.SEEKBAR_CUSTOM_COLOR_PRIMARY.get());
-            Color.colorToHSV(customSeekbarColor, customSeekbarColorHSV);
+            Color.colorToHSV(color, customSeekbarColorHSV);
-
+            customSeekbarColorGradient[0] = color;
-            customSeekbarColorGradient[0] = customSeekbarColor;
             customSeekbarColorGradient[1] = Color.parseColor(Settings.SEEKBAR_CUSTOM_COLOR_ACCENT.get());
+
+            return color;
         } catch (Exception ex) {
             Utils.showToastShort(str("revanced_seekbar_custom_color_invalid"));
             Settings.SEEKBAR_CUSTOM_COLOR_PRIMARY.resetToDefault();
             Settings.SEEKBAR_CUSTOM_COLOR_ACCENT.resetToDefault();
 
-            loadCustomSeekbarColor();
+            return loadCustomSeekbarColor();
         }
     }
 
@@ -114,6 +115,7 @@ public final class SeekbarColorPatch {
                 : (int) channel3Bits;
     }
 
+    @SuppressWarnings("SameParameterValue")
     private static String get9BitStyleIdentifier(int color24Bit) {
         final int r3 = colorChannelTo3Bits(Color.red(color24Bit));
         final int g3 = colorChannelTo3Bits(Color.green(color24Bit));
@@ -179,7 +181,7 @@ public final class SeekbarColorPatch {
             //noinspection ConstantConditions
             if (false) { // Set true to force slow animation for development.
                 final int longAnimation = Utils.getResourceIdentifier(
-                        Utils.isDarkModeEnabled(Utils.getContext())
+                        Utils.isDarkModeEnabled()
                                 ? "startup_animation_5s_30fps_dark"
                                 : "startup_animation_5s_30fps_light",
                         "raw");

extensions/youtube/src/main/java/app/revanced/extension/youtube/returnyoutubedislike/ReturnYouTubeDislike.java

@@ -21,8 +21,6 @@ import android.text.Spanned;
 import android.text.style.ForegroundColorSpan;
 import android.text.style.ImageSpan;
 import android.text.style.ReplacementSpan;
-import android.util.DisplayMetrics;
-import android.util.TypedValue;
 
 import androidx.annotation.GuardedBy;
 import androidx.annotation.NonNull;
@@ -120,16 +118,13 @@ public class ReturnYouTubeDislike {
     private static final ShapeDrawable leftSeparatorShape;
 
     static {
-        DisplayMetrics dp = Objects.requireNonNull(Utils.getContext()).getResources().getDisplayMetrics();
-
         leftSeparatorBounds = new Rect(0, 0,
-                (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1.2f, dp),
+                Utils.dipToPixels(1.2f),
-                (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 14, dp));
+                Utils.dipToPixels(14f));
-        final int middleSeparatorSize =
+        final int middleSeparatorSize = Utils.dipToPixels(3.7f);
-                (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 3.7f, dp);
         middleSeparatorBounds = new Rect(0, 0, middleSeparatorSize, middleSeparatorSize);
 
-        leftSeparatorShapePaddingPixels = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 8.4f, dp);
+        leftSeparatorShapePaddingPixels = Utils.dipToPixels(8.4f);
 
         leftSeparatorShape = new ShapeDrawable(new RectShape());
         leftSeparatorShape.setBounds(leftSeparatorBounds);

extensions/youtube/src/main/java/app/revanced/extension/youtube/settings/LicenseActivityHook.java

@@ -6,7 +6,6 @@ import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.content.Context;
 import android.preference.PreferenceFragment;
-import android.util.TypedValue;
 import android.view.ViewGroup;
 import android.widget.TextView;
 import android.widget.Toolbar;
@@ -119,8 +118,7 @@ public class LicenseActivityHook {
         toolbar.setNavigationIcon(ReVancedPreferenceFragment.getBackButtonDrawable());
         toolbar.setTitle(getResourceIdentifier("revanced_settings_title", "string"));
 
-        final int margin = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 16,
+        final int margin = Utils.dipToPixels(16);
-                Utils.getContext().getResources().getDisplayMetrics());
         toolbar.setTitleMarginStart(margin);
         toolbar.setTitleMarginEnd(margin);
         TextView toolbarTextView = Utils.getChildView(toolbar, false,

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

@@ -63,7 +63,7 @@ public class Settings extends BaseSettings {
     public static final BooleanSetting CUSTOM_SPEED_MENU = new BooleanSetting("revanced_custom_speed_menu", TRUE);
     public static final FloatSetting PLAYBACK_SPEED_DEFAULT = new FloatSetting("revanced_playback_speed_default", -2.0f);
     public static final StringSetting CUSTOM_PLAYBACK_SPEEDS = new StringSetting("revanced_custom_playback_speeds",
-            "0.25\n0.5\n0.75\n0.9\n0.95\n1.0\n1.05\n1.1\n1.25\n1.5\n1.75\n2.0\n3.0\n4.0\n5.0", true);
+            "0.25\n0.5\n0.75\n1.0\n1.25\n1.5\n1.75\n2.0\n2.5\n3.0\n4.0\n5.0\n6.0\n7.0\n8.0", true);
     // Audio
     public static final BooleanSetting FORCE_ORIGINAL_AUDIO = new BooleanSetting("revanced_force_original_audio", FALSE, new ForceOriginalAudioAvailability());
 
@@ -309,16 +309,16 @@ public class Settings extends BaseSettings {
     public static final BooleanSetting AUTO_REPEAT = new BooleanSetting("revanced_auto_repeat", FALSE);
     public static final BooleanSetting BYPASS_URL_REDIRECTS = new BooleanSetting("revanced_bypass_url_redirects", TRUE);
     public static final BooleanSetting CHECK_WATCH_HISTORY_DOMAIN_NAME = new BooleanSetting("revanced_check_watch_history_domain_name", TRUE, false, false);
-    public static final BooleanSetting DISABLE_ZOOM_HAPTICS = new BooleanSetting("revanced_disable_zoom_haptics", TRUE);
+    public static final BooleanSetting DISABLE_HAPTIC_FEEDBACK_CHAPTERS = new BooleanSetting("revanced_disable_haptic_feedback_chapters", FALSE);
+    public static final BooleanSetting DISABLE_HAPTIC_FEEDBACK_PRECISE_SEEKING = new BooleanSetting("revanced_disable_haptic_feedback_precise_seeking", FALSE);
+    public static final BooleanSetting DISABLE_HAPTIC_FEEDBACK_SEEK_UNDO = new BooleanSetting("revanced_disable_haptic_feedback_seek_undo", FALSE);
+    public static final BooleanSetting DISABLE_HAPTIC_FEEDBACK_ZOOM = new BooleanSetting("revanced_disable_haptic_feedback_zoom", FALSE);
     public static final BooleanSetting EXTERNAL_BROWSER = new BooleanSetting("revanced_external_browser", TRUE, true);
     public static final BooleanSetting REMOVE_TRACKING_QUERY_PARAMETER = new BooleanSetting("revanced_remove_tracking_query_parameter", TRUE);
     public static final BooleanSetting SPOOF_DEVICE_DIMENSIONS = new BooleanSetting("revanced_spoof_device_dimensions", FALSE, true,
             "revanced_spoof_device_dimensions_user_dialog_message");
-    /**
+    public static final BooleanSetting DEBUG_PROTOBUFFER = new BooleanSetting("revanced_debug_protobuffer", FALSE, false,
-     * When enabled, share the debug logs with care.
+            "revanced_debug_protobuffer_user_dialog_message", parent(BaseSettings.DEBUG));
-     * The buffer contains select user data, including the client ip address and information that could identify the end user.
-     */
-    public static final BooleanSetting DEBUG_PROTOBUFFER = new BooleanSetting("revanced_debug_protobuffer", FALSE, parent(BaseSettings.DEBUG));
 
     // Swipe controls
     public static final BooleanSetting SWIPE_CHANGE_VIDEO = new BooleanSetting("revanced_swipe_change_video", FALSE, true);
@@ -337,13 +337,17 @@ public class Settings extends BaseSettings {
             parentsAny(SWIPE_BRIGHTNESS, SWIPE_VOLUME));
     public static final IntegerSetting SWIPE_OVERLAY_OPACITY = new IntegerSetting("revanced_swipe_overlay_background_opacity", 60, true,
             parentsAny(SWIPE_BRIGHTNESS, SWIPE_VOLUME));
-    public static final StringSetting SWIPE_OVERLAY_PROGRESS_COLOR = new StringSetting("revanced_swipe_overlay_progress_color", "#FFFFFF", true,
+    public static final StringSetting SWIPE_OVERLAY_BRIGHTNESS_COLOR = new StringSetting("revanced_swipe_overlay_progress_brightness_color", "#FFFFFF", true,
-            parentsAny(SWIPE_BRIGHTNESS, SWIPE_VOLUME));
+            parent(SWIPE_BRIGHTNESS));
+    public static final StringSetting SWIPE_OVERLAY_VOLUME_COLOR = new StringSetting("revanced_swipe_overlay_progress_volume_color", "#FFFFFF", true,
+            parent(SWIPE_VOLUME));
     public static final LongSetting SWIPE_OVERLAY_TIMEOUT = new LongSetting("revanced_swipe_overlay_timeout", 500L, true,
             parentsAny(SWIPE_BRIGHTNESS, SWIPE_VOLUME));
-    public static final BooleanSetting SWIPE_SAVE_AND_RESTORE_BRIGHTNESS = new BooleanSetting("revanced_swipe_save_and_restore_brightness", TRUE, true, parent(SWIPE_BRIGHTNESS));
+    public static final BooleanSetting SWIPE_SAVE_AND_RESTORE_BRIGHTNESS = new BooleanSetting("revanced_swipe_save_and_restore_brightness", TRUE, true,
+            parent(SWIPE_BRIGHTNESS));
     public static final FloatSetting SWIPE_BRIGHTNESS_VALUE = new FloatSetting("revanced_swipe_brightness_value", -1f);
-    public static final BooleanSetting SWIPE_LOWEST_VALUE_ENABLE_AUTO_BRIGHTNESS = new BooleanSetting("revanced_swipe_lowest_value_enable_auto_brightness", FALSE, true, parent(SWIPE_BRIGHTNESS));
+    public static final BooleanSetting SWIPE_LOWEST_VALUE_ENABLE_AUTO_BRIGHTNESS = new BooleanSetting("revanced_swipe_lowest_value_enable_auto_brightness", FALSE, true,
+            parent(SWIPE_BRIGHTNESS));
 
     // ReturnYoutubeDislike
     public static final BooleanSetting RYD_ENABLED = new BooleanSetting("revanced_ryd_enabled", TRUE);

extensions/youtube/src/main/java/app/revanced/extension/youtube/settings/preference/ClearLogBufferPreference.java

@@ -0,0 +1,34 @@
+package app.revanced.extension.youtube.settings.preference;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.preference.Preference;
+import app.revanced.extension.shared.settings.preference.LogBufferManager;
+
+/**
+ * A custom preference that clears the ReVanced debug log buffer when clicked.
+ * Invokes the {@link LogBufferManager#clearLogBuffer} method.
+ */
+@SuppressWarnings("unused")
+public class ClearLogBufferPreference extends Preference {
+
+    {
+        setOnPreferenceClickListener(pref -> {
+            LogBufferManager.clearLogBuffer();
+            return true;
+        });
+    }
+
+    public ClearLogBufferPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+    public ClearLogBufferPreference(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+    public ClearLogBufferPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+    public ClearLogBufferPreference(Context context) {
+        super(context);
+    }
+}

extensions/youtube/src/main/java/app/revanced/extension/youtube/settings/preference/ExportLogToClipboardPreference.java

@@ -0,0 +1,34 @@
+package app.revanced.extension.youtube.settings.preference;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.preference.Preference;
+import app.revanced.extension.shared.settings.preference.LogBufferManager;
+
+/**
+ * A custom preference that triggers exporting ReVanced debug logs to the clipboard when clicked.
+ * Invokes the {@link LogBufferManager#exportToClipboard} method.
+ */
+@SuppressWarnings({"deprecation", "unused"})
+public class ExportLogToClipboardPreference extends Preference {
+
+    {
+        setOnPreferenceClickListener(pref -> {
+            LogBufferManager.exportToClipboard();
+            return true;
+        });
+    }
+
+    public ExportLogToClipboardPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+    public ExportLogToClipboardPreference(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+    public ExportLogToClipboardPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+    public ExportLogToClipboardPreference(Context context) {
+        super(context);
+    }
+}

extensions/youtube/src/main/java/app/revanced/extension/youtube/settings/preference/ReVancedPreferenceFragment.java

@@ -17,7 +17,6 @@ import android.preference.SwitchPreference;
 import android.text.SpannableStringBuilder;
 import android.text.TextUtils;
 import android.text.style.BackgroundColorSpan;
-import android.util.TypedValue;
 import android.view.ViewGroup;
 import android.view.WindowInsets;
 import android.widget.TextView;
@@ -245,9 +244,7 @@ public class ReVancedPreferenceFragment extends AbstractPreferenceFragment {
                             toolbar.setNavigationIcon(getBackButtonDrawable());
                             toolbar.setNavigationOnClickListener(view -> preferenceScreenDialog.dismiss());
 
-                            final int margin = (int) TypedValue.applyDimension(
+                            final int margin = Utils.dipToPixels(16);
-                                    TypedValue.COMPLEX_UNIT_DIP, 16, getResources().getDisplayMetrics()
-                            );
                             toolbar.setTitleMargin(margin, 0, margin, 0);
 
                             TextView toolbarTextView = Utils.getChildView(toolbar,

extensions/youtube/src/main/java/app/revanced/extension/youtube/sponsorblock/SegmentPlaybackController.java

@@ -5,7 +5,6 @@ import static app.revanced.extension.shared.StringRef.str;
 import android.graphics.Canvas;
 import android.graphics.Rect;
 import android.text.TextUtils;
-import android.util.TypedValue;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -727,15 +726,11 @@ public class SegmentPlaybackController {
         }
     }
 
-    private static int highlightSegmentTimeBarScreenWidth = -1; // actual pixel width to use
+    /**
-    private static int getHighlightSegmentTimeBarScreenWidth() {
+     * Actual screen pixel width to use for the highlight segment time bar.
-        if (highlightSegmentTimeBarScreenWidth == -1) {
+     */
-            highlightSegmentTimeBarScreenWidth = (int) TypedValue.applyDimension(
+    private static final int highlightSegmentTimeBarScreenWidth
-                    TypedValue.COMPLEX_UNIT_DIP, HIGHLIGHT_SEGMENT_DRAW_BAR_WIDTH,
+            = Utils.dipToPixels(HIGHLIGHT_SEGMENT_DRAW_BAR_WIDTH);
-                    Objects.requireNonNull(Utils.getContext()).getResources().getDisplayMetrics());
-        }
-        return highlightSegmentTimeBarScreenWidth;
-    }
 
     /**
      * Injection point.
@@ -757,7 +752,7 @@ public class SegmentPlaybackController {
                 final float left = leftPadding + segment.start * videoMillisecondsToPixels;
                 final float right;
                 if (segment.category == SegmentCategory.HIGHLIGHT) {
-                    right = left + getHighlightSegmentTimeBarScreenWidth();
+                    right = left + highlightSegmentTimeBarScreenWidth;
                 } else {
                      right = leftPadding + segment.end * videoMillisecondsToPixels;
                 }

extensions/youtube/src/main/java/app/revanced/extension/youtube/sponsorblock/objects/SegmentCategory.java

@@ -1,6 +1,7 @@
 package app.revanced.extension.youtube.sponsorblock.objects;
 
 import static app.revanced.extension.shared.StringRef.sf;
+import static app.revanced.extension.shared.settings.preference.ColorPickerPreference.COLOR_DOT_STRING;
 import static app.revanced.extension.youtube.settings.Settings.*;
 
 import android.graphics.Color;
@@ -9,7 +10,9 @@ import android.text.Spannable;
 import android.text.SpannableString;
 import android.text.TextUtils;
 import android.text.style.ForegroundColorSpan;
+import android.text.style.RelativeSizeSpan;
 
+import androidx.annotation.ColorInt;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
@@ -134,7 +137,8 @@ public enum SegmentCategory {
         updateEnabledCategories();
     }
 
-    public static int applyOpacityToColor(int color, float opacity) {
+    @ColorInt
+    public static int applyOpacityToColor(@ColorInt int color, float opacity) {
         if (opacity < 0 || opacity > 1.0f) {
             throw new IllegalArgumentException("Invalid opacity: " + opacity);
         }
@@ -165,29 +169,28 @@ public enum SegmentCategory {
     /**
      * Skipped segment toast, if the skip occurred in the first quarter of the video
      */
-    @NonNull
     public final StringRef skippedToastBeginning;
     /**
      * Skipped segment toast, if the skip occurred in the middle half of the video
      */
-    @NonNull
     public final StringRef skippedToastMiddle;
     /**
      * Skipped segment toast, if the skip occurred in the last quarter of the video
      */
-    @NonNull
     public final StringRef skippedToastEnd;
 
-    @NonNull
     public final Paint paint;
 
+    /**
+     * Category color with opacity applied.
+     */
+    @ColorInt
     private int color;
 
     /**
      * Value must be changed using {@link #setBehaviour(CategoryBehaviour)}.
      * Caller must also {@link #updateEnabledCategories()}.
      */
-    @NonNull
     public CategoryBehaviour behaviour = CategoryBehaviour.IGNORE;
 
     SegmentCategory(String keyValue, StringRef title, StringRef description,
@@ -247,7 +250,7 @@ public enum SegmentCategory {
         }
     }
 
-    public void setBehaviour(@NonNull CategoryBehaviour behaviour) {
+    public void setBehaviour(CategoryBehaviour behaviour) {
         this.behaviour = Objects.requireNonNull(behaviour);
         this.behaviorSetting.save(behaviour.reVancedKeyValue);
     }
@@ -273,6 +276,10 @@ public enum SegmentCategory {
         return opacitySetting.get();
     }
 
+    public float getOpacityDefault() {
+        return opacitySetting.defaultValue;
+    }
+
     public void resetColorAndOpacity() {
         setColor(colorSetting.defaultValue);
         setOpacity(opacitySetting.defaultValue);
@@ -291,10 +298,19 @@ public enum SegmentCategory {
     /**
      * @return Integer color of #RRGGBB format.
      */
+    @ColorInt
     public int getColorNoOpacity() {
         return color & 0x00FFFFFF;
     }
 
+    /**
+     * @return Integer color of #RRGGBB format.
+     */
+    @ColorInt
+    public int getColorNoOpacityDefault() {
+        return Color.parseColor(colorSetting.defaultValue) & 0x00FFFFFF;
+    }
+
     /**
      * @return Hex color string of #RRGGBB format with no opacity level.
      */
@@ -302,22 +318,27 @@ public enum SegmentCategory {
         return String.format(Locale.US, "#%06X", getColorNoOpacity());
     }
 
-    private static SpannableString getCategoryColorDotSpan(String text, int color) {
+    private static SpannableString getCategoryColorDotSpan(String text, @ColorInt int color) {
-        SpannableString dotSpan = new SpannableString('⬤' + text);
+        SpannableString dotSpan = new SpannableString(COLOR_DOT_STRING + text);
         dotSpan.setSpan(new ForegroundColorSpan(color), 0, 1,
                 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
         return dotSpan;
     }
 
-    public static SpannableString getCategoryColorDot(int color) {
+    public static SpannableString getCategoryColorDot(@ColorInt int color) {
-        return getCategoryColorDotSpan("", color);
+        SpannableString dotSpan = new SpannableString(COLOR_DOT_STRING);
+        dotSpan.setSpan(new ForegroundColorSpan(color), 0, 1,
+                Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+        dotSpan.setSpan(new RelativeSizeSpan(1.5f), 0, 1,
+                Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+        return dotSpan;
     }
 
     public SpannableString getCategoryColorDot() {
         return getCategoryColorDot(color);
     }
 
-    public SpannableString getTitleWithColorDot(int categoryColor) {
+    public SpannableString getTitleWithColorDot(@ColorInt int categoryColor) {
         return getCategoryColorDotSpan(" " + title, categoryColor);
     }
 

extensions/youtube/src/main/java/app/revanced/extension/youtube/sponsorblock/objects/SegmentCategoryListPreference.java

@@ -1,35 +1,46 @@
 package app.revanced.extension.youtube.sponsorblock.objects;
 
 import static app.revanced.extension.shared.StringRef.str;
+import static app.revanced.extension.shared.Utils.getResourceIdentifier;
+import static app.revanced.extension.shared.settings.preference.ColorPickerPreference.getColorString;
 import static app.revanced.extension.youtube.sponsorblock.objects.SegmentCategory.applyOpacityToColor;
 
 import android.app.AlertDialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.graphics.Color;
+import android.graphics.Typeface;
+import android.os.Bundle;
 import android.preference.ListPreference;
 import android.text.Editable;
 import android.text.InputType;
 import android.text.TextWatcher;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.Button;
 import android.widget.EditText;
 import android.widget.GridLayout;
+import android.widget.LinearLayout;
 import android.widget.TextView;
 
+import androidx.annotation.ColorInt;
+
 import java.util.Locale;
 import java.util.Objects;
 
 import app.revanced.extension.shared.Logger;
 import app.revanced.extension.shared.Utils;
+import app.revanced.extension.shared.settings.preference.ColorPickerPreference;
+import app.revanced.extension.shared.settings.preference.ColorPickerView;
 
 @SuppressWarnings("deprecation")
 public class SegmentCategoryListPreference extends ListPreference {
     private final SegmentCategory category;
-    private TextView colorDotView;
+
-    private EditText colorEditText;
-    private EditText opacityEditText;
     /**
-     * #RRGGBB
+     * RGB format (no alpha).
      */
+    @ColorInt
     private int categoryColor;
     /**
      * [0, 1]
@@ -37,6 +48,11 @@ public class SegmentCategoryListPreference extends ListPreference {
     private float categoryOpacity;
     private int selectedDialogEntryIndex;
 
+    private TextView dialogColorDotView;
+    private EditText dialogColorEditText;
+    private EditText dialogOpacityEditText;
+    private ColorPickerView dialogColorPickerView;
+
     public SegmentCategoryListPreference(Context context, SegmentCategory category) {
         super(context);
         this.category = Objects.requireNonNull(category);
@@ -67,8 +83,20 @@ public class SegmentCategoryListPreference extends ListPreference {
             categoryOpacity = category.getOpacity();
 
             Context context = builder.getContext();
+            LinearLayout mainLayout = new LinearLayout(context);
+            mainLayout.setOrientation(LinearLayout.VERTICAL);
+            mainLayout.setPadding(70, 0, 70, 0);
+
+            // Inflate the color picker view.
+            View colorPickerContainer = LayoutInflater.from(context)
+                    .inflate(getResourceIdentifier("revanced_color_picker", "layout"), null);
+            dialogColorPickerView = colorPickerContainer.findViewById(
+                    getResourceIdentifier("color_picker_view", "id"));
+            dialogColorPickerView.setColor(categoryColor);
+            mainLayout.addView(colorPickerContainer);
+
+            // Grid layout for color and opacity inputs.
             GridLayout gridLayout = new GridLayout(context);
-            gridLayout.setPadding(70, 0, 150, 0); // Padding for the entire layout.
             gridLayout.setColumnCount(3);
             gridLayout.setRowCount(2);
 
@@ -84,19 +112,22 @@ public class SegmentCategoryListPreference extends ListPreference {
             gridParams.rowSpec = GridLayout.spec(0); // First row.
             gridParams.columnSpec = GridLayout.spec(1); // Second column.
             gridParams.setMargins(0, 0, 10, 0);
-            colorDotView = new TextView(context);
+            dialogColorDotView = new TextView(context);
-            colorDotView.setLayoutParams(gridParams);
+            dialogColorDotView.setLayoutParams(gridParams);
-            gridLayout.addView(colorDotView);
+            gridLayout.addView(dialogColorDotView);
             updateCategoryColorDot();
 
             gridParams = new GridLayout.LayoutParams();
             gridParams.rowSpec = GridLayout.spec(0); // First row.
             gridParams.columnSpec = GridLayout.spec(2); // Third column.
-            colorEditText = new EditText(context);
+            dialogColorEditText = new EditText(context);
-            colorEditText.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS);
+            dialogColorEditText.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS
-            colorEditText.setTextLocale(Locale.US);
+                    | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);
-            colorEditText.setText(category.getColorString());
+            dialogColorEditText.setAutofillHints((String) null);
-            colorEditText.addTextChangedListener(new TextWatcher() {
+            dialogColorEditText.setTypeface(Typeface.MONOSPACE);
+            dialogColorEditText.setTextLocale(Locale.US);
+            dialogColorEditText.setText(getColorString(categoryColor));
+            dialogColorEditText.addTextChangedListener(new TextWatcher() {
                 @Override
                 public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                 }
@@ -109,28 +140,30 @@ public class SegmentCategoryListPreference extends ListPreference {
                 public void afterTextChanged(Editable edit) {
                     try {
                         String colorString = edit.toString();
-                        final int colorStringLength = colorString.length();
+                        String normalizedColorString = ColorPickerPreference.cleanupColorCodeString(colorString);
 
-                        if (!colorString.startsWith("#")) {
+                        if (!normalizedColorString.equals(colorString)) {
-                            edit.insert(0, "#"); // Recursively calls back into this method.
+                            edit.replace(0, colorString.length(), normalizedColorString);
                             return;
                         }
 
-                        final int maxColorStringLength = 7; // #RRGGBB
+                        if (normalizedColorString.length() != ColorPickerPreference.COLOR_STRING_LENGTH) {
-                        if (colorStringLength > maxColorStringLength) {
+                            // User is still typing out the color.
-                            edit.delete(maxColorStringLength, colorStringLength);
                             return;
                         }
 
-                        categoryColor = Color.parseColor(colorString);
+                        // Remove the alpha channel.
-                        updateCategoryColorDot();
+                        final int newColor = Color.parseColor(colorString) & 0x00FFFFFF;
-                    } catch (IllegalArgumentException ex) {
+                        // Changing view color causes callback into this class.
-                        // Ignore.
+                        dialogColorPickerView.setColor(newColor);
+                    } catch (Exception ex) {
+                        // Should never be reached since input is validated before using.
+                        Logger.printException(() -> "colorEditText afterTextChanged failure", ex);
                     }
                 }
             });
-            colorEditText.setLayoutParams(gridParams);
+            dialogColorEditText.setLayoutParams(gridParams);
-            gridLayout.addView(colorEditText);
+            gridLayout.addView(dialogColorEditText);
 
             gridParams = new GridLayout.LayoutParams();
             gridParams.rowSpec = GridLayout.spec(1); // Second row.
@@ -143,9 +176,13 @@ public class SegmentCategoryListPreference extends ListPreference {
             gridParams = new GridLayout.LayoutParams();
             gridParams.rowSpec = GridLayout.spec(1); // Second row.
             gridParams.columnSpec = GridLayout.spec(2); // Third column.
-            opacityEditText = new EditText(context);
+            dialogOpacityEditText = new EditText(context);
-            opacityEditText.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_DECIMAL);
+            dialogOpacityEditText.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_DECIMAL
-            opacityEditText.addTextChangedListener(new TextWatcher() {
+                    | InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);
+            dialogOpacityEditText.setAutofillHints((String) null);
+            dialogOpacityEditText.setTypeface(Typeface.MONOSPACE);
+            dialogOpacityEditText.setTextLocale(Locale.US);
+            dialogOpacityEditText.addTextChangedListener(new TextWatcher() {
                 @Override
                 public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                 }
@@ -183,31 +220,40 @@ public class SegmentCategoryListPreference extends ListPreference {
                         }
 
                         updateCategoryColorDot();
-                    } catch (NumberFormatException ex) {
+                    } catch (Exception ex) {
                         // Should never happen.
-                        Logger.printException(() -> "Could not parse opacity string", ex);
+                        Logger.printException(() -> "opacityEditText afterTextChanged failure", ex);
                     }
                 }
             });
-            opacityEditText.setLayoutParams(gridParams);
+            dialogOpacityEditText.setLayoutParams(gridParams);
-            gridLayout.addView(opacityEditText);
+            gridLayout.addView(dialogOpacityEditText);
             updateOpacityText();
 
-            builder.setView(gridLayout);
+            mainLayout.addView(gridLayout);
+
+            // Set up color picker listener.
+            // Do last to prevent listener callbacks while setting up view.
+            dialogColorPickerView.setOnColorChangedListener(color -> {
+                if (categoryColor == color) {
+                    return;
+                }
+                categoryColor = color;
+                String hexColor = getColorString(color);
+                Logger.printDebug(() -> "onColorChanged: " + hexColor);
+
+                updateCategoryColorDot();
+                dialogColorEditText.setText(hexColor);
+                dialogColorEditText.setSelection(hexColor.length());
+            });
+
+            builder.setView(mainLayout);
             builder.setTitle(category.title.toString());
 
             builder.setPositiveButton(android.R.string.ok, (dialog, which) -> {
                 onClick(dialog, DialogInterface.BUTTON_POSITIVE);
             });
-            builder.setNeutralButton(str("revanced_sb_reset_color"), (dialog, which) -> {
+            builder.setNeutralButton(str("revanced_settings_reset_color"), null);
-                try {
-                    category.resetColorAndOpacity();
-                    updateUI();
-                    Utils.showToastShort(str("revanced_sb_color_reset"));
-                } catch (Exception ex) {
-                    Logger.printException(() -> "setNeutralButton failure", ex);
-                }
-            });
             builder.setNegativeButton(android.R.string.cancel, null);
 
             selectedDialogEntryIndex = findIndexOfValue(getValue());
@@ -218,6 +264,25 @@ public class SegmentCategoryListPreference extends ListPreference {
         }
     }
 
+    @Override
+    protected void showDialog(Bundle state) {
+        super.showDialog(state);
+
+        // Do not close dialog when reset is pressed.
+        Button button = ((AlertDialog) getDialog()).getButton(AlertDialog.BUTTON_NEUTRAL);
+        button.setOnClickListener(view -> {
+            try {
+                // Setting view color causes callback to update the UI.
+                dialogColorPickerView.setColor(category.getColorNoOpacityDefault());
+
+                categoryOpacity = category.getOpacityDefault();
+                updateOpacityText();
+            } catch (Exception ex) {
+                Logger.printException(() -> "setOnClickListener failure", ex);
+            }
+        });
+    }
+
     @Override
     protected void onDialogClosed(boolean positiveResult) {
         try {
@@ -230,43 +295,42 @@ public class SegmentCategoryListPreference extends ListPreference {
                 }
 
                 try {
-                    String colorString = colorEditText.getText().toString();
+                    category.setColor(dialogColorEditText.getText().toString());
-                    if (!colorString.equals(category.getColorString()) || categoryOpacity != category.getOpacity()) {
+                    category.setOpacity(categoryOpacity);
-                        category.setColor(colorString);
-                        category.setOpacity(categoryOpacity);
-                        Utils.showToastShort(str("revanced_sb_color_changed"));
-                    }
                 } catch (IllegalArgumentException ex) {
-                    Utils.showToastShort(str("revanced_sb_color_invalid"));
+                    Utils.showToastShort(str("revanced_settings_color_invalid"));
                 }
 
                 updateUI();
             }
         } catch (Exception ex) {
             Logger.printException(() -> "onDialogClosed failure", ex);
+        } finally {
+            dialogColorDotView = null;
+            dialogColorEditText = null;
+            dialogOpacityEditText = null;
+            dialogColorPickerView = null;
         }
     }
 
-    private void applyOpacityToCategoryColor() {
+    @ColorInt
-        categoryColor = applyOpacityToColor(categoryColor, categoryOpacity);
+    private int applyOpacityToCategoryColor() {
+        return applyOpacityToColor(categoryColor, categoryOpacity);
     }
 
     public void updateUI() {
         categoryColor = category.getColorNoOpacity();
         categoryOpacity = category.getOpacity();
-        applyOpacityToCategoryColor();
 
-        setTitle(category.getTitleWithColorDot(categoryColor));
+        setTitle(category.getTitleWithColorDot(applyOpacityToCategoryColor()));
     }
 
     private void updateCategoryColorDot() {
-        applyOpacityToCategoryColor();
+        dialogColorDotView.setText(SegmentCategory.getCategoryColorDot(applyOpacityToCategoryColor()));
-
-        colorDotView.setText(SegmentCategory.getCategoryColorDot(categoryColor));
     }
 
     private void updateOpacityText() {
-        opacityEditText.setText(String.format(Locale.US, "%.2f", categoryOpacity));
+        dialogOpacityEditText.setText(String.format(Locale.US, "%.2f", categoryOpacity));
     }
 
     @Override

extensions/youtube/src/main/java/app/revanced/extension/youtube/sponsorblock/ui/SponsorBlockPreferenceGroup.java

@@ -376,7 +376,11 @@ public class SponsorBlockPreferenceGroup extends PreferenceGroup {
                     Utils.setEditTextDialogTheme(builder);
 
                     builder.setNeutralButton(str("revanced_sb_settings_copy"), (dialog, which) -> {
-                        Utils.setClipboard(getEditText().getText().toString());
+                        try {
+                            Utils.setClipboard(getEditText().getText());
+                        } catch (Exception ex) {
+                            Logger.printException(() -> "Copy settings failure", ex);
+                        }
                     });
                 }
             };
@@ -421,7 +425,7 @@ public class SponsorBlockPreferenceGroup extends PreferenceGroup {
                         .setTitle(apiUrl.getTitle())
                         .setView(editText)
                         .setNegativeButton(android.R.string.cancel, null)
-                        .setNeutralButton(str("revanced_sb_reset"), urlChangeListener)
+                        .setNeutralButton(str("revanced_settings_reset"), urlChangeListener)
                         .setPositiveButton(android.R.string.ok, urlChangeListener)
                         .show();
                 return true;
@@ -433,7 +437,11 @@ public class SponsorBlockPreferenceGroup extends PreferenceGroup {
                     Utils.setEditTextDialogTheme(builder);
 
                     builder.setNeutralButton(str("revanced_sb_settings_copy"), (dialog, which) -> {
-                        Utils.setClipboard(getEditText().getText().toString());
+                        try {
+                            Utils.setClipboard(getEditText().getText());
+                        } catch (Exception ex) {
+                            Logger.printException(() -> "Copy settings failure", ex);
+                        }
                     });
                 }
             };

extensions/youtube/src/main/java/app/revanced/extension/youtube/swipecontrols/SwipeControlsConfigurationProvider.kt

@@ -1,10 +1,10 @@
 package app.revanced.extension.youtube.swipecontrols
 
-import android.annotation.SuppressLint
 import android.graphics.Color
 import app.revanced.extension.shared.Logger
 import app.revanced.extension.shared.StringRef.str
 import app.revanced.extension.shared.Utils
+import app.revanced.extension.shared.settings.StringSetting
 import app.revanced.extension.youtube.settings.Settings
 import app.revanced.extension.youtube.shared.PlayerType
 
@@ -51,105 +51,112 @@ class SwipeControlsConfigurationProvider {
     /**
      * Indicates whether press-to-swipe mode is enabled, requiring a press before swiping to activate controls.
      */
-    val shouldEnablePressToSwipe: Boolean
+    val shouldEnablePressToSwipe = Settings.SWIPE_PRESS_TO_ENGAGE.get()
-        get() = Settings.SWIPE_PRESS_TO_ENGAGE.get()
 
     /**
      * The threshold for detecting swipe gestures, in pixels.
      * Loaded once to ensure consistent behavior during rapid scroll events.
      */
-    val swipeMagnitudeThreshold: Int
+    val swipeMagnitudeThreshold = Settings.SWIPE_MAGNITUDE_THRESHOLD.get()
-        get() = Settings.SWIPE_MAGNITUDE_THRESHOLD.get()
 
     /**
      * The sensitivity of volume swipe gestures, determining how much volume changes per swipe.
      * Resets to default if set to 0, as it would disable swiping.
      */
-    val volumeSwipeSensitivity: Int
+    val volumeSwipeSensitivity: Int by lazy {
-        get() {
+        val sensitivity = Settings.SWIPE_VOLUME_SENSITIVITY.get()
-            val sensitivity = Settings.SWIPE_VOLUME_SENSITIVITY.get()
 
-            if (sensitivity < 1) {
+        if (sensitivity < 1) {
-                return Settings.SWIPE_VOLUME_SENSITIVITY.resetToDefault()
+            return@lazy Settings.SWIPE_VOLUME_SENSITIVITY.resetToDefault()
-            }
-
-            return sensitivity
         }
+
+        sensitivity
+    }
     //endregion
 
     //region overlay adjustments
     /**
      * Indicates whether haptic feedback should be enabled for swipe control interactions.
      */
-    val shouldEnableHapticFeedback: Boolean
+    val shouldEnableHapticFeedback = Settings.SWIPE_HAPTIC_FEEDBACK.get()
-        get() = Settings.SWIPE_HAPTIC_FEEDBACK.get()
 
     /**
      * The duration in milliseconds that the overlay should remain visible after a change.
      */
-    val overlayShowTimeoutMillis: Long
+    val overlayShowTimeoutMillis = Settings.SWIPE_OVERLAY_TIMEOUT.get()
-        get() = Settings.SWIPE_OVERLAY_TIMEOUT.get()
 
     /**
      * The background opacity of the overlay, converted from a percentage (0-100) to an alpha value (0-255).
      * Resets to default and shows a toast if the value is out of range.
      */
-    val overlayBackgroundOpacity: Int
+    val overlayBackgroundOpacity: Int by lazy {
-        get() {
+        var opacity = Settings.SWIPE_OVERLAY_OPACITY.get()
-            var opacity = Settings.SWIPE_OVERLAY_OPACITY.get()
 
-            if (opacity < 0 || opacity > 100) {
+        if (opacity < 0 || opacity > 100) {
-                Utils.showToastLong(str("revanced_swipe_overlay_background_opacity_invalid_toast"))
+            Utils.showToastLong(str("revanced_swipe_overlay_background_opacity_invalid_toast"))
-                opacity = Settings.SWIPE_OVERLAY_OPACITY.resetToDefault()
+            opacity = Settings.SWIPE_OVERLAY_OPACITY.resetToDefault()
-            }
-
-            opacity = opacity * 255 / 100
-            return Color.argb(opacity, 0, 0, 0)
         }
 
+        opacity = opacity * 255 / 100
+        Color.argb(opacity, 0, 0, 0)
+    }
+
     /**
-     * The color of the progress bar in the overlay.
+     * The color of the progress bar in the overlay for brightness.
      * Resets to default and shows a toast if the color string is invalid or empty.
      */
-    val overlayProgressColor: Int
+    val overlayBrightnessProgressColor: Int by lazy {
-        get() {
+        // Use lazy to avoid repeat parsing. Changing color requires app restart.
-            try {
+        getSettingColor(Settings.SWIPE_OVERLAY_BRIGHTNESS_COLOR)
-                @SuppressLint("UseKtx")
+    }
-                val color = Color.parseColor(Settings.SWIPE_OVERLAY_PROGRESS_COLOR.get())
+
-                return (0xBF000000.toInt() or (color and 0xFFFFFF))
+    /**
-            } catch (ex: IllegalArgumentException) {
+     * The color of the progress bar in the overlay for volume.
-                Logger.printDebug({ "Could not parse color" }, ex)
+     * Resets to default and shows a toast if the color string is invalid or empty.
-                Utils.showToastLong(str("revanced_swipe_overlay_progress_color_invalid_toast"))
+     */
-                Settings.SWIPE_OVERLAY_PROGRESS_COLOR.resetToDefault()
+    val overlayVolumeProgressColor: Int by lazy {
-                return overlayProgressColor // Recursively return.
+        getSettingColor(Settings.SWIPE_OVERLAY_VOLUME_COLOR)
-            }
+    }
+
+    private fun getSettingColor(setting: StringSetting): Int {
+        try {
+            //noinspection UseKtx
+            val color = Color.parseColor(setting.get())
+            return (0xBF000000.toInt() or (color and 0x00FFFFFF))
+        } catch (ex: IllegalArgumentException) {
+            // This code should never be reached.
+            // Color picker rejects and will not save bad colors to a setting.
+            // If a user imports bad data, the color picker preference resets the
+            // bad color before this method can be called.
+            Logger.printDebug({ "Could not parse color: $setting" }, ex)
+            Utils.showToastLong(str("revanced_settings_color_invalid"))
+            setting.resetToDefault()
+            return getSettingColor(setting) // Recursively return.
         }
+    }
 
     /**
      * The background color used for the filled portion of the progress bar in the overlay.
      */
-    val overlayFillBackgroundPaint: Int
+    val overlayFillBackgroundPaint = 0x80D3D3D3.toInt()
-        get() = 0x80D3D3D3.toInt()
 
     /**
      * The color used for text and icons in the overlay.
      */
-    val overlayTextColor: Int
+    val overlayTextColor = Color.WHITE
-        get() = Color.WHITE
 
     /**
      * The text size in the overlay, in density-independent pixels (dp).
      * Must be between 1 and 30 dp; resets to default and shows a toast if invalid.
      */
-    val overlayTextSize: Int
+    val overlayTextSize: Int by lazy {
-        get() {
+        val size = Settings.SWIPE_OVERLAY_TEXT_SIZE.get()
-            val size = Settings.SWIPE_OVERLAY_TEXT_SIZE.get()
+        if (size < 1 || size > 30) {
-            if (size < 1 || size > 30) {
+            Utils.showToastLong(str("revanced_swipe_text_overlay_size_invalid_toast"))
-                Utils.showToastLong(str("revanced_swipe_text_overlay_size_invalid_toast"))
+            return@lazy Settings.SWIPE_OVERLAY_TEXT_SIZE.resetToDefault()
-                return Settings.SWIPE_OVERLAY_TEXT_SIZE.resetToDefault()
-            }
-            return size
         }
+        size
+    }
 
     /**
      * Defines the style of the swipe controls overlay, determining its layout and appearance.
@@ -199,28 +206,25 @@ class SwipeControlsConfigurationProvider {
         /**
          * A minimal vertical progress bar.
          */
-        VERTICAL_MINIMAL(isMinimal =  true, isVertical = true)
+        VERTICAL_MINIMAL(isMinimal = true, isVertical = true)
     }
 
     /**
      * The current style of the overlay, determining its layout and appearance.
      */
-    val overlayStyle: SwipeOverlayStyle
+    val overlayStyle = Settings.SWIPE_OVERLAY_STYLE.get()
-        get() = Settings.SWIPE_OVERLAY_STYLE.get()
     //endregion
 
     //region behaviour
     /**
      * Indicates whether the brightness level should be saved and restored when entering or exiting fullscreen mode.
      */
-    val shouldSaveAndRestoreBrightness: Boolean
+    val shouldSaveAndRestoreBrightness = Settings.SWIPE_SAVE_AND_RESTORE_BRIGHTNESS.get()
-        get() = Settings.SWIPE_SAVE_AND_RESTORE_BRIGHTNESS.get()
 
     /**
      * Indicates whether auto-brightness should be enabled when the brightness gesture reaches its lowest value.
      */
-    val shouldLowestValueEnableAutoBrightness: Boolean
+    val shouldLowestValueEnableAutoBrightness = Settings.SWIPE_LOWEST_VALUE_ENABLE_AUTO_BRIGHTNESS.get()
-        get() = Settings.SWIPE_LOWEST_VALUE_ENABLE_AUTO_BRIGHTNESS.get()
 
     /**
      * The saved brightness value for the swipe gesture, used to restore brightness in fullscreen mode.

extensions/youtube/src/main/java/app/revanced/extension/youtube/swipecontrols/views/SwipeControlsOverlayLayout.kt

@@ -39,7 +39,7 @@ class SwipeControlsOverlayLayout(
 
     constructor(context: Context) : this(context, SwipeControlsConfigurationProvider())
 
-    // Drawable icons for brightness and volume
+    // Drawable icons for brightness and volume.
     private val autoBrightnessIcon: Drawable = getDrawable("revanced_ic_sc_brightness_auto")
     private val lowBrightnessIcon: Drawable = getDrawable("revanced_ic_sc_brightness_low")
     private val mediumBrightnessIcon: Drawable = getDrawable("revanced_ic_sc_brightness_medium")
@@ -50,7 +50,7 @@ class SwipeControlsOverlayLayout(
     private val normalVolumeIcon: Drawable = getDrawable("revanced_ic_sc_volume_normal")
     private val fullVolumeIcon: Drawable = getDrawable("revanced_ic_sc_volume_high")
 
-    // Function to retrieve drawable resources by name
+    // Function to retrieve drawable resources by name.
     private fun getDrawable(name: String): Drawable {
         val drawable = resources.getDrawable(
             Utils.getResourceIdentifier(context, name, "drawable"),
@@ -60,19 +60,19 @@ class SwipeControlsOverlayLayout(
         return drawable
     }
 
-    // Initialize progress bars
+    // Initialize progress bars.
     private val circularProgressView: CircularProgressView
     private val horizontalProgressView: HorizontalProgressView
     private val verticalBrightnessProgressView: VerticalProgressView
     private val verticalVolumeProgressView: VerticalProgressView
 
     init {
-        // Initialize circular progress bar
+        // Initialize circular progress bar.
         circularProgressView = CircularProgressView(
             context,
             config.overlayBackgroundOpacity,
             config.overlayStyle.isMinimal,
-            config.overlayProgressColor,
+            config.overlayBrightnessProgressColor, // Placeholder, updated in showFeedbackView.
             config.overlayFillBackgroundPaint,
             config.overlayTextColor,
             config.overlayTextSize
@@ -80,18 +80,18 @@ class SwipeControlsOverlayLayout(
             layoutParams = LayoutParams(100f.toDisplayPixels().toInt(), 100f.toDisplayPixels().toInt()).apply {
                 addRule(CENTER_IN_PARENT, TRUE)
             }
-            visibility = GONE // Initially hidden
+            visibility = GONE // Initially hidden.
         }
         addView(circularProgressView)
 
-        // Initialize horizontal progress bar
+        // Initialize horizontal progress bar.
         val screenWidth = resources.displayMetrics.widthPixels
-        val layoutWidth = (screenWidth * 4 / 5).toInt() // Cap at ~360dp
+        val layoutWidth = (screenWidth * 4 / 5).toInt() // Cap at ~360dp.
         horizontalProgressView = HorizontalProgressView(
             context,
             config.overlayBackgroundOpacity,
             config.overlayStyle.isMinimal,
-            config.overlayProgressColor,
+            config.overlayBrightnessProgressColor, // Placeholder, updated in showFeedbackView.
             config.overlayFillBackgroundPaint,
             config.overlayTextColor,
             config.overlayTextSize
@@ -104,16 +104,16 @@ class SwipeControlsOverlayLayout(
                     topMargin = 20f.toDisplayPixels().toInt()
                 }
             }
-            visibility = GONE // Initially hidden
+            visibility = GONE // Initially hidden.
         }
         addView(horizontalProgressView)
 
-        // Initialize vertical progress bar for brightness (right side)
+        // Initialize vertical progress bar for brightness (right side).
         verticalBrightnessProgressView = VerticalProgressView(
             context,
             config.overlayBackgroundOpacity,
             config.overlayStyle.isMinimal,
-            config.overlayProgressColor,
+            config.overlayBrightnessProgressColor,
             config.overlayFillBackgroundPaint,
             config.overlayTextColor,
             config.overlayTextSize
@@ -123,16 +123,16 @@ class SwipeControlsOverlayLayout(
                 rightMargin = 40f.toDisplayPixels().toInt()
                 addRule(CENTER_VERTICAL)
             }
-            visibility = GONE // Initially hidden
+            visibility = GONE // Initially hidden.
         }
         addView(verticalBrightnessProgressView)
 
-        // Initialize vertical progress bar for volume (left side)
+        // Initialize vertical progress bar for volume (left side).
         verticalVolumeProgressView = VerticalProgressView(
             context,
             config.overlayBackgroundOpacity,
             config.overlayStyle.isMinimal,
-            config.overlayProgressColor,
+            config.overlayVolumeProgressColor,
             config.overlayFillBackgroundPaint,
             config.overlayTextColor,
             config.overlayTextSize
@@ -142,12 +142,12 @@ class SwipeControlsOverlayLayout(
                 leftMargin = 40f.toDisplayPixels().toInt()
                 addRule(CENTER_VERTICAL)
             }
-            visibility = GONE // Initially hidden
+            visibility = GONE // Initially hidden.
         }
         addView(verticalVolumeProgressView)
     }
 
-    // Handler and callback for hiding progress bars
+    // Handler and callback for hiding progress bars.
     private val feedbackHideHandler = Handler(Looper.getMainLooper())
     private val feedbackHideCallback = Runnable {
         circularProgressView.visibility = GONE
@@ -165,29 +165,42 @@ class SwipeControlsOverlayLayout(
 
         val viewToShow = when {
             config.overlayStyle.isCircular -> circularProgressView
-            config.overlayStyle.isVertical -> if (isBrightness) verticalBrightnessProgressView else verticalVolumeProgressView
+            config.overlayStyle.isVertical ->
+                if (isBrightness)
+                    verticalBrightnessProgressView
+                else
+                    verticalVolumeProgressView
             else -> horizontalProgressView
         }
         viewToShow.apply {
+            // Set the appropriate progress color.
+            if (this is CircularProgressView || this is HorizontalProgressView) {
+                setProgressColor(
+                    if (isBrightness)
+                        config.overlayBrightnessProgressColor
+                    else
+                        config.overlayVolumeProgressColor
+                )
+            }
             setProgress(progress, max, value, isBrightness)
             this.icon = icon
             visibility = VISIBLE
         }
     }
 
-    // Handle volume change
+    // Handle volume change.
     override fun onVolumeChanged(newVolume: Int, maximumVolume: Int) {
         val volumePercentage = (newVolume.toFloat() / maximumVolume) * 100
         val icon = when {
             newVolume == 0 -> mutedVolumeIcon
-            volumePercentage < 33 -> lowVolumeIcon
+            volumePercentage < 25 -> lowVolumeIcon
-            volumePercentage < 66 -> normalVolumeIcon
+            volumePercentage < 50 -> normalVolumeIcon
             else -> fullVolumeIcon
         }
         showFeedbackView("$newVolume", newVolume, maximumVolume, icon, isBrightness = false)
     }
 
-    // Handle brightness change
+    // Handle brightness change.
     override fun onBrightnessChanged(brightness: Double) {
         if (config.shouldLowestValueEnableAutoBrightness && brightness <= 0) {
             val displayText = if (config.overlayStyle.isVertical) "А"
@@ -195,18 +208,19 @@ class SwipeControlsOverlayLayout(
             showFeedbackView(displayText, 0, 100, autoBrightnessIcon, isBrightness = true)
         } else {
             val brightnessValue = round(brightness).toInt()
+            val clampedProgress = max(0, brightnessValue)
             val icon = when {
-                brightnessValue < 25 -> lowBrightnessIcon
+                clampedProgress < 25 -> lowBrightnessIcon
-                brightnessValue < 50 -> mediumBrightnessIcon
+                clampedProgress < 50 -> mediumBrightnessIcon
-                brightnessValue < 75 -> highBrightnessIcon
+                clampedProgress < 75 -> highBrightnessIcon
                 else -> fullBrightnessIcon
             }
-            val displayText = if (config.overlayStyle.isVertical) "$brightnessValue" else "$brightnessValue%"
+            val displayText = if (config.overlayStyle.isVertical) "$clampedProgress" else "$clampedProgress%"
-            showFeedbackView(displayText, brightnessValue, 100, icon, isBrightness = true)
+            showFeedbackView(displayText, clampedProgress, 100, icon, isBrightness = true)
         }
     }
 
-    // Begin swipe session
+    // Begin swipe session.
     override fun onEnterSwipeSession() {
         if (config.shouldEnableHapticFeedback) {
             @Suppress("DEPRECATION")
@@ -233,25 +247,41 @@ abstract class AbstractProgressView(
     defStyleAttr: Int = 0
 ) : View(context, attrs, defStyleAttr) {
 
-    // Combined paint creation function for both fill and stroke styles
+    // Combined paint creation function for both fill and stroke styles.
-    private fun createPaint(color: Int, style: Paint.Style = Paint.Style.FILL, strokeCap: Paint.Cap = Paint.Cap.BUTT, strokeWidth: Float = 0f) = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    private fun createPaint(
+        color: Int,
+        style: Paint.Style = Paint.Style.FILL,
+        strokeCap: Paint.Cap = Paint.Cap.BUTT,
+        strokeWidth: Float = 0f
+    ) = Paint(Paint.ANTI_ALIAS_FLAG).apply {
         this.style = style
         this.color = color
         this.strokeCap = strokeCap
         this.strokeWidth = strokeWidth
     }
 
-    // Initialize paints
+    // Initialize paints.
-    val backgroundPaint     = createPaint(overlayBackgroundOpacity,   style = Paint.Style.FILL)
+    val backgroundPaint = createPaint(
-    val progressPaint       = createPaint(overlayProgressColor,       style = Paint.Style.STROKE, strokeCap = Paint.Cap.ROUND, strokeWidth = 6f.toDisplayPixels())
+        overlayBackgroundOpacity,
-    val fillBackgroundPaint = createPaint(overlayFillBackgroundPaint, style = Paint.Style.FILL)
+        style = Paint.Style.FILL
-    val textPaint           = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    )
-        color     = overlayTextColor
+    val progressPaint = createPaint(
+        overlayProgressColor,
+        style = Paint.Style.STROKE,
+        strokeCap = Paint.Cap.ROUND,
+        strokeWidth = 6f.toDisplayPixels()
+    )
+    val fillBackgroundPaint = createPaint(
+        overlayFillBackgroundPaint,
+        style = Paint.Style.FILL
+    )
+    val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        color = overlayTextColor
         textAlign = Paint.Align.CENTER
-        textSize  = overlayTextSize.toFloat().toDisplayPixels()
+        textSize = overlayTextSize.toFloat().toDisplayPixels()
     }
 
-    // Rect for text measurement
+    // Rect for text measurement.
     protected val textBounds = Rect()
 
     protected var progress = 0
@@ -268,13 +298,18 @@ abstract class AbstractProgressView(
         invalidate()
     }
 
+    fun setProgressColor(color: Int) {
+        progressPaint.color = color
+        invalidate()
+    }
+
     protected fun measureTextWidth(text: String, paint: Paint): Int {
         paint.getTextBounds(text, 0, text.length, textBounds)
         return textBounds.width()
     }
 
     override fun onDraw(canvas: Canvas) {
-        // Base class implementation can be empty
+        // Base class implementation can be empty.
     }
 }
 
@@ -393,8 +428,8 @@ class HorizontalProgressView(
     }
 
     /**
-     * Calculate required width based on content
+     * Calculate required width based on content.
-     * @return Required width to display all elements
+     * @return Required width to display all elements.
      */
     private fun calculateRequiredWidth(): Float {
         textWidth = measureTextWidth(displayText, textPaint).toFloat()
@@ -537,8 +572,8 @@ class VerticalProgressView(
     }
 
     /**
-     * Calculate required height based on content
+     * Calculate required height based on content.
-     * @return Required height to display all elements
+     * @return Required height to display all elements.
      */
     private fun calculateRequiredHeight(): Float {
         return if (!isMinimalStyle) {

extensions/youtube/src/main/java/app/revanced/extension/youtube/videoplayer/PlaybackSpeedDialogButton.java

@@ -5,9 +5,13 @@ import android.view.View;
 import androidx.annotation.Nullable;
 
 import app.revanced.extension.shared.Logger;
+import app.revanced.extension.youtube.patches.VideoInformation;
 import app.revanced.extension.youtube.patches.playback.speed.CustomPlaybackSpeedPatch;
 import app.revanced.extension.youtube.settings.Settings;
 
+import static app.revanced.extension.shared.StringRef.str;
+import static app.revanced.extension.shared.Utils.showToastShort;
+
 @SuppressWarnings("unused")
 public class PlaybackSpeedDialogButton {
     @Nullable
@@ -23,8 +27,27 @@ public class PlaybackSpeedDialogButton {
                     "revanced_playback_speed_dialog_button",
                     "revanced_playback_speed_dialog_button_placeholder",
                     Settings.PLAYBACK_SPEED_DIALOG_BUTTON::get,
-                    view -> CustomPlaybackSpeedPatch.showOldPlaybackSpeedMenu(),
+                    view -> {
-                    null
+                        try {
+                            CustomPlaybackSpeedPatch.showModernCustomPlaybackSpeedDialog(view.getContext());
+                        } catch (Exception ex) {
+                            Logger.printException(() -> "speed button onClick failure", ex);
+                        }
+                    },
+                    view -> {
+                        try {
+                            final float speed = (!Settings.REMEMBER_PLAYBACK_SPEED_LAST_SELECTED.get() ||
+                                    VideoInformation.getPlaybackSpeed() == Settings.PLAYBACK_SPEED_DEFAULT.get())
+                                    ? 1.0f
+                                    : Settings.PLAYBACK_SPEED_DEFAULT.get();
+
+                            VideoInformation.overridePlaybackSpeed(speed);
+                            showToastShort(str("revanced_custom_playback_speeds_reset_toast", (speed + "x")));
+                        } catch (Exception ex) {
+                            Logger.printException(() -> "speed button reset failure", ex);
+                        }
+                        return true;
+                    }
             );
         } catch (Exception ex) {
             Logger.printException(() -> "initializeButton failure", ex);

gradle.properties

@@ -3,4 +3,4 @@ org.gradle.jvmargs = -Xms512M -Xmx2048M
 org.gradle.parallel = true
 android.useAndroidX = true
 kotlin.code.style = official
-version = 5.25.0-dev.3
+version = 5.26.0-dev.5

package-lock.json

@@ -9,7 +9,7 @@
         "@semantic-release/changelog": "^6.0.3",
         "@semantic-release/git": "^10.0.1",
         "gradle-semantic-release-plugin": "^1.10.1",
-        "semantic-release": "^24.2.1"
+        "semantic-release": "^24.2.5"
       }
     },
     "node_modules/@babel/code-frame": {
@@ -1964,9 +1964,9 @@
       }
     },
     "node_modules/chalk": {
-      "version": "5.3.0",
+      "version": "5.4.1",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz",
-      "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+      "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3460,9 +3460,9 @@
       "license": "ISC"
     },
     "node_modules/marked": {
-      "version": "12.0.2",
+      "version": "15.0.12",
-      "resolved": "https://registry.npmjs.org/marked/-/marked-12.0.2.tgz",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-15.0.12.tgz",
-      "integrity": "sha512-qXUm7e/YKFoqFPYPa3Ukg9xlI5cyAtGmyEIzMfW//m6kXwCy2Ps9DYf5ioijFKQ8qyuscrHoY04iJGctu2Kg0Q==",
+      "integrity": "sha512-8dD6FusOQSrpv9Z1rdNMdlSgQOIP880DHqnohobOmYLElGEqAL/JvxvuxZO16r4HtjTlfPRDC1hbvxC9dPN2nA==",
       "dev": true,
       "license": "MIT",
       "bin": {
@@ -3473,24 +3473,38 @@
       }
     },
     "node_modules/marked-terminal": {
-      "version": "7.1.0",
+      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/marked-terminal/-/marked-terminal-7.1.0.tgz",
+      "resolved": "https://registry.npmjs.org/marked-terminal/-/marked-terminal-7.3.0.tgz",
-      "integrity": "sha512-+pvwa14KZL74MVXjYdPR3nSInhGhNvPce/3mqLVZT2oUvt654sL1XImFuLZ1pkA866IYZ3ikDTOFUIC7XzpZZg==",
+      "integrity": "sha512-t4rBvPsHc57uE/2nJOLmMbZCQ4tgAccAED3ngXQqW6g+TxA488JzJ+FK3lQkzBQOI1mRV/r/Kq+1ZlJ4D0owQw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "ansi-escapes": "^7.0.0",
-        "chalk": "^5.3.0",
+        "ansi-regex": "^6.1.0",
+        "chalk": "^5.4.1",
         "cli-highlight": "^2.1.11",
         "cli-table3": "^0.6.5",
-        "node-emoji": "^2.1.3",
+        "node-emoji": "^2.2.0",
-        "supports-hyperlinks": "^3.0.0"
+        "supports-hyperlinks": "^3.1.0"
       },
       "engines": {
         "node": ">=16.0.0"
       },
       "peerDependencies": {
-        "marked": ">=1 <14"
+        "marked": ">=1 <16"
+      }
+    },
+    "node_modules/marked-terminal/node_modules/ansi-regex": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
       }
     },
     "node_modules/meow": {
@@ -3607,9 +3621,9 @@
       "license": "MIT"
     },
     "node_modules/node-emoji": {
-      "version": "2.1.3",
+      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-2.1.3.tgz",
+      "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-2.2.0.tgz",
-      "integrity": "sha512-E2WEOVsgs7O16zsURJ/eH8BqhF029wGpEOnv7Urwdo2wmQanOACwJQh0devF9D9RhoZru0+9JXIS0dBXIAz+lA==",
+      "integrity": "sha512-Z3lTE9pLaJF47NyMhd4ww1yFTAP8YhYI8SleJiHzM46Fgpm5cnNzSl9XfzFNqbaz+VlJrIj3fXQ4DeN1Rjm6cw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -6760,9 +6774,9 @@
       "license": "MIT"
     },
     "node_modules/semantic-release": {
-      "version": "24.2.1",
+      "version": "24.2.5",
-      "resolved": "https://registry.npmjs.org/semantic-release/-/semantic-release-24.2.1.tgz",
+      "resolved": "https://registry.npmjs.org/semantic-release/-/semantic-release-24.2.5.tgz",
-      "integrity": "sha512-z0/3cutKNkLQ4Oy0HTi3lubnjTsdjjgOqmxdPjeYWe6lhFqUPfwslZxRHv3HDZlN4MhnZitb9SLihDkZNxOXfQ==",
+      "integrity": "sha512-9xV49HNY8C0/WmPWxTlaNleiXhWb//qfMzG2c5X8/k7tuWcu8RssbuS+sujb/h7PiWSXv53mrQvV9hrO9b7vuQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -6784,8 +6798,8 @@
         "hosted-git-info": "^8.0.0",
         "import-from-esm": "^2.0.0",
         "lodash-es": "^4.17.21",
-        "marked": "^12.0.0",
+        "marked": "^15.0.0",
-        "marked-terminal": "^7.0.0",
+        "marked-terminal": "^7.3.0",
         "micromatch": "^4.0.2",
         "p-each-series": "^3.0.0",
         "p-reduce": "^3.0.0",

package.json

@@ -4,6 +4,6 @@
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "gradle-semantic-release-plugin": "^1.10.1",
-    "semantic-release": "^24.2.1"
+    "semantic-release": "^24.2.5"
   }
 }

patches/api/patches.api

@@ -296,6 +296,10 @@ public final class app/revanced/patches/messenger/navbar/RemoveMetaAITabPatchKt
 	public static final fun getRemoveMetaAITabPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
 
+public final class app/revanced/patches/meta/ads/HideAdsPatchKt {
+	public static final fun getHideAdsPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
+}
+
 public final class app/revanced/patches/mifitness/misc/locale/ForceEnglishLocalePatchKt {
 	public static final fun getForceEnglishLocalePatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
@@ -440,6 +444,14 @@ public final class app/revanced/patches/primevideo/misc/extension/ExtensionPatch
 	public static final fun getSharedExtensionPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
 
+public final class app/revanced/patches/primevideo/misc/permissions/RenamePermissionsPatchKt {
+	public static final fun getRenamePermissionsPatch ()Lapp/revanced/patcher/patch/ResourcePatch;
+}
+
+public final class app/revanced/patches/protonmail/account/RemoveFreeAccountsLimitPatchKt {
+	public static final fun getRemoveFreeAccountsLimitPatch ()Lapp/revanced/patcher/patch/ResourcePatch;
+}
+
 public final class app/revanced/patches/protonmail/signature/RemoveSentFromSignaturePatchKt {
 	public static final fun getRemoveSentFromSignaturePatch ()Lapp/revanced/patcher/patch/ResourcePatch;
 }
@@ -581,6 +593,7 @@ public final class app/revanced/patches/reddit/layout/disablescreenshotpopup/Dis
 
 public final class app/revanced/patches/reddit/layout/premiumicon/UnlockPremiumIconPatchKt {
 	public static final fun getUnlockPremiumIconPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
+	public static final fun getUnlockPremiumIconsPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
 
 public final class app/revanced/patches/reddit/misc/extension/ExtensionPatchKt {
@@ -860,6 +873,10 @@ public final class app/revanced/patches/soundcloud/offlinesync/EnableOfflineSync
 	public static final fun getEnableOfflineSync ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
 
+public final class app/revanced/patches/spotify/layout/hide/createbutton/HideCreateButtonPatchKt {
+	public static final fun getHideCreateButtonPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
+}
+
 public final class app/revanced/patches/spotify/layout/theme/CustomThemePatchKt {
 	public static final fun getCustomThemePatch ()Lapp/revanced/patcher/patch/ResourcePatch;
 }
@@ -884,6 +901,10 @@ public final class app/revanced/patches/spotify/misc/fix/SpoofSignaturePatchKt {
 	public static final fun getSpoofSignaturePatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
 
+public final class app/revanced/patches/spotify/misc/fix/login/FixFacebookLoginPatchKt {
+	public static final fun getFixFacebookLoginPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
+}
+
 public final class app/revanced/patches/spotify/misc/privacy/SanitizeSharingLinksPatchKt {
 	public static final fun getSanitizeSharingLinksPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
@@ -1395,6 +1416,10 @@ public final class app/revanced/patches/youtube/misc/gms/GmsCoreSupportPatchKt {
 	public static final fun getGmsCoreSupportPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
 
+public final class app/revanced/patches/youtube/misc/hapticfeedback/DisableHapticFeedbackPatchKt {
+	public static final fun getDisableHapticFeedbackPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
+}
+
 public final class app/revanced/patches/youtube/misc/imageurlhook/CronetImageUrlHookKt {
 	public static final fun addImageUrlErrorCallbackHook (Ljava/lang/String;)V
 	public static final fun addImageUrlHook (Ljava/lang/String;Z)V
@@ -1644,7 +1669,6 @@ public final class app/revanced/util/BytecodeUtilsKt {
 	public static final fun returnLate (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;J)V
 	public static final fun returnLate (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;S)V
 	public static final fun returnLate (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;Z)V
-	public static synthetic fun returnLate$default (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableMethod;ZILjava/lang/Object;)V
 	public static final fun transformMethods (Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;Lkotlin/jvm/functions/Function1;)V
 	public static final fun traverseClassHierarchy (Lapp/revanced/patcher/patch/BytecodePatchContext;Lapp/revanced/patcher/util/proxy/mutableTypes/MutableClass;Lkotlin/jvm/functions/Function1;)V
 }

patches/src/main/kotlin/app/revanced/patches/all/misc/adb/HideAdbPatch.kt

@@ -47,7 +47,7 @@ val hideAdbStatusPatch = bytecodePatch(
                     .takeIf { it.opcode == Opcode.INVOKE_STATIC }
                     ?.getReference<MethodReference>()
                     ?.takeIf {
-                        it.anyMethodSignatureMatches(it,
+                        it.anyMethodSignatureMatches(
                             SETTINGS_GLOBAL_GET_INT_OR_THROW_METHOD_REFERENCE,
                             SETTINGS_GLOBAL_GET_INT_OR_DEFAULT_METHOD_REFERENCE
                         )

patches/src/main/kotlin/app/revanced/patches/all/misc/build/SpoofBuildInfoPatch.kt

@@ -7,7 +7,7 @@ import app.revanced.patcher.patch.stringOption
 @Suppress("unused")
 val spoofBuildInfoPatch = bytecodePatch(
     name = "Spoof build info",
-    description = "Spoof the information about the current build.",
+    description = "Spoofs the information about the current build.",
     use = false,
 ) {
     val board by stringOption(
@@ -141,14 +141,14 @@ val spoofBuildInfoPatch = bytecodePatch(
     val socManufacturer by stringOption(
         key = "soc-manufacturer",
         default = null,
-        title = "SOC Manufacturer",
+        title = "SOC manufacturer",
         description = "The manufacturer of the device's primary system-on-chip.",
     )
 
     val socModel by stringOption(
         key = "soc-model",
         default = null,
-        title = "SOC Model",
+        title = "SOC model",
         description = "The model name of the device's primary system-on-chip.",
     )
 

patches/src/main/kotlin/app/revanced/patches/all/misc/connectivity/telephony/sim/spoof/SpoofSimCountryPatch.kt

@@ -36,12 +36,12 @@ val spoofSimCountryPatch = bytecodePatch(
 
     val networkCountryIso by isoCountryPatchOption(
         "networkCountryIso",
-        "Network ISO Country Code",
+        "Network ISO country code",
     )
 
     val simCountryIso by isoCountryPatchOption(
         "simCountryIso",
-        "Sim ISO Country Code",
+        "SIM ISO country code",
     )
 
     dependsOn(

patches/src/main/kotlin/app/revanced/patches/instagram/ads/HideAdsPatch.kt

@@ -1,23 +1,9 @@
 package app.revanced.patches.instagram.ads
 
-import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
 import app.revanced.patcher.patch.bytecodePatch
 
+@Deprecated("Patch was moved to different package: app.revanced.patches.meta.ads.hideAdsPatch")
 @Suppress("unused")
-val hideAdsPatch = bytecodePatch(
+val hideAdsPatch = bytecodePatch {
-    name = "Hide ads",
+    dependsOn(app.revanced.patches.meta.ads.hideAdsPatch)
-    description = "Hides ads in stories, discover, profile, etc. " +
-        "An ad can still appear once when refreshing the home feed.",
-) {
-    compatibleWith("com.instagram.android")
-
-    execute {
-        adInjectorFingerprint.method.addInstructions(
-            0,
-            """
-                const/4 v0, 0x0
-                return v0
-            """,
-        )
-    }
 }

patches/src/main/kotlin/app/revanced/patches/lightroom/misc/premium/UnlockPremiumPatch.kt

@@ -5,7 +5,7 @@ import app.revanced.patcher.patch.bytecodePatch
 
 @Suppress("unused")
 val unlockPremiumPatch = bytecodePatch(
-    name = "Unlock premium",
+    name = "Unlock Premium",
 ) {
     compatibleWith("com.adobe.lrmobile"("10.0.2"))
 

patches/src/main/kotlin/app/revanced/patches/messenger/inputfield/DisableSwitchingEmojiToStickerPatch.kt

@@ -5,9 +5,14 @@ import app.revanced.patcher.extensions.InstructionExtensions.replaceInstruction
 import app.revanced.patcher.patch.bytecodePatch
 import com.android.tools.smali.dexlib2.iface.instruction.OneRegisterInstruction
 
+/**
+ * This patch will be deleted soon.
+ *
+ * Pull requests to update this patch to the latest app target are invited.
+ */
+@Deprecated("This patch only works with an outdated app target that is no longer fully supported by Facebook.")
 @Suppress("unused")
 val disableSwitchingEmojiToStickerPatch = bytecodePatch(
-    name = "Disable switching emoji to sticker",
     description = "Disables switching from emoji to sticker search mode in message input field.",
 ) {
     compatibleWith("com.facebook.orca"("439.0.0.29.119"))

patches/src/main/kotlin/app/revanced/patches/meta/ads/Fingerprints.kt

@@ -1,4 +1,4 @@
-package app.revanced.patches.instagram.ads
+package app.revanced.patches.meta.ads
 
 import app.revanced.patcher.fingerprint
 import com.android.tools.smali.dexlib2.AccessFlags

patches/src/main/kotlin/app/revanced/patches/meta/ads/HideAdsPatch.kt

@@ -0,0 +1,21 @@
+package app.revanced.patches.meta.ads
+
+import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.util.returnEarly
+
+@Suppress("unused")
+val hideAdsPatch = bytecodePatch(
+    name = "Hide ads",
+) {
+    /**
+     * Patch is identical for both Instagram and Threads app.
+     */
+    compatibleWith(
+        "com.instagram.android",
+        "com.instagram.barcelona",
+    )
+
+    execute {
+        adInjectorFingerprint.method.returnEarly(false)
+    }
+}

patches/src/main/kotlin/app/revanced/patches/primevideo/misc/permissions/RenamePermissionsPatch.kt

@@ -0,0 +1,44 @@
+package app.revanced.patches.primevideo.misc.permissions
+
+import app.revanced.patcher.patch.PatchException
+import app.revanced.patcher.patch.resourcePatch
+import app.revanced.util.asSequence
+import app.revanced.util.getNode
+import org.w3c.dom.Element
+
+@Suppress("unused")
+val renamePermissionsPatch = resourcePatch(
+    name = "Rename shared permissions",
+    description = "Rename certain permissions shared across Amazon apps. " +
+            "Applying this patch can fix installation errors, but can also break features in certain apps.",
+    use = false
+) {
+    compatibleWith("com.amazon.avod.thirdpartyclient")
+
+    val permissionNames = setOf(
+        "com.amazon.identity.permission.CAN_CALL_MAP_INFORMATION_PROVIDER",
+        "com.amazon.identity.auth.device.perm.AUTH_SDK",
+        "com.amazon.dcp.sso.permission.account.changed",
+        "com.amazon.dcp.sso.permission.AmazonAccountPropertyService.property.changed",
+        "com.amazon.identity.permission.CALL_AMAZON_DEVICE_INFORMATION_PROVIDER",
+        "com.amazon.appmanager.preload.permission.READ_PRELOAD_DEVICE_INFO_PROVIDER"
+    )
+
+    execute {
+        document("AndroidManifest.xml").use { document ->
+            val manifest = document.getNode("manifest") as Element
+
+            val permissions = manifest
+                .getElementsByTagName("permission")
+                .asSequence()
+                .map { Pair(it as Element, it.getAttribute("android:name")) }
+                .filter { (_, name) -> name in permissionNames }
+
+            if (permissions.none()) throw PatchException("Could not find any permissions to rename")
+
+            permissions.forEach { (element, name) ->
+                element.setAttribute("android:name", "revanced.$name")
+            }
+        }
+    }
+}

patches/src/main/kotlin/app/revanced/patches/protonmail/account/RemoveFreeAccountsLimitPatch.kt

@@ -0,0 +1,21 @@
+package app.revanced.patches.protonmail.account
+
+import app.revanced.patcher.patch.resourcePatch
+import app.revanced.util.findElementByAttributeValueOrThrow
+
+@Suppress("unused")
+val removeFreeAccountsLimitPatch = resourcePatch(
+    name = "Remove free accounts limit",
+    description = "Removes the limit for maximum free accounts logged in.",
+) {
+    compatibleWith("ch.protonmail.android")
+
+    execute {
+        document("res/values/integers.xml").use { document ->
+            document.documentElement.childNodes.findElementByAttributeValueOrThrow(
+                "name",
+                "core_feature_auth_user_check_max_free_user_count",
+            ).textContent = Int.MAX_VALUE.toString()
+        }
+    }
+}

patches/src/main/kotlin/app/revanced/patches/reddit/layout/premiumicon/UnlockPremiumIconPatch.kt

@@ -4,9 +4,9 @@ import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
 import app.revanced.patcher.patch.bytecodePatch
 
 @Suppress("unused")
-val unlockPremiumIconPatch = bytecodePatch(
+val unlockPremiumIconsPatch = bytecodePatch(
-    name = "Unlock premium Reddit icons",
+    name = "Unlock Premium icons",
-    description = "Unlocks the premium Reddit icons.",
+    description = "Unlocks the Reddit Premium icons.",
 ) {
     compatibleWith("com.reddit.frontpage")
 
@@ -20,3 +20,9 @@ val unlockPremiumIconPatch = bytecodePatch(
         )
     }
 }
+
+@Deprecated("Patch was renamed", ReplaceWith("unlockPremiumIconsPatch"))
+@Suppress("unused")
+val unlockPremiumIconPatch = bytecodePatch{
+    dependsOn(unlockPremiumIconsPatch)
+}

patches/src/main/kotlin/app/revanced/patches/shared/misc/gms/GmsCoreSupportPatch.kt

@@ -198,7 +198,7 @@ fun gmsCoreSupportPatch(
 
         // Google Play Utility is not present in all apps, so we need to check if it's present.
         if (googlePlayUtilityFingerprint.methodOrNull != null) {
-            googlePlayUtilityFingerprint.method.returnEarly()
+            googlePlayUtilityFingerprint.method.returnEarly(0)
         }
 
         // Verify GmsCore is installed and whitelisted for power optimizations and background usage.

patches/src/main/kotlin/app/revanced/patches/shared/misc/pairip/license/DisableLicenseCheckPatch.kt

@@ -8,7 +8,7 @@ import java.util.logging.Logger
 @Suppress("unused")
 val disableLicenseCheckPatch = bytecodePatch(
     name = "Disable Pairip license check",
-    description = "Disable Play Integrity Protect (Pairip) client-side license check.",
+    description = "Disables Play Integrity API (Pairip) client-side license check.",
     use = false
 ) {
 

patches/src/main/kotlin/app/revanced/patches/spotify/layout/hide/createbutton/Fingerprints.kt

@@ -0,0 +1,28 @@
+package app.revanced.patches.spotify.layout.hide.createbutton
+
+import app.revanced.patcher.fingerprint
+import app.revanced.util.getReference
+import app.revanced.util.indexOfFirstInstruction
+import com.android.tools.smali.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.iface.reference.MethodReference
+
+internal val navigationBarItemSetClassFingerprint = fingerprint {
+    strings("NavigationBarItemSet(")
+}
+
+internal val navigationBarItemSetConstructorFingerprint = fingerprint {
+    accessFlags(AccessFlags.PUBLIC, AccessFlags.CONSTRUCTOR)
+    // Make sure the method checks whether navigation bar items are null before adding them.
+    // If this is not true, then we cannot patch the method and potentially transform the parameters into null.
+    opcodes(Opcode.IF_EQZ, Opcode.INVOKE_VIRTUAL)
+    custom { method, _ ->
+        method.indexOfFirstInstruction {
+            getReference<MethodReference>()?.name == "add"
+        } >= 0
+    }
+}
+
+internal val oldNavigationBarAddItemFingerprint = fingerprint {
+    strings("Bottom navigation tabs exceeds maximum of 5 tabs")
+}

patches/src/main/kotlin/app/revanced/patches/spotify/layout/hide/createbutton/HideCreateButtonPatch.kt

@@ -0,0 +1,110 @@
+package app.revanced.patches.spotify.layout.hide.createbutton
+
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
+import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
+import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.patcher.util.smali.ExternalLabel
+import app.revanced.patches.spotify.misc.extension.sharedExtensionPatch
+import app.revanced.patches.spotify.shared.IS_SPOTIFY_LEGACY_APP_TARGET
+import app.revanced.util.getReference
+import app.revanced.util.indexOfFirstInstructionOrThrow
+import com.android.tools.smali.dexlib2.iface.instruction.FiveRegisterInstruction
+import com.android.tools.smali.dexlib2.iface.reference.MethodReference
+import java.util.logging.Logger
+
+private const val EXTENSION_CLASS_DESCRIPTOR =
+    "Lapp/revanced/extension/spotify/layout/hide/createbutton/HideCreateButtonPatch;"
+
+@Suppress("unused")
+val hideCreateButtonPatch = bytecodePatch(
+    name = "Hide Create button",
+    description = "Hides the \"Create\" button in the navigation bar."
+) {
+    compatibleWith("com.spotify.music")
+
+    dependsOn(sharedExtensionPatch)
+
+    execute {
+        if (IS_SPOTIFY_LEGACY_APP_TARGET) {
+            Logger.getLogger(this::class.java.name).warning(
+                "Create button does not exist in legacy app target.  No changes applied."
+            )
+            return@execute
+        }
+
+        val oldNavigationBarAddItemMethod = oldNavigationBarAddItemFingerprint.originalMethodOrNull
+        // Only throw the fingerprint error when oldNavigationBarAddItemMethod does not exist.
+        val navigationBarItemSetClassDef = if (oldNavigationBarAddItemMethod == null) {
+            navigationBarItemSetClassFingerprint.originalClassDef
+        } else {
+            navigationBarItemSetClassFingerprint.originalClassDefOrNull
+        }
+
+        if (navigationBarItemSetClassDef != null) {
+            // Main patch for newest and most versions.
+            // The NavigationBarItemSet constructor accepts multiple parameters which represent each navigation bar item.
+            // Each item is manually checked whether it is not null and then added to a LinkedHashSet.
+            // Since the order of the items can differ, we are required to check every parameter to see whether it is the
+            // Create button. So, for every parameter passed to the method, invoke our extension method and overwrite it
+            // to null in case it is the Create button.
+            navigationBarItemSetConstructorFingerprint.match(navigationBarItemSetClassDef).method.apply {
+                // Add 1 to the index because the first parameter register is `this`.
+                val parameterTypesWithRegister = parameterTypes.mapIndexed { index, parameterType ->
+                    parameterType to (index + 1)
+                }
+
+                val returnNullIfIsCreateButtonDescriptor =
+                    "$EXTENSION_CLASS_DESCRIPTOR->returnNullIfIsCreateButton(Ljava/lang/Object;)Ljava/lang/Object;"
+
+                parameterTypesWithRegister.reversed().forEach { (parameterType, parameterRegister) ->
+                    addInstructions(
+                        0,
+                        """
+                            invoke-static { p$parameterRegister }, $returnNullIfIsCreateButtonDescriptor
+                            move-result-object p$parameterRegister
+                            check-cast p$parameterRegister, $parameterType
+                        """
+                    )
+                }
+            }
+        }
+
+        if (oldNavigationBarAddItemMethod != null) {
+            // In case an older version of the app is being patched, hook the old method which adds navigation bar items.
+            // Return null early if the navigation bar item title resource id is old Create button title resource id.
+            oldNavigationBarAddItemFingerprint.methodOrNull?.apply {
+                val getNavigationBarItemTitleStringIndex = indexOfFirstInstructionOrThrow {
+                    val reference = getReference<MethodReference>()
+                    reference?.definingClass == "Landroid/content/res/Resources;" && reference.name == "getString"
+                }
+                // This register is a parameter register, so it can be used at the start of the method when adding
+                // the new instructions.
+                val oldNavigationBarItemTitleResIdRegister =
+                    getInstruction<FiveRegisterInstruction>(getNavigationBarItemTitleStringIndex).registerD
+
+                // The instruction where the normal method logic starts.
+                val firstInstruction = getInstruction(0)
+
+                val isOldCreateButtonDescriptor =
+                    "$EXTENSION_CLASS_DESCRIPTOR->isOldCreateButton(I)Z"
+
+                addInstructionsWithLabels(
+                    0,
+                    """
+                        invoke-static { v$oldNavigationBarItemTitleResIdRegister }, $isOldCreateButtonDescriptor
+                        move-result v0
+                        
+                        # If this navigation bar item is not the Create button, jump to the normal method logic.
+                        if-eqz v0, :normal-method-logic
+                        
+                        # Return null early because this method return value is a BottomNavigationItemView.
+                        const/4 v0, 0
+                        return-object v0
+                    """,
+                    ExternalLabel("normal-method-logic", firstInstruction)
+                )
+            }
+        }
+    }
+}

patches/src/main/kotlin/app/revanced/patches/spotify/layout/theme/CustomThemePatch.kt

@@ -2,65 +2,19 @@ package app.revanced.patches.spotify.layout.theme
 
 import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
 import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
-import app.revanced.patcher.fingerprint
 import app.revanced.patcher.patch.booleanOption
 import app.revanced.patcher.patch.bytecodePatch
 import app.revanced.patcher.patch.resourcePatch
 import app.revanced.patcher.patch.stringOption
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import app.revanced.patches.spotify.misc.extension.IS_SPOTIFY_LEGACY_APP_TARGET
 import app.revanced.patches.spotify.misc.extension.sharedExtensionPatch
+import app.revanced.patches.spotify.shared.IS_SPOTIFY_LEGACY_APP_TARGET
 import app.revanced.util.*
-import com.android.tools.smali.dexlib2.AccessFlags
-import com.android.tools.smali.dexlib2.Opcode
 import com.android.tools.smali.dexlib2.iface.instruction.OneRegisterInstruction
-import com.android.tools.smali.dexlib2.iface.reference.FieldReference
+import com.android.tools.smali.dexlib2.iface.reference.MethodReference
 import org.w3c.dom.Element
 
 private const val EXTENSION_CLASS_DESCRIPTOR = "Lapp/revanced/extension/spotify/layout/theme/CustomThemePatch;"
 
-internal val spotifyBackgroundColor = stringOption(
-    key = "backgroundColor",
-    default = "@android:color/black",
-    title = "Primary background color",
-    description = "The background color. Can be a hex color or a resource reference.",
-    required = true,
-)
-
-internal val overridePlayerGradientColor = booleanOption(
-    key = "overridePlayerGradientColor",
-    default = false,
-    title = "Override player gradient color",
-    description = "Apply primary background color to the player gradient color, which changes dynamically with the song.",
-    required = false
-)
-
-internal val spotifyBackgroundColorSecondary = stringOption(
-    key = "backgroundColorSecondary",
-    default = "#FF121212",
-    title = "Secondary background color",
-    description =
-        "The secondary background color. (e.g. playlist list in home, player artist, song credits). Can be a hex color or a resource reference.",
-    required = true,
-)
-
-internal val spotifyAccentColor = stringOption(
-    key = "accentColor",
-    default = "#FF1ED760",
-    title = "Accent color",
-    description = "The accent color ('Spotify green' by default). Can be a hex color or a resource reference.",
-    required = true,
-)
-
-internal val spotifyAccentColorPressed = stringOption(
-    key = "accentColorPressed",
-    default = "#FF169C46",
-    title = "Pressed dark theme accent color",
-    description =
-        "The color when accented buttons are pressed, by default slightly darker than accent. Can be a hex color or a resource reference.",
-    required = true,
-)
-
 private val customThemeBytecodePatch = bytecodePatch {
     dependsOn(sharedExtensionPatch)
 
@@ -71,60 +25,60 @@ private val customThemeBytecodePatch = bytecodePatch {
             return@execute
         }
 
-        fun MutableMethod.addColorChangeInstructions(literal: Long, colorString: String) {
+        val colorSpaceUtilsClassDef = colorSpaceUtilsClassFingerprint.originalClassDef
-            val index = indexOfFirstLiteralInstructionOrThrow(literal)
+
-            val register = getInstruction<OneRegisterInstruction>(index).registerA
+        // Hook a util method that converts ARGB to RGBA in the sRGB color space to replace hardcoded accent colors.
+        convertArgbToRgbaFingerprint.match(colorSpaceUtilsClassDef).method.apply {
+            addInstructions(
+                0,
+                """
+                    long-to-int p0, p0
+                    invoke-static { p0 }, $EXTENSION_CLASS_DESCRIPTOR->replaceColor(I)I
+                    move-result p0
+                    int-to-long p0, p0
+                """
+            )
+        }
+
+        // Lottie JSON parser method. It parses the JSON Lottie animation into its own class,
+        // including the solid color of it.
+        parseLottieJsonFingerprint.method.apply {
+            val invokeParseColorIndex = indexOfFirstInstructionOrThrow {
+                val reference = getReference<MethodReference>()
+                reference?.definingClass == "Landroid/graphics/Color;"
+                        && reference.name == "parseColor"
+            }
+            val parsedColorRegister = getInstruction<OneRegisterInstruction>(invokeParseColorIndex + 1).registerA
+
+            val replaceColorDescriptor =  "$EXTENSION_CLASS_DESCRIPTOR->replaceColor(I)I"
 
             addInstructions(
-                index + 1,
+                invokeParseColorIndex + 2,
                 """
-                    const-string v$register, "$colorString"
+                    # Use invoke-static/range because the register number is too large.
-                    invoke-static { v$register }, $EXTENSION_CLASS_DESCRIPTOR->getThemeColor(Ljava/lang/String;)J
+                    invoke-static/range { v$parsedColorRegister .. v$parsedColorRegister }, $replaceColorDescriptor
-                    move-result-wide v$register
+                    move-result v$parsedColorRegister
                 """
             )
         }
 
-        val encoreColorsClassName = with(encoreThemeFingerprint.originalMethod) {
+        // Lottie animated color parser.
-            // "Encore" colors are referenced right before the value of POSITIVE_INFINITY is returned.
+        parseAnimatedColorFingerprint.method.apply {
-            // Begin the instruction find using the index of where POSITIVE_INFINITY is set into the register.
+            val invokeArgbIndex = indexOfFirstInstructionOrThrow {
-            val positiveInfinityIndex = indexOfFirstLiteralInstructionOrThrow(
+                val reference = getReference<MethodReference>()
-                Float.POSITIVE_INFINITY
+                reference?.definingClass == "Landroid/graphics/Color;"
-            )
+                        && reference.name == "argb"
-            val encoreColorsFieldReferenceIndex = indexOfFirstInstructionReversedOrThrow(
-                positiveInfinityIndex,
-                Opcode.SGET_OBJECT
-            )
-
-            getInstruction(encoreColorsFieldReferenceIndex)
-                .getReference<FieldReference>()!!.definingClass
-        }
-
-        val encoreColorsConstructorFingerprint = fingerprint {
-            accessFlags(AccessFlags.STATIC, AccessFlags.CONSTRUCTOR)
-            custom { method, classDef ->
-                classDef.type == encoreColorsClassName &&
-                        method.containsLiteralInstruction(PLAYLIST_BACKGROUND_COLOR_LITERAL)
             }
+            val argbColorRegister = getInstruction<OneRegisterInstruction>(invokeArgbIndex + 1).registerA
+
+            addInstructions(
+                invokeArgbIndex + 2,
+                """
+                    invoke-static { v$argbColorRegister }, $EXTENSION_CLASS_DESCRIPTOR->replaceColor(I)I
+                    move-result v$argbColorRegister
+                """
+            )
         }
-
-        val backgroundColor by spotifyBackgroundColor
-        val backgroundColorSecondary by spotifyBackgroundColorSecondary
-
-        encoreColorsConstructorFingerprint.method.apply {
-            addColorChangeInstructions(PLAYLIST_BACKGROUND_COLOR_LITERAL, backgroundColor!!)
-            addColorChangeInstructions(SHARE_MENU_BACKGROUND_COLOR_LITERAL, backgroundColorSecondary!!)
-        }
-
-        homeCategoryPillColorsFingerprint.method.addColorChangeInstructions(
-            HOME_CATEGORY_PILL_COLOR_LITERAL,
-            backgroundColorSecondary!!
-        )
-
-        settingsHeaderColorFingerprint.method.addColorChangeInstructions(
-            SETTINGS_HEADER_COLOR_LITERAL,
-            backgroundColorSecondary!!
-        )
     }
 }
 
@@ -138,11 +92,48 @@ val customThemePatch = resourcePatch(
 
     dependsOn(customThemeBytecodePatch)
 
-    val backgroundColor by spotifyBackgroundColor()
+    val backgroundColor by stringOption(
-    val overridePlayerGradientColor by overridePlayerGradientColor()
+        key = "backgroundColor",
-    val backgroundColorSecondary by spotifyBackgroundColorSecondary()
+        default = "@android:color/black",
-    val accentColor by spotifyAccentColor()
+        title = "Primary background color",
-    val accentColorPressed by spotifyAccentColorPressed()
+        description = "The background color. Can be a hex color or a resource reference.",
+        required = true,
+    )
+
+    val overridePlayerGradientColor by booleanOption(
+        key = "overridePlayerGradientColor",
+        default = false,
+        title = "Override player gradient color",
+        description =
+            "Apply primary background color to the player gradient color, which changes dynamically with the song.",
+        required = false,
+    )
+
+    val backgroundColorSecondary by stringOption(
+        key = "backgroundColorSecondary",
+        default = "#FF121212",
+        title = "Secondary background color",
+        description = "The secondary background color. (e.g. playlist list in home, player artist, song credits). " +
+                "Can be a hex color or a resource reference.\",",
+        required = true,
+    )
+
+    val accentColor by stringOption(
+        key = "accentColor",
+        default = "#FF1ED760",
+        title = "Accent color",
+        description = "The accent color ('Spotify green' by default). Can be a hex color or a resource reference.",
+        required = true,
+    )
+
+    val accentColorPressed by stringOption(
+        key = "accentColorPressed",
+        default = "#FF1ABC54",
+        title = "Pressed dark theme accent color",
+        description = "The color when accented buttons are pressed, by default slightly darker than accent. " +
+                "Can be a hex color or a resource reference.",
+        required = true,
+    )
 
     execute {
         document("res/values/colors.xml").use { document ->
@@ -161,34 +152,41 @@ val customThemePatch = resourcePatch(
                 }
 
                 node.textContent = when (name) {
+                    // Main background color.
+                    "gray_7",
+                    // Left sidebar background color in tablet mode.
+                    "gray_10",
                     // Gradient next to user photo and "All" in home page.
                     "dark_base_background_base",
-                    // Main background.
+                    // "Add account", "Settings and privacy", "View Profile" left sidebar background color.
-                    "gray_7",
-                    // Left sidebar background in tablet mode.
-                    "gray_10",
-                    // "Add account", "Settings and privacy", "View Profile" left sidebar background.
                     "dark_base_background_elevated_base",
                     // Song/player gradient start/end color.
                     "bg_gradient_start_color", "bg_gradient_end_color",
-                    // Login screen background and gradient start.
+                    // Login screen background color and gradient start.
                     "sthlm_blk", "sthlm_blk_grad_start",
                     // Misc.
                     "image_placeholder_color",
                         -> backgroundColor
 
-                    // Track credits, merch background in song player.
+                    // "About the artist" background color in song player.
+                    "gray_15",
+                    // Track credits, merch background color in song player.
                     "track_credits_card_bg", "benefit_list_default_color", "merch_card_background",
                     // Playlist list background in home page.
                     "opacity_white_10",
-                    // "About the artist" background in song player.
-                    "gray_15",
                     // "What's New" pills background.
                     "dark_base_background_tinted_highlight"
                         -> backgroundColorSecondary
 
-                    "dark_brightaccent_background_base", "dark_base_text_brightaccent", "green_light" -> accentColor
+                    "dark_brightaccent_background_base",
-                    "dark_brightaccent_background_press" -> accentColorPressed
+                    "dark_base_text_brightaccent",
+                    "green_light",
+                    "spotify_green_157"
+                        -> accentColor
+
+                    "dark_brightaccent_background_press"
+                        -> accentColorPressed
+
                     else -> continue
                 }
             }
@@ -198,8 +196,8 @@ val customThemePatch = resourcePatch(
         document("res/drawable/start_screen_gradient.xml").use { document ->
             val gradientNode = document.getElementsByTagName("gradient").item(0) as Element
 
-            gradientNode.setAttribute("android:startColor", backgroundColor)
+            gradientNode.setAttribute("android:startColor", "@color/gray_7")
-            gradientNode.setAttribute("android:endColor", backgroundColor)
+            gradientNode.setAttribute("android:endColor", "@color/gray_7")
         }
     }
 }

patches/src/main/kotlin/app/revanced/patches/spotify/layout/theme/Fingerprints.kt

@@ -4,30 +4,25 @@ import app.revanced.patcher.fingerprint
 import app.revanced.util.containsLiteralInstruction
 import com.android.tools.smali.dexlib2.AccessFlags
 
-internal val encoreThemeFingerprint = fingerprint {
+internal val colorSpaceUtilsClassFingerprint = fingerprint {
-    strings("Encore theme was not provided.") // Partial string match.
+    strings("The specified color must be encoded in an RGB color space.") // Partial string match.
-    custom { method, _ ->
-        method.name == "invoke"
-    }
 }
 
-internal const val PLAYLIST_BACKGROUND_COLOR_LITERAL = 0xFF121212
+internal val convertArgbToRgbaFingerprint = fingerprint {
-internal const val SHARE_MENU_BACKGROUND_COLOR_LITERAL = 0xFF1F1F1F
+    accessFlags(AccessFlags.PUBLIC, AccessFlags.STATIC, AccessFlags.FINAL)
-internal const val HOME_CATEGORY_PILL_COLOR_LITERAL = 0xFF333333
+    returns("J")
-internal const val SETTINGS_HEADER_COLOR_LITERAL = 0xFF282828
+    parameters("J")
-
-internal val homeCategoryPillColorsFingerprint = fingerprint{
-    accessFlags(AccessFlags.STATIC, AccessFlags.CONSTRUCTOR)
-    custom { method, _ ->
-        method.containsLiteralInstruction(HOME_CATEGORY_PILL_COLOR_LITERAL) &&
-                method.containsLiteralInstruction(0x33000000)
-    }
 }
 
-internal val settingsHeaderColorFingerprint = fingerprint {
+internal val parseLottieJsonFingerprint = fingerprint {
-    accessFlags(AccessFlags.STATIC, AccessFlags.CONSTRUCTOR)
+    strings("Unsupported matte type: ")
+}
+
+internal val parseAnimatedColorFingerprint = fingerprint {
+    parameters("L", "F")
+    returns("Ljava/lang/Object;")
     custom { method, _ ->
-        method.containsLiteralInstruction(SETTINGS_HEADER_COLOR_LITERAL) &&
+        method.containsLiteralInstruction(255.0) &&
-                method.containsLiteralInstruction(0)
+                method.containsLiteralInstruction(1.0)
     }
 }

patches/src/main/kotlin/app/revanced/patches/spotify/lite/ondemand/OnDemandPatch.kt

@@ -3,9 +3,9 @@ package app.revanced.patches.spotify.lite.ondemand
 import app.revanced.patcher.extensions.InstructionExtensions.addInstruction
 import app.revanced.patcher.patch.bytecodePatch
 
+@Deprecated("Patch no longer works and will be deleted soon")
 @Suppress("unused")
 val onDemandPatch = bytecodePatch(
-    name = "Enable on demand",
     description = "Enables listening to songs on-demand, allowing to play any song from playlists, albums or artists without limitations. This does not remove ads.",
 ) {
     compatibleWith("com.spotify.lite")

patches/src/main/kotlin/app/revanced/patches/spotify/misc/Fingerprints.kt

@@ -1,15 +1,18 @@
 package app.revanced.patches.spotify.misc
 
 import app.revanced.patcher.fingerprint
-import app.revanced.patches.spotify.misc.extension.IS_SPOTIFY_LEGACY_APP_TARGET
+import app.revanced.patcher.patch.BytecodePatchContext
+import app.revanced.patches.spotify.shared.IS_SPOTIFY_LEGACY_APP_TARGET
 import app.revanced.util.getReference
 import app.revanced.util.indexOfFirstInstruction
 import com.android.tools.smali.dexlib2.AccessFlags
 import com.android.tools.smali.dexlib2.Opcode
 import com.android.tools.smali.dexlib2.iface.reference.FieldReference
+import com.android.tools.smali.dexlib2.iface.reference.MethodReference
 import com.android.tools.smali.dexlib2.iface.reference.TypeReference
 
-internal val accountAttributeFingerprint = fingerprint {
+context(BytecodePatchContext)
+internal val accountAttributeFingerprint get() = fingerprint {
     custom { _, classDef ->
         classDef.type == if (IS_SPOTIFY_LEGACY_APP_TARGET) {
             "Lcom/spotify/useraccount/v1/AccountAttribute;"
@@ -19,7 +22,8 @@ internal val accountAttributeFingerprint = fingerprint {
     }
 }
 
-internal val productStateProtoGetMapFingerprint = fingerprint {
+context(BytecodePatchContext)
+internal val productStateProtoGetMapFingerprint get() = fingerprint {
     returns("Ljava/util/Map;")
     custom { _, classDef ->
         classDef.type == if (IS_SPOTIFY_LEGACY_APP_TARGET) {
@@ -34,9 +38,22 @@ internal val buildQueryParametersFingerprint = fingerprint {
     strings("trackRows", "device_type:tablet")
 }
 
-internal val contextMenuExperimentsFingerprint = fingerprint {
+internal val contextMenuViewModelClassFingerprint = fingerprint {
+    strings("ContextMenuViewModel(header=")
+}
+
+internal val contextMenuViewModelAddItemFingerprint = fingerprint {
     parameters("L")
-    strings("remove_ads_upsell_enabled")
+    returns("V")
+    custom { method, _ ->
+        method.indexOfFirstInstruction {
+            getReference<MethodReference>()?.name == "add"
+        } >= 0
+    }
+}
+
+internal val getViewModelFingerprint = fingerprint {
+    custom { method, _ -> method.name == "getViewModel" }
 }
 
 internal val contextFromJsonFingerprint = fingerprint {
@@ -47,15 +64,15 @@ internal val contextFromJsonFingerprint = fingerprint {
         Opcode.MOVE_RESULT_OBJECT,
         Opcode.INVOKE_STATIC
     )
-    custom { methodDef, classDef ->
+    custom { method, classDef ->
-        methodDef.name == "fromJson" &&
+        method.name == "fromJson" &&
                 classDef.endsWith("voiceassistants/playermodels/ContextJsonAdapter;")
     }
 }
 
 internal val readPlayerOptionOverridesFingerprint = fingerprint {
-    custom { methodDef, classDef ->
+    custom { method, classDef ->
-        methodDef.name == "readPlayerOptionOverrides" &&
+        method.name == "readPlayerOptionOverrides" &&
                 classDef.endsWith("voiceassistants/playermodels/PreparePlayOptionsJsonAdapter;")
     }
 }
@@ -65,8 +82,15 @@ internal val protobufListsFingerprint = fingerprint {
     custom { method, _ -> method.name == "emptyProtobufList" }
 }
 
-internal val protobufListRemoveFingerprint = fingerprint {
+internal val abstractProtobufListEnsureIsMutableFingerprint = fingerprint {
-    custom { method, _ -> method.name == "remove" }
+    accessFlags(AccessFlags.PUBLIC, AccessFlags.FINAL)
+    parameters()
+    returns("V")
+    custom { method, _ ->
+    	method.indexOfFirstInstruction {
+            getReference<TypeReference>()?.type == "Ljava/lang/UnsupportedOperationException;"
+        } >= 0
+    }
 }
 
 internal val homeSectionFingerprint = fingerprint {
@@ -84,7 +108,8 @@ internal val homeStructureGetSectionsFingerprint = fingerprint {
 internal fun reactivexFunctionApplyWithClassInitFingerprint(className: String) = fingerprint {
     returns("Ljava/lang/Object;")
     parameters("Ljava/lang/Object;")
-    custom { method, _ -> method.name == "apply" && method.indexOfFirstInstruction {
+    custom { method, _ ->
+        method.name == "apply" && method.indexOfFirstInstruction {
             opcode == Opcode.NEW_INSTANCE && getReference<TypeReference>()?.type?.endsWith(className) == true
         } >= 0
     }

patches/src/main/kotlin/app/revanced/patches/spotify/misc/extension/ExtensionPatch.kt

@@ -1,21 +1,5 @@
 package app.revanced.patches.spotify.misc.extension
 
-import app.revanced.patcher.patch.bytecodePatch
 import app.revanced.patches.shared.misc.extension.sharedExtensionPatch
-import app.revanced.patches.spotify.shared.SPOTIFY_MAIN_ACTIVITY_LEGACY
 
-/**
+val sharedExtensionPatch = sharedExtensionPatch("spotify", mainActivityOnCreateHook)
- * If patching a legacy 8.x target. This may also be set if patching slightly older/newer app targets,
- * but the only legacy target of interest is 8.6.98.900 as it's the last version that
- * supports Spotify integration on Kenwood/Pioneer car stereos.
- */
-internal var IS_SPOTIFY_LEGACY_APP_TARGET = false
-
-val sharedExtensionPatch = bytecodePatch {
-    dependsOn(sharedExtensionPatch("spotify", mainActivityOnCreateHook))
-
-    execute {
-        IS_SPOTIFY_LEGACY_APP_TARGET = mainActivityOnCreateHook.fingerprint
-            .originalClassDef.type == SPOTIFY_MAIN_ACTIVITY_LEGACY
-    }
-}

patches/src/main/kotlin/app/revanced/patches/spotify/misc/fix/SpoofSignaturePatch.kt

@@ -7,7 +7,5 @@ import app.revanced.patcher.patch.bytecodePatch
 val spoofSignaturePatch = bytecodePatch(
     description = "Spoofs the signature of the app fix various functions of the app.",
 ) {
-    compatibleWith("com.spotify.music")
-
     dependsOn(spoofPackageInfoPatch)
 }

patches/src/main/kotlin/app/revanced/patches/spotify/misc/fix/login/Fingerprints.kt

@@ -0,0 +1,13 @@
+package app.revanced.patches.spotify.misc.fix.login
+
+import app.revanced.patcher.fingerprint
+import app.revanced.util.literal
+
+internal val katanaProxyLoginMethodHandlerClassFingerprint = fingerprint {
+    strings("katana_proxy_auth")
+}
+
+internal val katanaProxyLoginMethodTryAuthorizeFingerprint = fingerprint {
+    strings("e2e")
+    literal { 0 }
+}

patches/src/main/kotlin/app/revanced/patches/spotify/misc/fix/login/FixFacebookLoginPatch.kt

@@ -0,0 +1,29 @@
+package app.revanced.patches.spotify.misc.fix.login
+
+import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.util.returnEarly
+
+@Suppress("unused")
+val fixFacebookLoginPatch = bytecodePatch(
+    name = "Fix Facebook login",
+    description =
+        "Fix logging in with Facebook when the app is patched by always opening the login in a web browser window.",
+) {
+    compatibleWith("com.spotify.music")
+
+    execute {
+        // The Facebook SDK tries to handle the login using the Facebook app in case it is installed.
+        // However, the Facebook app does signature checks with the app that is requesting the authentication,
+        // which ends up making the Facebook server reject with an invalid key hash for the app signature.
+        // Override the Faceboook SDK to always handle the login using the web browser, which does not perform
+        // signature checks.
+
+        val katanaProxyLoginMethodHandlerClass = katanaProxyLoginMethodHandlerClassFingerprint.originalClassDef
+        // Always return 0 (no Intent was launched) as the result of trying to authorize with the Facebook app to 
+        // make the login fallback to a web browser window.
+        katanaProxyLoginMethodTryAuthorizeFingerprint
+            .match(katanaProxyLoginMethodHandlerClass)
+            .method
+            .returnEarly(0)
+    }
+}

patches/src/main/kotlin/app/revanced/patches/spotify/misc/privacy/SanitizeSharingLinksPatch.kt

@@ -4,8 +4,8 @@ import app.revanced.patcher.Fingerprint
 import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
 import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
 import app.revanced.patcher.patch.bytecodePatch
-import app.revanced.patches.spotify.misc.extension.IS_SPOTIFY_LEGACY_APP_TARGET
 import app.revanced.patches.spotify.misc.extension.sharedExtensionPatch
+import app.revanced.patches.spotify.shared.IS_SPOTIFY_LEGACY_APP_TARGET
 import app.revanced.util.getReference
 import app.revanced.util.indexOfFirstInstructionOrThrow
 import com.android.tools.smali.dexlib2.iface.instruction.FiveRegisterInstruction
@@ -37,13 +37,13 @@ val sanitizeSharingLinksPatch = bytecodePatch(
             val newPlainTextInvokeIndex = indexOfFirstInstructionOrThrow {
                 getReference<MethodReference>()?.name == "newPlainText"
             }
-            val register = getInstruction<FiveRegisterInstruction>(newPlainTextInvokeIndex).registerD
+            val urlRegister = getInstruction<FiveRegisterInstruction>(newPlainTextInvokeIndex).registerD
 
             addInstructions(
                 newPlainTextInvokeIndex,
                 """
-                    invoke-static { v$register }, $extensionMethodDescriptor
+                    invoke-static { v$urlRegister }, $extensionMethodDescriptor
-                    move-result-object v$register
+                    move-result-object v$urlRegister
                 """
             )
         }

patches/src/main/kotlin/app/revanced/patches/spotify/misc/widgets/FixThirdPartyLaunchersWidgets.kt

@@ -1,7 +1,9 @@
 package app.revanced.patches.spotify.misc.widgets
 
 import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.patches.spotify.shared.IS_SPOTIFY_LEGACY_APP_TARGET
 import app.revanced.util.returnEarly
+import java.util.logging.Logger
 
 @Suppress("unused")
 val fixThirdPartyLaunchersWidgets = bytecodePatch(
@@ -11,6 +13,14 @@ val fixThirdPartyLaunchersWidgets = bytecodePatch(
     compatibleWith("com.spotify.music")
 
     execute {
+        if (IS_SPOTIFY_LEGACY_APP_TARGET)  {
+            // The permission check does not exist in legacy versions.
+            Logger.getLogger(this::class.java.name).warning(
+                "Legacy app target does not have any third party launcher restrictions.  No changes applied."
+            )
+            return@execute
+        }
+
         // Only system app launchers are granted the BIND_APPWIDGET permission.
         // Override the method that checks for it to always return true, as this permission is not actually required
         // for the widgets to work.

patches/src/main/kotlin/app/revanced/patches/spotify/shared/Fingerprints.kt

@@ -1,6 +1,8 @@
 package app.revanced.patches.spotify.shared
 
 import app.revanced.patcher.fingerprint
+import app.revanced.patcher.patch.BytecodePatchContext
+import app.revanced.patches.spotify.misc.extension.mainActivityOnCreateHook
 
 private const val SPOTIFY_MAIN_ACTIVITY = "Lcom/spotify/music/SpotifyMainActivity;"
 
@@ -15,3 +17,18 @@ internal val mainActivityOnCreateFingerprint = fingerprint {
                 || classDef.type == SPOTIFY_MAIN_ACTIVITY_LEGACY)
     }
 }
+
+private var isLegacyAppTarget: Boolean? = null
+
+/**
+ * If patching a legacy 8.x target. This may also be set if patching slightly older/newer app targets,
+ * but the only legacy target of interest is 8.6.98.900 as it's the last version that
+ * supports Spotify integration on Kenwood/Pioneer car stereos.
+ */
+context(BytecodePatchContext)
+internal val IS_SPOTIFY_LEGACY_APP_TARGET get(): Boolean {
+    if (isLegacyAppTarget == null) {
+        isLegacyAppTarget = mainActivityOnCreateHook.fingerprint.originalClassDef.type == SPOTIFY_MAIN_ACTIVITY_LEGACY
+    }
+    return isLegacyAppTarget!!
+}

patches/src/main/kotlin/app/revanced/patches/youtube/interaction/swipecontrols/SwipeControlsPatch.kt

@@ -48,7 +48,12 @@ private val swipeControlsResourcePatch = resourcePatch {
                 summaryKey = null,
             ),
             TextPreference("revanced_swipe_overlay_background_opacity", inputType = InputType.NUMBER),
-            TextPreference("revanced_swipe_overlay_progress_color", inputType = InputType.TEXT_CAP_CHARACTERS),
+            TextPreference("revanced_swipe_overlay_progress_brightness_color",
+                tag = "app.revanced.extension.shared.settings.preference.ColorPickerPreference",
+                inputType = InputType.TEXT_CAP_CHARACTERS),
+            TextPreference("revanced_swipe_overlay_progress_volume_color",
+                tag = "app.revanced.extension.shared.settings.preference.ColorPickerPreference",
+                inputType = InputType.TEXT_CAP_CHARACTERS),
             TextPreference("revanced_swipe_text_overlay_size", inputType = InputType.NUMBER),
             TextPreference("revanced_swipe_overlay_timeout", inputType = InputType.NUMBER),
             TextPreference("revanced_swipe_threshold", inputType = InputType.NUMBER),

patches/src/main/kotlin/app/revanced/patches/youtube/layout/player/fullscreen/Fingerprints.kt

@@ -15,9 +15,6 @@ internal val openVideosFullscreenPortraitFingerprint = fingerprint {
     }
 }
 
-/**
- * Used to enable opening regular videos fullscreen.
- */
 internal val openVideosFullscreenHookPatchExtensionFingerprint = fingerprint {
     accessFlags(AccessFlags.PRIVATE, AccessFlags.STATIC)
     returns("Z")

patches/src/main/kotlin/app/revanced/patches/youtube/layout/shortsplayer/Fingerprints.kt

@@ -54,3 +54,11 @@ internal val shortsPlaybackIntentFingerprint = fingerprint {
         "reels_fragment_descriptor"
     )
 }
+
+internal val exitVideoPlayerFingerprint = fingerprint {
+    returns("V")
+    parameters()
+    literal {
+        mdx_drawer_layout_id
+    }
+}

patches/src/main/kotlin/app/revanced/patches/youtube/layout/shortsplayer/OpenShortsInRegularPlayerPatch.kt

@@ -1,11 +1,16 @@
 package app.revanced.patches.youtube.layout.shortsplayer
 
 import app.revanced.patcher.extensions.InstructionExtensions.addInstruction
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
 import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
 import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
 import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.patcher.patch.resourcePatch
 import app.revanced.patches.all.misc.resources.addResources
 import app.revanced.patches.all.misc.resources.addResourcesPatch
+import app.revanced.patches.shared.misc.mapping.get
+import app.revanced.patches.shared.misc.mapping.resourceMappingPatch
+import app.revanced.patches.shared.misc.mapping.resourceMappings
 import app.revanced.patches.shared.misc.settings.preference.ListPreference
 import app.revanced.patches.youtube.layout.player.fullscreen.openVideosFullscreenHookPatch
 import app.revanced.patches.youtube.misc.extension.sharedExtensionPatch
@@ -19,12 +24,29 @@ import app.revanced.patches.youtube.shared.mainActivityOnCreateFingerprint
 import app.revanced.util.findFreeRegister
 import app.revanced.util.getReference
 import app.revanced.util.indexOfFirstInstructionOrThrow
+import app.revanced.util.indexOfFirstInstructionReversedOrThrow
+import com.android.tools.smali.dexlib2.Opcode
 import com.android.tools.smali.dexlib2.iface.instruction.OneRegisterInstruction
 import com.android.tools.smali.dexlib2.iface.reference.MethodReference
 
 private const val EXTENSION_CLASS_DESCRIPTOR =
     "Lapp/revanced/extension/youtube/patches/OpenShortsInRegularPlayerPatch;"
 
+internal var mdx_drawer_layout_id = -1L
+    private set
+
+private val openShortsInRegularPlayerResourcePatch = resourcePatch {
+    dependsOn(resourceMappingPatch)
+
+    execute {
+        mdx_drawer_layout_id = resourceMappings[
+            "id",
+            "mdx_drawer_layout",
+        ]
+
+    }
+}
+
 @Suppress("unused")
 val openShortsInRegularPlayerPatch = bytecodePatch(
     name = "Open Shorts in regular player",
@@ -36,7 +58,8 @@ val openShortsInRegularPlayerPatch = bytecodePatch(
         addResourcesPatch,
         openVideosFullscreenHookPatch,
         navigationBarHookPatch,
-        versionCheckPatch
+        versionCheckPatch,
+        openShortsInRegularPlayerResourcePatch
     )
 
     compatibleWith(
@@ -127,5 +150,28 @@ val openShortsInRegularPlayerPatch = bytecodePatch(
                 ${extensionInstructions(0, 1)}
             """
         )
+
+        // Fix issue with back button exiting the app instead of minimizing the player.
+        // Without this change this issue can be difficult to reproduce, but seems to occur
+        // most often with 'open video in regular player' and not open in fullscreen player.
+        exitVideoPlayerFingerprint.method.apply {
+            // Method call for Activity.finish()
+            val finishIndex = indexOfFirstInstructionOrThrow {
+                val reference = getReference<MethodReference>()
+                reference?.name == "finish"
+            }
+
+            // Index of PlayerType.isWatchWhileMaximizedOrFullscreen()
+            val index = indexOfFirstInstructionReversedOrThrow(finishIndex, Opcode.MOVE_RESULT)
+            val register = getInstruction<OneRegisterInstruction>(index).registerA
+
+            addInstructions(
+                index + 1,
+                """
+                    invoke-static { v$register }, ${EXTENSION_CLASS_DESCRIPTOR}->overrideBackPressToExit(Z)Z    
+                    move-result v$register
+                """
+            )
+        }
     }
 }

patches/src/main/kotlin/app/revanced/patches/youtube/layout/theme/ThemePatch.kt

@@ -89,14 +89,15 @@ val themePatch = bytecodePatch(
             execute {
                 val preferences = mutableSetOf<BasePreference>(
                     SwitchPreference("revanced_seekbar_custom_color"),
-                    TextPreference("revanced_seekbar_custom_color_primary", inputType = InputType.TEXT_CAP_CHARACTERS),
+                    TextPreference("revanced_seekbar_custom_color_primary",
+                        tag = "app.revanced.extension.shared.settings.preference.ColorPickerPreference",
+                        inputType = InputType.TEXT_CAP_CHARACTERS),
                 )
 
                 if (is_19_25_or_greater) {
-                    preferences += TextPreference(
+                    preferences += TextPreference("revanced_seekbar_custom_color_accent",
-                        "revanced_seekbar_custom_color_accent",
+                        tag = "app.revanced.extension.shared.settings.preference.ColorPickerPreference",
-                        inputType = InputType.TEXT_CAP_CHARACTERS
+                        inputType = InputType.TEXT_CAP_CHARACTERS)
-                    )
                 }
 
                 PreferenceScreen.SEEKBAR.addPreferences(

patches/src/main/kotlin/app/revanced/patches/youtube/misc/debugging/EnableDebuggingPatch.kt

@@ -5,6 +5,7 @@ import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
 import app.revanced.patcher.patch.bytecodePatch
 import app.revanced.patches.all.misc.resources.addResources
 import app.revanced.patches.all.misc.resources.addResourcesPatch
+import app.revanced.patches.shared.misc.settings.preference.NonInteractivePreference
 import app.revanced.patches.shared.misc.settings.preference.PreferenceScreenPreference
 import app.revanced.patches.shared.misc.settings.preference.PreferenceScreenPreference.Sorting
 import app.revanced.patches.shared.misc.settings.preference.SwitchPreference
@@ -23,7 +24,7 @@ private const val EXTENSION_CLASS_DESCRIPTOR =
 
 val enableDebuggingPatch = bytecodePatch(
     name = "Enable debugging",
-    description = "Adds options for debugging.",
+    description = "Adds options for debugging and exporting ReVanced logs to the clipboard.",
 ) {
     dependsOn(
         sharedExtensionPatch,
@@ -56,6 +57,16 @@ val enableDebuggingPatch = bytecodePatch(
                     SwitchPreference("revanced_debug_protobuffer"),
                     SwitchPreference("revanced_debug_stacktrace"),
                     SwitchPreference("revanced_debug_toast_on_error"),
+                    NonInteractivePreference(
+                        "revanced_debug_export_logs_to_clipboard",
+                        tag = "app.revanced.extension.youtube.settings.preference.ExportLogToClipboardPreference",
+                        selectable = true,
+                    ),
+                    NonInteractivePreference(
+                        "revanced_debug_logs_clear_buffer",
+                        tag = "app.revanced.extension.youtube.settings.preference.ClearLogBufferPreference",
+                        selectable = true,
+                    ),
                 ),
             ),
         )
@@ -107,7 +118,6 @@ val enableDebuggingPatch = bytecodePatch(
                     return-wide v0
                 """
             )
-
         }
 
         experimentalStringFeatureFlagFingerprint.match(

patches/src/main/kotlin/app/revanced/patches/youtube/misc/hapticfeedback/DisableHapticFeedbackPatch.kt

@@ -0,0 +1,74 @@
+package app.revanced.patches.youtube.misc.hapticfeedback
+
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
+import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
+import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.patcher.util.smali.ExternalLabel
+import app.revanced.patches.all.misc.resources.addResources
+import app.revanced.patches.all.misc.resources.addResourcesPatch
+import app.revanced.patches.shared.misc.settings.preference.PreferenceScreenPreference
+import app.revanced.patches.shared.misc.settings.preference.SwitchPreference
+import app.revanced.patches.youtube.misc.settings.PreferenceScreen
+import app.revanced.patches.youtube.misc.settings.settingsPatch
+
+private const val EXTENSION_CLASS_DESCRIPTOR =
+    "Lapp/revanced/extension/youtube/patches/DisableHapticFeedbackPatch;"
+
+@Suppress("unused")
+val disableHapticFeedbackPatch = bytecodePatch(
+    name = "Disable haptic feedback",
+    description = "Adds an option to disable haptic feedback in the player for various actions.",
+) {
+    dependsOn(
+        settingsPatch,
+        addResourcesPatch,
+    )
+
+    compatibleWith(
+        "com.google.android.youtube"(
+            "19.16.39",
+            "19.25.37",
+            "19.34.42",
+            "19.43.41",
+            "19.47.53",
+            "20.07.39",
+            "20.12.46",
+        )
+    )
+
+    execute {
+        addResources("youtube", "misc.hapticfeedback.disableHapticFeedbackPatch")
+
+        PreferenceScreen.PLAYER.addPreferences(
+            PreferenceScreenPreference(
+                "revanced_disable_haptic_feedback",
+                preferences = setOf(
+                    SwitchPreference("revanced_disable_haptic_feedback_chapters"),
+                    SwitchPreference("revanced_disable_haptic_feedback_precise_seeking"),
+                    SwitchPreference("revanced_disable_haptic_feedback_seek_undo"),
+                    SwitchPreference("revanced_disable_haptic_feedback_zoom"),
+                )
+            )
+        )
+
+        arrayOf(
+            markerHapticsFingerprint to "disableChapterVibrate",
+            scrubbingHapticsFingerprint to "disablePreciseSeekingVibrate",
+            seekUndoHapticsFingerprint to "disableSeekUndoVibrate",
+            zoomHapticsFingerprint to "disableZoomVibrate"
+        ).forEach { (fingerprint, methodName) ->
+            fingerprint.method.apply {
+                addInstructionsWithLabels(
+                    0,
+                    """
+                        invoke-static {}, $EXTENSION_CLASS_DESCRIPTOR->$methodName()Z
+                        move-result v0
+                        if-eqz v0, :vibrate
+                        return-void
+                    """,
+                    ExternalLabel("vibrate", getInstruction(0))
+                )
+            }
+        }
+    }
+}

patches/src/main/kotlin/app/revanced/patches/youtube/misc/hapticfeedback/Fingerprints.kt

@@ -0,0 +1,23 @@
+package app.revanced.patches.youtube.misc.hapticfeedback
+
+import app.revanced.patcher.fingerprint
+
+internal val markerHapticsFingerprint = fingerprint {
+    returns("V")
+    strings("Failed to execute markers haptics vibrate.")
+}
+
+internal val scrubbingHapticsFingerprint = fingerprint {
+    returns("V")
+    strings("Failed to haptics vibrate for fine scrubbing.")
+}
+
+internal val seekUndoHapticsFingerprint = fingerprint {
+    returns("V")
+    strings("Failed to execute seek undo haptics vibrate.")
+}
+
+internal val zoomHapticsFingerprint = fingerprint {
+    returns("V")
+    strings("Failed to haptics vibrate for video zoom")
+}

patches/src/main/kotlin/app/revanced/patches/youtube/misc/settings/SettingsPatch.kt

@@ -74,6 +74,7 @@ private val settingsResourcePatch = resourcePatch {
 
         arrayOf(
             ResourceGroup("drawable",
+                "revanced_settings_circle_background.xml",
                 "revanced_settings_cursor.xml",
                 "revanced_settings_icon.xml",
                 "revanced_settings_screen_00_about.xml",
@@ -91,6 +92,8 @@ private val settingsResourcePatch = resourcePatch {
                 "revanced_settings_screen_12_video.xml",
             ),
             ResourceGroup("layout",
+                "revanced_color_dot_widget.xml",
+                "revanced_color_picker.xml",
                 "revanced_preference_with_icon_no_search_result.xml",
                 "revanced_search_suggestion_item.xml",
                 "revanced_settings_with_toolbar.xml"),

patches/src/main/kotlin/app/revanced/patches/youtube/misc/zoomhaptics/Fingerprints.kt

@@ -1,7 +0,0 @@
-package app.revanced.patches.youtube.misc.zoomhaptics
-
-import app.revanced.patcher.fingerprint
-
-internal val zoomHapticsFingerprint = fingerprint {
-    strings("Failed to haptics vibrate for video zoom")
-}

patches/src/main/kotlin/app/revanced/patches/youtube/misc/zoomhaptics/ZoomHapticsPatch.kt

@@ -1,54 +1,11 @@
 package app.revanced.patches.youtube.misc.zoomhaptics
 
-import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
-import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
 import app.revanced.patcher.patch.bytecodePatch
-import app.revanced.patcher.util.smali.ExternalLabel
+import app.revanced.patches.youtube.misc.hapticfeedback.disableHapticFeedbackPatch
-import app.revanced.patches.all.misc.resources.addResources
-import app.revanced.patches.all.misc.resources.addResourcesPatch
-import app.revanced.patches.shared.misc.settings.preference.SwitchPreference
-import app.revanced.patches.youtube.misc.settings.PreferenceScreen
-import app.revanced.patches.youtube.misc.settings.settingsPatch
 
+@Deprecated("Superseded by disableHapticFeedbackPatch", ReplaceWith("disableHapticFeedbackPatch"))
 val zoomHapticsPatch = bytecodePatch(
-    name = "Disable zoom haptics",
     description = "Adds an option to disable haptics when zooming.",
 ) {
-    dependsOn(
+    dependsOn(disableHapticFeedbackPatch)
-        settingsPatch,
-        addResourcesPatch,
-    )
-
-    compatibleWith(
-        "com.google.android.youtube"(
-            "19.16.39",
-            "19.25.37",
-            "19.34.42",
-            "19.43.41",
-            "19.47.53",
-            "20.07.39",
-            "20.12.46",
-        )
-    )
-
-    execute {
-        addResources("youtube", "misc.zoomhaptics.zoomHapticsPatch")
-
-        PreferenceScreen.MISC.addPreferences(
-            SwitchPreference("revanced_disable_zoom_haptics"),
-        )
-
-        zoomHapticsFingerprint.method.apply {
-            addInstructionsWithLabels(
-                0,
-                """
-                invoke-static { }, Lapp/revanced/extension/youtube/patches/ZoomHapticsPatch;->shouldVibrate()Z
-                move-result v0
-                if-nez v0, :vibrate
-                return-void
-            """,
-                ExternalLabel("vibrate", getInstruction(0)),
-            )
-        }
-    }
 }

patches/src/main/kotlin/app/revanced/patches/youtube/video/information/Fingerprints.kt

@@ -123,3 +123,13 @@ internal val playbackSpeedMenuSpeedChangedFingerprint = fingerprint {
         Opcode.RETURN_OBJECT,
     )
 }
+
+internal val playbackSpeedClassFingerprint = fingerprint {
+    accessFlags(AccessFlags.PUBLIC, AccessFlags.STATIC)
+    returns("L")
+    parameters("L")
+    opcodes(
+        Opcode.RETURN_OBJECT
+    )
+    strings("PLAYBACK_RATE_MENU_BOTTOM_SHEET_FRAGMENT")
+}

patches/src/main/kotlin/app/revanced/patches/youtube/video/information/VideoInformationPatch.kt

@@ -7,6 +7,7 @@ import app.revanced.patcher.patch.bytecodePatch
 import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
+import app.revanced.patcher.util.smali.toInstructions
 import app.revanced.patches.youtube.misc.extension.sharedExtensionPatch
 import app.revanced.patches.youtube.shared.newVideoQualityChangedFingerprint
 import app.revanced.patches.youtube.video.playerresponse.Hook
@@ -16,6 +17,8 @@ import app.revanced.patches.youtube.video.videoid.hookBackgroundPlayVideoId
 import app.revanced.patches.youtube.video.videoid.hookPlayerResponseVideoId
 import app.revanced.patches.youtube.video.videoid.hookVideoId
 import app.revanced.patches.youtube.video.videoid.videoIdPatch
+import app.revanced.util.addInstructionsAtControlFlowLabel
+import app.revanced.util.addStaticFieldToExtension
 import app.revanced.util.getReference
 import app.revanced.util.indexOfFirstInstructionOrThrow
 import com.android.tools.smali.dexlib2.AccessFlags
@@ -29,6 +32,7 @@ import com.android.tools.smali.dexlib2.iface.instruction.TwoRegisterInstruction
 import com.android.tools.smali.dexlib2.iface.reference.FieldReference
 import com.android.tools.smali.dexlib2.iface.reference.MethodReference
 import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethodImplementation
 import com.android.tools.smali.dexlib2.immutable.ImmutableMethodParameter
 import com.android.tools.smali.dexlib2.util.MethodUtil
 
@@ -189,6 +193,72 @@ val videoInformationPatch = bytecodePatch(
                 proxy(classes.first { it.type == setPlaybackSpeedMethodReference.definingClass })
                     .mutableClass.methods.first { it.name == setPlaybackSpeedMethodReference.name }
             setPlaybackSpeedMethodIndex = 0
+
+            // Add override playback speed method.
+            onPlaybackSpeedItemClickFingerprint.classDef.methods.add(
+                ImmutableMethod(
+                    definingClass,
+                    "overridePlaybackSpeed",
+                    listOf(ImmutableMethodParameter("F", annotations, null)),
+                    "V",
+                    AccessFlags.PUBLIC.value or AccessFlags.PUBLIC.value,
+                    annotations,
+                    null,
+                    ImmutableMethodImplementation(
+                        4,
+                        """
+                            # Check if the playback speed is not auto (-2.0f)
+                            const/4 v0, 0x0
+                            cmpg-float v0, v3, v0
+                            if-lez v0, :ignore
+                            
+                            # Get the container class field.
+                            iget-object v0, v2, $setPlaybackSpeedContainerClassFieldReference  
+
+                            # For some reason, in YouTube 19.44.39 this value is sometimes null.
+                            if-eqz v0, :ignore
+
+                            # Get the field from its class.
+                            iget-object v1, v0, $setPlaybackSpeedClassFieldReference
+                            
+                            # Invoke setPlaybackSpeed on that class.
+                            invoke-virtual {v1, v3}, $setPlaybackSpeedMethodReference
+
+                            :ignore
+                            return-void
+                        """.toInstructions(), null, null
+                    )
+                ).toMutable()
+            )
+        }
+
+        playbackSpeedClassFingerprint.method.apply {
+            val index = indexOfFirstInstructionOrThrow(Opcode.RETURN_OBJECT)
+            val register = getInstruction<OneRegisterInstruction>(index).registerA
+            val playbackSpeedClass = this.returnType
+
+            // Set playback speed class.
+            addInstructionsAtControlFlowLabel(
+                index,
+                "sput-object v$register, $EXTENSION_CLASS_DESCRIPTOR->playbackSpeedClass:$playbackSpeedClass"
+            )
+
+            val smaliInstructions =
+                """
+                    if-eqz v0, :ignore
+                    invoke-virtual {v0, p0}, $playbackSpeedClass->overridePlaybackSpeed(F)V
+                    return-void
+                    :ignore
+                    nop
+                """
+
+            addStaticFieldToExtension(
+                EXTENSION_CLASS_DESCRIPTOR,
+                "overridePlaybackSpeed",
+                "playbackSpeedClass",
+                playbackSpeedClass,
+                smaliInstructions
+            )
         }
 
         // Handle new playback speed menu.

patches/src/main/kotlin/app/revanced/patches/youtube/video/speed/custom/CustomPlaybackSpeedPatch.kt

@@ -1,19 +1,11 @@
 package app.revanced.patches.youtube.video.speed.custom
 
-import app.revanced.patcher.extensions.InstructionExtensions.addInstruction
 import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
-import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
 import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
-import app.revanced.patcher.extensions.InstructionExtensions.instructions
 import app.revanced.patcher.extensions.InstructionExtensions.replaceInstruction
 import app.revanced.patcher.patch.bytecodePatch
-import app.revanced.patcher.patch.resourcePatch
-import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
 import app.revanced.patches.all.misc.resources.addResources
 import app.revanced.patches.all.misc.resources.addResourcesPatch
-import app.revanced.patches.shared.misc.mapping.get
-import app.revanced.patches.shared.misc.mapping.resourceMappingPatch
-import app.revanced.patches.shared.misc.mapping.resourceMappings
 import app.revanced.patches.shared.misc.settings.preference.InputType
 import app.revanced.patches.shared.misc.settings.preference.SwitchPreference
 import app.revanced.patches.shared.misc.settings.preference.TextPreference
@@ -27,27 +19,11 @@ import app.revanced.patches.youtube.misc.recyclerviewtree.hook.addRecyclerViewTr
 import app.revanced.patches.youtube.misc.recyclerviewtree.hook.recyclerViewTreeHookPatch
 import app.revanced.patches.youtube.misc.settings.settingsPatch
 import app.revanced.patches.youtube.video.speed.settingsMenuVideoSpeedGroup
-import app.revanced.util.*
+import app.revanced.util.indexOfFirstInstructionOrThrow
-import com.android.tools.smali.dexlib2.AccessFlags
+import app.revanced.util.indexOfFirstLiteralInstruction
+import app.revanced.util.indexOfFirstLiteralInstructionOrThrow
 import com.android.tools.smali.dexlib2.iface.instruction.NarrowLiteralInstruction
 import com.android.tools.smali.dexlib2.iface.instruction.OneRegisterInstruction
-import com.android.tools.smali.dexlib2.iface.reference.FieldReference
-import com.android.tools.smali.dexlib2.iface.reference.MethodReference
-import com.android.tools.smali.dexlib2.immutable.ImmutableField
-
-internal var speedUnavailableId = -1L
-    private set
-
-private val customPlaybackSpeedResourcePatch = resourcePatch {
-    dependsOn(resourceMappingPatch)
-
-    execute {
-        speedUnavailableId = resourceMappings[
-            "string",
-            "varispeed_unavailable_message",
-        ]
-    }
-}
 
 private const val FILTER_CLASS_DESCRIPTOR =
     "Lapp/revanced/extension/youtube/patches/components/PlaybackSpeedMenuFilterPatch;"
@@ -64,8 +40,7 @@ internal val customPlaybackSpeedPatch = bytecodePatch(
         addResourcesPatch,
         lithoFilterPatch,
         versionCheckPatch,
-        recyclerViewTreeHookPatch,
+        recyclerViewTreeHookPatch
-        customPlaybackSpeedResourcePatch
     )
 
     execute {
@@ -87,38 +62,6 @@ internal val customPlaybackSpeedPatch = bytecodePatch(
             )
         }
 
-        // Replace the speeds float array with custom speeds.
-        speedArrayGeneratorFingerprint.method.apply {
-            val sizeCallIndex = indexOfFirstInstructionOrThrow { getReference<MethodReference>()?.name == "size" }
-            val sizeCallResultRegister = getInstruction<OneRegisterInstruction>(sizeCallIndex + 1).registerA
-
-            replaceInstruction(sizeCallIndex + 1, "const/4 v$sizeCallResultRegister, 0x0")
-
-            val arrayLengthConstIndex = indexOfFirstLiteralInstructionOrThrow(7)
-            val arrayLengthConstDestination = getInstruction<OneRegisterInstruction>(arrayLengthConstIndex).registerA
-            val playbackSpeedsArrayType = "$EXTENSION_CLASS_DESCRIPTOR->customPlaybackSpeeds:[F"
-
-            addInstructions(
-                arrayLengthConstIndex + 1,
-                """
-                    sget-object v$arrayLengthConstDestination, $playbackSpeedsArrayType
-                    array-length v$arrayLengthConstDestination, v$arrayLengthConstDestination
-                """,
-            )
-
-            val originalArrayFetchIndex = indexOfFirstInstructionOrThrow {
-                val reference = getReference<FieldReference>()
-                reference?.type == "[F" && reference.definingClass.endsWith("/PlayerConfigModel;")
-            }
-            val originalArrayFetchDestination =
-                getInstruction<OneRegisterInstruction>(originalArrayFetchIndex).registerA
-
-            replaceInstruction(
-                originalArrayFetchIndex,
-                "sget-object v$originalArrayFetchDestination, $playbackSpeedsArrayType",
-            )
-        }
-
         // Override the min/max speeds that can be used.
         speedLimiterFingerprint.method.apply {
             val limitMinIndex = indexOfFirstLiteralInstructionOrThrow(0.25f)
@@ -135,47 +78,7 @@ internal val customPlaybackSpeedPatch = bytecodePatch(
             replaceInstruction(limitMaxIndex, "const/high16 v$limitMaxRegister, 8.0f")
         }
 
-        // Add a static INSTANCE field to the class.
+        // Close the unpatched playback dialog and show the modern custom dialog.
-        // This is later used to call "showOldPlaybackSpeedMenu" on the instance.
-
-        val instanceField = ImmutableField(
-            getOldPlaybackSpeedsFingerprint.originalClassDef.type,
-            "INSTANCE",
-            getOldPlaybackSpeedsFingerprint.originalClassDef.type,
-            AccessFlags.PUBLIC.value or AccessFlags.STATIC.value,
-            null,
-            null,
-            null,
-        ).toMutable()
-
-        getOldPlaybackSpeedsFingerprint.classDef.staticFields.add(instanceField)
-        // Set the INSTANCE field to the instance of the class.
-        // In order to prevent a conflict with another patch, add the instruction at index 1.
-        getOldPlaybackSpeedsFingerprint.method.addInstruction(1, "sput-object p0, $instanceField")
-
-        // Get the "showOldPlaybackSpeedMenu" method.
-        // This is later called on the field INSTANCE.
-        val showOldPlaybackSpeedMenuMethod = showOldPlaybackSpeedMenuFingerprint.match(
-            getOldPlaybackSpeedsFingerprint.classDef,
-        ).method.toString()
-
-        // Insert the call to the "showOldPlaybackSpeedMenu" method on the field INSTANCE.
-        showOldPlaybackSpeedMenuExtensionFingerprint.method.apply {
-            addInstructionsWithLabels(
-                instructions.lastIndex,
-                """
-                    sget-object v0, $instanceField
-                    if-nez v0, :not_null
-                    return-void
-                    :not_null
-                    invoke-virtual { v0 }, $showOldPlaybackSpeedMenuMethod
-                """,
-            )
-        }
-
-        // region Force old video quality menu.
-        // This is necessary, because there is no known way of adding custom playback speeds to the new menu.
-
         addRecyclerViewTreeHook(EXTENSION_CLASS_DESCRIPTOR)
 
         // Required to check if the playback speed menu is currently shown.

patches/src/main/kotlin/app/revanced/patches/youtube/video/speed/custom/Fingerprints.kt

@@ -1,30 +1,9 @@
 package app.revanced.patches.youtube.video.speed.custom
 
 import app.revanced.patcher.fingerprint
-import app.revanced.util.literal
 import com.android.tools.smali.dexlib2.AccessFlags
 import com.android.tools.smali.dexlib2.Opcode
 
-internal val getOldPlaybackSpeedsFingerprint = fingerprint {
-    parameters("[L", "I")
-    strings("menu_item_playback_speed")
-}
-
-internal val showOldPlaybackSpeedMenuFingerprint = fingerprint {
-    literal { speedUnavailableId }
-}
-
-internal val showOldPlaybackSpeedMenuExtensionFingerprint = fingerprint {
-    custom { method, _ -> method.name == "showOldPlaybackSpeedMenu" }
-}
-
-internal val speedArrayGeneratorFingerprint = fingerprint {
-    accessFlags(AccessFlags.PUBLIC, AccessFlags.STATIC)
-    returns("[L")
-    parameters("Lcom/google/android/libraries/youtube/innertube/model/player/PlayerResponseModel;")
-    strings("0.0#")
-}
-
 internal val speedLimiterFingerprint = fingerprint {
     accessFlags(AccessFlags.PUBLIC, AccessFlags.FINAL)
     returns("V")

patches/src/main/kotlin/app/revanced/patches/yuka/misc/unlockpremium/UnlockPremiumPatch.kt

@@ -3,10 +3,10 @@ package app.revanced.patches.yuka.misc.unlockpremium
 import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
 import app.revanced.patcher.patch.bytecodePatch
 
+@Deprecated("This patch no longer works and will be removed in the future.")
 @Suppress("unused")
-val unlockPremiumPatch = bytecodePatch(
+val unlockPremiumPatch = bytecodePatch {
-    name = "Unlock premium",
+
-) {
     compatibleWith("io.yuka.android"("4.29"))
 
     execute {

patches/src/main/kotlin/app/revanced/util/BytecodeUtils.kt

@@ -10,6 +10,7 @@ import app.revanced.patcher.extensions.InstructionExtensions.removeInstruction
 import app.revanced.patcher.patch.BytecodePatchContext
 import app.revanced.patcher.patch.PatchException
 import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
+import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
 import app.revanced.patcher.util.smali.ExternalLabel
 import app.revanced.patches.shared.misc.mapping.get
@@ -31,6 +32,7 @@ import com.android.tools.smali.dexlib2.iface.instruction.ThreeRegisterInstructio
 import com.android.tools.smali.dexlib2.iface.instruction.TwoRegisterInstruction
 import com.android.tools.smali.dexlib2.iface.instruction.WideLiteralInstruction
 import com.android.tools.smali.dexlib2.iface.reference.Reference
+import com.android.tools.smali.dexlib2.immutable.ImmutableField
 import com.android.tools.smali.dexlib2.util.MethodUtil
 import java.util.EnumSet
 
@@ -962,6 +964,43 @@ private fun MutableMethod.overrideReturnValue(value: String, returnLate: Boolean
     }
 }
 
+internal fun BytecodePatchContext.addStaticFieldToExtension(
+    className: String,
+    methodName: String,
+    fieldName: String,
+    objectClass: String,
+    smaliInstructions: String
+) {
+    val classDef = classes.find { classDef -> classDef.type == className }
+        ?: throw PatchException("No matching methods found in: $className")
+    val mutableClass = proxy(classDef).mutableClass
+
+    val objectCall = "$mutableClass->$fieldName:$objectClass"
+
+    mutableClass.apply {
+        methods.first { method -> method.name == methodName }.apply {
+            staticFields.add(
+                ImmutableField(
+                    definingClass,
+                    fieldName,
+                    objectClass,
+                    AccessFlags.PUBLIC.value or AccessFlags.STATIC.value,
+                    null,
+                    annotations,
+                    null
+                ).toMutable()
+            )
+
+            addInstructionsWithLabels(
+                0,
+                """
+                    sget-object v0, $objectCall
+                """ + smaliInstructions
+            )
+        }
+    }
+}
+
 /**
  * Set the custom condition for this fingerprint to check for a literal value.
  *

patches/src/main/resources/addresources/values-af-rZA/strings.xml

@@ -199,6 +199,8 @@ Second \"item\" text"</string>
   </patch>
   <patch id="misc.gms.gmsCoreSupportResourcePatch">
   </patch>
+  <patch id="misc.hapticfeedback.disableHapticFeedbackPatch">
+  </patch>
   <patch id="misc.gms.accountCredentialsInvalidTextPatch">
   </patch>
   <patch id="misc.links.bypassURLRedirectsPatch">
@@ -207,8 +209,6 @@ Second \"item\" text"</string>
   </patch>
   <patch id="misc.privacy.removeTrackingQueryParameterPatch">
   </patch>
-  <patch id="misc.zoomhaptics.zoomHapticsPatch">
-  </patch>
   <patch id="video.audio.forceOriginalAudioPatch">
   <!-- 'Spoof video streams' should be the same translation used for revanced_spoof_video_streams_screen_title -->
   </patch>

patches/src/main/resources/addresources/values-am-rET/strings.xml

@@ -199,6 +199,8 @@ Second \"item\" text"</string>
   </patch>
   <patch id="misc.gms.gmsCoreSupportResourcePatch">
   </patch>
+  <patch id="misc.hapticfeedback.disableHapticFeedbackPatch">
+  </patch>
   <patch id="misc.gms.accountCredentialsInvalidTextPatch">
   </patch>
   <patch id="misc.links.bypassURLRedirectsPatch">
@@ -207,8 +209,6 @@ Second \"item\" text"</string>
   </patch>
   <patch id="misc.privacy.removeTrackingQueryParameterPatch">
   </patch>
-  <patch id="misc.zoomhaptics.zoomHapticsPatch">
-  </patch>
   <patch id="video.audio.forceOriginalAudioPatch">
   <!-- 'Spoof video streams' should be the same translation used for revanced_spoof_video_streams_screen_title -->
   </patch>

patches/src/main/resources/addresources/values-ar-rSA/strings.xml

@@ -35,6 +35,8 @@ Second \"item\" text"</string>
   <string name="revanced_settings_submenu_title">الإعدادات</string>
   <string name="revanced_settings_confirm_user_dialog_title">هل ترغب في المتابعة؟</string>
   <string name="revanced_settings_reset">إعادة التعيين</string>
+  <string name="revanced_settings_reset_color">إعادة تعيين اللون</string>
+  <string name="revanced_settings_color_invalid">لون غير صالح</string>
   <string name="revanced_settings_restart_title">تحديث وإعادة التشغيل</string>
   <string name="revanced_settings_restart">إعادة التشغيل</string>
   <string name="revanced_settings_import">استيراد</string>
@@ -115,6 +117,11 @@ Second \"item\" text"</string>
   <string name="revanced_debug_protobuffer_title">سجل بروتوكول التخزين المؤقت</string>
   <string name="revanced_debug_protobuffer_summary_on">تتضمن سجلات التصحيح التخزين المؤقت</string>
   <string name="revanced_debug_protobuffer_summary_off">لا تتضمن سجلات التصحيح التخزين المؤقت</string>
+  <string name="revanced_debug_protobuffer_user_dialog_message">"سيؤدي تمكين هذا الإعداد إلى تسجيل بيانات تخطيط إضافية، بما في ذلك النص المعروض على الشاشة لبعض مكونات واجهة المستخدم.
+
+يمكن أن يساعد هذا في تحديد المكونات عند إنشاء عوامل تصفية مخصصة.
+
+ومع ذلك، سيؤدي تمكين هذا أيضًا إلى تسجيل بعض بيانات المستخدم مثل عنوان IP الخاص بك."</string>
   <string name="revanced_debug_stacktrace_title">سجل تتبع المكدس</string>
   <string name="revanced_debug_stacktrace_summary_on">تتضمن سجلات التصحيح سجل تتبع المكدس</string>
   <string name="revanced_debug_stacktrace_summary_off">لا تتضمن سجلات التصحيح سجل تتبع المكدس</string>
@@ -124,6 +131,15 @@ Second \"item\" text"</string>
   <string name="revanced_debug_toast_on_error_user_dialog_message">"يؤدي إيقاف تشغيل ملاحظات الأخطاء إلى إخفاء كافة إشعارات أخطاء ReVanced.
 
 لن يتم إعلامك بأي أخطاء غير متوقعة."</string>
+  <string name="revanced_debug_export_logs_to_clipboard_title">تصدير سجلات تصحيح الأخطاء</string>
+  <string name="revanced_debug_export_logs_to_clipboard_summary">نسخ سجلات تصحيح أخطاء ReVanced إلى الحافظة</string>
+  <string name="revanced_debug_logs_disabled">تم تعطيل تسجيلات تصحيح الأخطاء</string>
+  <string name="revanced_debug_logs_none_found">لم يتم العثور على سجلات</string>
+  <string name="revanced_debug_logs_copied_to_clipboard">تم نسخ السجلات</string>
+  <string name="revanced_debug_logs_failed_to_export">فشل تصدير السجلات: $s</string>
+  <string name="revanced_debug_logs_clear_buffer_title">مسح سجلات تصحيح الأخطاء</string>
+  <string name="revanced_debug_logs_clear_buffer_summary">يمسح جميع سجلات تصحيح أخطاء ReVanced المخزنة</string>
+  <string name="revanced_debug_logs_clear_toast">تم مسح السجلات</string>
   </patch>
   <patch id="layout.hide.general.hideLayoutComponentsPatch">
   <string name="revanced_hide_album_cards_title">إخفاء بطاقات الألبوم</string>
@@ -365,9 +381,6 @@ Second \"item\" text"</string>
 
 هذه الميزة متاحة فقط للأجهزة القديمة"</string>
   <string name="revanced_hide_fullscreen_ads_summary_off">يتم عرض إعلانات ملء الشاشة</string>
-  <string name="revanced_hide_buttoned_ads_title">إخفاء الإعلانات الزرية</string>
-  <string name="revanced_hide_buttoned_ads_summary_on">تم إخفاء الإعلانات الزرية</string>
-  <string name="revanced_hide_buttoned_ads_summary_off">يتم عرض الإعلانات الزرية</string>
   <string name="revanced_hide_paid_promotion_label_title">إخفاء تسمية الترقية المدفوعة</string>
   <string name="revanced_hide_paid_promotion_label_summary_on">تم إخفاء تسمية الترقية المدفوعة</string>
   <string name="revanced_hide_paid_promotion_label_summary_off">يتم عرض تسمية الترقية المدفوعة</string>
@@ -478,9 +491,10 @@ Second \"item\" text"</string>
   <string name="revanced_swipe_overlay_background_opacity_title">تعتيم خلفية واجهة التمرير السريع</string>
   <string name="revanced_swipe_overlay_background_opacity_summary">قيمة التعتيم بين 0-100</string>
   <string name="revanced_swipe_overlay_background_opacity_invalid_toast">يجب أن يكون تعتيم التمرير السريع بين 0-100</string>
-  <string name="revanced_swipe_overlay_progress_color_title">لون شريط تقدم واجهة التمرير</string>
+  <string name="revanced_swipe_overlay_progress_brightness_color_title">لون سطوع واجهة التمرير</string>
-  <string name="revanced_swipe_overlay_progress_color_summary">لون شريط التقدم لعناصر التحكم في مستوى الصوت والسطوع</string>
+  <string name="revanced_swipe_overlay_progress_brightness_color_summary">لون شريط التقدم لعناصر التحكم في السطوع</string>
-  <string name="revanced_swipe_overlay_progress_color_invalid_toast">لون شريط التقدم غير صالح</string>
+  <string name="revanced_swipe_overlay_progress_volume_color_title">لون مستوى صوت واجهة التمرير</string>
+  <string name="revanced_swipe_overlay_progress_volume_color_summary">لون شريط التقدم لعناصر التحكم في مستوى الصوت</string>
   <string name="revanced_swipe_text_overlay_size_title">حجم نص واجهة التمرير</string>
   <string name="revanced_swipe_text_overlay_size_summary">حجم النص لواجهة التمرير بين 1-30</string>
   <string name="revanced_swipe_text_overlay_size_invalid_toast">يجب أن يكون حجم النص بين 1-30</string>
@@ -1099,11 +1113,6 @@ Second \"item\" text"</string>
   <string name="revanced_sb_stats_saved_second_format">%s ثانية</string>
   <string name="revanced_sb_color_opacity_label">الشفافية:</string>
   <string name="revanced_sb_color_dot_label">اللون:</string>
-  <string name="revanced_sb_color_changed">تم تغيير اللون</string>
-  <string name="revanced_sb_color_reset">إعادة ضبط اللون</string>
-  <string name="revanced_sb_color_invalid">رمز اللون غير صالح</string>
-  <string name="revanced_sb_reset_color">إعادة تعيين اللون</string>
-  <string name="revanced_sb_reset">إعادة التعيين</string>
   <string name="revanced_sb_about_title">لمحة</string>
   <string name="revanced_sb_about_api_summary">يتم توفير البيانات بواسطة SponsorBlock API. انقر هنا لمعرفة المزيد ومشاهدة التنزيلات لمنصات أخرى</string>
   </patch>
@@ -1328,6 +1337,22 @@ Second \"item\" text"</string>
   <string name="microg_settings_title">إعدادات GmsCore</string>
   <string name="microg_settings_summary">إعدادات لـ GmsCore</string>
   </patch>
+  <patch id="misc.hapticfeedback.disableHapticFeedbackPatch">
+  <string name="revanced_disable_haptic_feedback_title">الاهتزاز عند الضغط</string>
+  <string name="revanced_disable_haptic_feedback_summary">تغيير الاهتزاز عند الضغط</string>
+  <string name="revanced_disable_haptic_feedback_chapters_title">تعطيل الاهتزاز للفصول</string>
+  <string name="revanced_disable_haptic_feedback_chapters_summary_on">تم تعطيل الاهتزاز للفصول</string>
+  <string name="revanced_disable_haptic_feedback_chapters_summary_off">تم تفعيل الاهتزاز للفصول</string>
+  <string name="revanced_disable_haptic_feedback_precise_seeking_title">تعطيل الاهتزاز عند التمرير الدقيق</string>
+  <string name="revanced_disable_haptic_feedback_precise_seeking_summary_on">تم تعطيل الاهتزاز الدقيق عند البحث</string>
+  <string name="revanced_disable_haptic_feedback_precise_seeking_summary_off">تم تفعيل الاهتزاز عند التمرير الدقيق</string>
+  <string name="revanced_disable_haptic_feedback_seek_undo_title">تعطيل الاهتزاز عند التراجع عن البحث</string>
+  <string name="revanced_disable_haptic_feedback_seek_undo_summary_on">تم تعطيل الاهتزاز عند التراجع عن البحث</string>
+  <string name="revanced_disable_haptic_feedback_seek_undo_summary_off">تم تمكين الاهتزاز عند التراجع عن البحث</string>
+  <string name="revanced_disable_haptic_feedback_zoom_title">تعطيل الاهتزاز عند التكبير</string>
+  <string name="revanced_disable_haptic_feedback_zoom_summary_on">تم تعطيل الاهتزاز عند التكبير</string>
+  <string name="revanced_disable_haptic_feedback_zoom_summary_off">تم تمكين الاهتزاز عند التكبير</string>
+  </patch>
   <patch id="misc.gms.accountCredentialsInvalidTextPatch">
   <string name="microg_offline_account_login_error">إذا قمت مؤخرًا بتغيير تفاصيل تسجيل الدخول إلى حسابك، فأزل تثبيت MicroG ثم أعد تثبيته.</string>
   </patch>
@@ -1346,11 +1371,6 @@ Second \"item\" text"</string>
   <string name="revanced_remove_tracking_query_parameter_summary_on">يتم إزالة معلمة استعلام التتبع من الروابط</string>
   <string name="revanced_remove_tracking_query_parameter_summary_off">لا يتم إزالة معلمة استعلام التتبع من الروابط</string>
   </patch>
-  <patch id="misc.zoomhaptics.zoomHapticsPatch">
-  <string name="revanced_disable_zoom_haptics_title">تعطيل الاهتزاز عند التكبير</string>
-  <string name="revanced_disable_zoom_haptics_summary_on">تم تعطيل الاهتزاز</string>
-  <string name="revanced_disable_zoom_haptics_summary_off">تم تمكين الاهتزاز</string>
-  </patch>
   <patch id="video.audio.forceOriginalAudioPatch">
   <string name="revanced_force_original_audio_title">فرض لغة الصوت الأصلية</string>
   <string name="revanced_force_original_audio_summary_on">استخدام لغة الصوت الأصلية</string>
@@ -1378,7 +1398,7 @@ Second \"item\" text"</string>
   </patch>
   <patch id="video.speed.button.playbackSpeedButtonPatch">
   <string name="revanced_playback_speed_dialog_button_title">عرض زر مربع حوار السرعة</string>
-  <string name="revanced_playback_speed_dialog_button_summary_on">يتم عرض الزر</string>
+  <string name="revanced_playback_speed_dialog_button_summary_on">الزر معروض. انقر مع الاستمرار لإعادة ضبط سرعة التشغيل إلى الوضع الافتراضي</string>
   <string name="revanced_playback_speed_dialog_button_summary_off">لا يتم عرض الزر</string>
   </patch>
   <patch id="video.speed.custom.customPlaybackSpeedPatch">
@@ -1390,6 +1410,7 @@ Second \"item\" text"</string>
   <string name="revanced_custom_playback_speeds_invalid">يجب أن تكون سرعات التشغيل المخصصة أقل من %s</string>
   <string name="revanced_custom_playback_speeds_parse_exception">سرعة التشغيل المخصصة غير صالحة</string>
   <string name="revanced_custom_playback_speeds_auto">تلقائي</string>
+  <string name="revanced_custom_playback_speeds_reset_toast">تمت إعادة ضبط سرعة التشغيل إلى: %s</string>
   <string name="revanced_speed_tap_and_hold_title">سرعة النقر مع الاستمرار المخصصة</string>
   <string name="revanced_speed_tap_and_hold_summary">سرعة التشغيل بين 0-8</string>
   </patch>