feat(YouTube): Add player button to change video quality (#5435)

Co-authored-by: LisoUseInAIKyrios <118716522+LisoUseInAIKyrios@users.noreply.github.com>

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/playback/quality/AdvancedVideoQualityMenuPatch.java

@@ -18,7 +18,7 @@ import app.revanced.extension.youtube.settings.Settings;
 public final class AdvancedVideoQualityMenuPatch {
 
     /**
-     * Injection point.
+     * Injection point.  Regular videos.
      */
     public static void onFlyoutMenuCreate(RecyclerView recyclerView) {
         if (!Settings.ADVANCED_VIDEO_QUALITY_MENU.get()) return;
@@ -61,22 +61,12 @@ public final class AdvancedVideoQualityMenuPatch {
         });
     }
 
-
-    /**
-     * Injection point.
-     *
-     * Used to force the creation of the advanced menu item for the Shorts quality flyout.
-     */
-    public static boolean forceAdvancedVideoQualityMenuCreation(boolean original) {
-        return Settings.ADVANCED_VIDEO_QUALITY_MENU.get() || original;
-    }
-
     /**
      * Injection point.
      *
      * Shorts video quality flyout.
      */
-    public static void showAdvancedVideoQualityMenu(ListView listView) {
+    public static void addVideoQualityListMenuListener(ListView listView) {
         if (!Settings.ADVANCED_VIDEO_QUALITY_MENU.get()) return;
 
         listView.setOnHierarchyChangeListener(new ViewGroup.OnHierarchyChangeListener() {
@@ -91,7 +81,6 @@ public final class AdvancedVideoQualityMenuPatch {
                     listView.setSoundEffectsEnabled(false);
                     final var qualityItemMenuPosition = 4;
                     listView.performItemClick(null, qualityItemMenuPosition, 0);
-
                 } catch (Exception ex) {
                     Logger.printException(() -> "showAdvancedVideoQualityMenu failure", ex);
                 }
@@ -102,4 +91,13 @@ public final class AdvancedVideoQualityMenuPatch {
             }
         });
     }
+
+    /**
+     * Injection point.
+     *
+     * Used to force the creation of the advanced menu item for the Shorts quality flyout.
+     */
+    public static boolean forceAdvancedVideoQualityMenuCreation(boolean original) {
+        return Settings.ADVANCED_VIDEO_QUALITY_MENU.get() || original;
+    }
 }

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/playback/quality/RememberVideoQualityPatch.java

@@ -17,6 +17,7 @@ import app.revanced.extension.shared.settings.IntegerSetting;
 import app.revanced.extension.youtube.patches.VideoInformation;
 import app.revanced.extension.youtube.settings.Settings;
 import app.revanced.extension.youtube.shared.ShortsPlayerState;
+import app.revanced.extension.youtube.videoplayer.VideoQualityDialogButton;
 
 @SuppressWarnings("unused")
 public class RememberVideoQualityPatch {
@@ -25,10 +26,20 @@ public class RememberVideoQualityPatch {
      * Interface to use obfuscated methods.
      */
     public interface VideoQualityMenuInterface {
-        void patch_setMenuIndexFromQuality(VideoQuality quality);
+        void patch_setQuality(VideoQuality quality);
     }
 
-    private static final int AUTOMATIC_VIDEO_QUALITY_VALUE = -2;
+    /**
+     * Video resolution of the automatic quality option..
+     */
+    public static final int AUTOMATIC_VIDEO_QUALITY_VALUE = -2;
+
+    /**
+     * All quality names are the same for all languages.
+     * VideoQuality also has a resolution enum that can be used if needed.
+     */
+    public static final String VIDEO_QUALITY_1080P_PREMIUM_NAME = "1080p Premium";
+
     private static final IntegerSetting videoQualityWifi = Settings.VIDEO_QUALITY_DEFAULT_WIFI;
     private static final IntegerSetting videoQualityMobile = Settings.VIDEO_QUALITY_DEFAULT_MOBILE;
     private static final IntegerSetting shortsQualityWifi = Settings.SHORTS_QUALITY_DEFAULT_WIFI;
@@ -36,32 +47,56 @@ public class RememberVideoQualityPatch {
 
     private static boolean qualityNeedsUpdating;
 
-    /**
-     * If the user selected a new quality from the flyout menu,
-     * and {@link Settings#REMEMBER_VIDEO_QUALITY_LAST_SELECTED}
-     * or {@link Settings#REMEMBER_SHORTS_QUALITY_LAST_SELECTED} is enabled.
-     */
-    private static boolean userChangedDefaultQuality;
-
-    /**
-     * Index of the video quality chosen by the user from the flyout menu.
-     */
-    private static int userSelectedQualityIndex;
-
     /**
      * The available qualities of the current video.
      */
     @Nullable
-    private static List<VideoQuality> videoQualities;
+    private static List<VideoQuality> currentQualities;
 
-    private static boolean shouldRememberVideoQuality() {
-        BooleanSetting preference = ShortsPlayerState.isOpen() ?
-                Settings.REMEMBER_SHORTS_QUALITY_LAST_SELECTED
+    /**
+     * The current quality of the video playing.
+     * This is always the actual quality even if Automatic quality is active.
+     */
+    @Nullable
+    private static VideoQuality currentQuality;
+
+    /**
+     * The current VideoQualityMenuInterface, set during setVideoQuality.
+     */
+    @Nullable
+    private static VideoQualityMenuInterface currentMenuInterface;
+
+    @Nullable
+    public static List<VideoQuality> getCurrentQualities() {
+        return currentQualities;
+    }
+
+    @Nullable
+    public static VideoQuality getCurrentQuality() {
+        return currentQuality;
+    }
+
+    @Nullable
+    public static VideoQualityMenuInterface getCurrentMenuInterface() {
+        return currentMenuInterface;
+    }
+
+    public static boolean shouldRememberVideoQuality() {
+        BooleanSetting preference = ShortsPlayerState.isOpen()
+                ? Settings.REMEMBER_SHORTS_QUALITY_LAST_SELECTED
                 : Settings.REMEMBER_VIDEO_QUALITY_LAST_SELECTED;
         return preference.get();
     }
 
-    private static void changeDefaultQuality(int qualityResolution) {
+    public static int getDefaultQualityResolution() {
+        final boolean isShorts = ShortsPlayerState.isOpen();
+        IntegerSetting preference = Utils.getNetworkType() == NetworkType.MOBILE
+                ? (isShorts ? shortsQualityMobile : videoQualityMobile)
+                : (isShorts ? shortsQualityWifi : videoQualityWifi);
+        return preference.get();
+    }
+
+    public static void saveDefaultQuality(int qualityResolution) {
         final boolean shortPlayerOpen = ShortsPlayerState.isOpen();
         String networkTypeMessage;
         IntegerSetting qualitySetting;
@@ -72,16 +107,24 @@ public class RememberVideoQualityPatch {
             networkTypeMessage = str("revanced_remember_video_quality_wifi");
             qualitySetting = shortPlayerOpen ? shortsQualityWifi : videoQualityWifi;
         }
+
+        if (qualitySetting.get() == qualityResolution) {
+            // User clicked the same video quality as the current video,
+            // or changed between 1080p Premium and non-Premium.
+            return;
+        }
         qualitySetting.save(qualityResolution);
 
-        if (Settings.REMEMBER_VIDEO_QUALITY_LAST_SELECTED_TOAST.get())
+        if (Settings.REMEMBER_VIDEO_QUALITY_LAST_SELECTED_TOAST.get()) {
+            String qualityLabel = qualityResolution + "p";
             Utils.showToastShort(str(
                     shortPlayerOpen
                             ? "revanced_remember_video_quality_toast_shorts"
                             : "revanced_remember_video_quality_toast",
                     networkTypeMessage,
-                    (qualityResolution + "p"))
+                    qualityLabel)
             );
+        }
     }
 
     /**
@@ -93,111 +136,101 @@ public class RememberVideoQualityPatch {
     public static int setVideoQuality(VideoQuality[] qualities, VideoQualityMenuInterface menu, int originalQualityIndex) {
         try {
             Utils.verifyOnMainThread();
+            currentMenuInterface = menu;
 
-            final boolean useShortsPreference = ShortsPlayerState.isOpen();
-            final int preferredQuality = Utils.getNetworkType() == NetworkType.MOBILE
-                    ? (useShortsPreference ? shortsQualityMobile : videoQualityMobile).get()
-                    : (useShortsPreference ? shortsQualityWifi : videoQualityWifi).get();
+            final boolean availableQualitiesChanged = currentQualities == null
+                    || currentQualities.size() != qualities.length;
+            if (availableQualitiesChanged) {
+                currentQualities = Arrays.asList(qualities);
+                Logger.printDebug(() -> "VideoQualities: " + currentQualities);
+            }
 
-            if (!userChangedDefaultQuality && preferredQuality == AUTOMATIC_VIDEO_QUALITY_VALUE) {
+            VideoQuality updatedCurrentQuality = qualities[originalQualityIndex];
+            if (updatedCurrentQuality.patch_getResolution() != AUTOMATIC_VIDEO_QUALITY_VALUE &&
+                    (currentQuality == null
+                            || !currentQuality.patch_getQualityName().equals(updatedCurrentQuality.patch_getQualityName()))) {
+                currentQuality = updatedCurrentQuality;
+                Logger.printDebug(() -> "Current quality changed to: " + updatedCurrentQuality);
+
+                VideoQualityDialogButton.updateButtonIcon(updatedCurrentQuality);
+            }
+
+            final int preferredQuality = getDefaultQualityResolution();
+            if (preferredQuality == AUTOMATIC_VIDEO_QUALITY_VALUE) {
                 return originalQualityIndex; // Nothing to do.
             }
 
-            if (videoQualities == null || videoQualities.size() != qualities.length) {
-                videoQualities = Arrays.asList(qualities);
-
-                // After changing videos the qualities can initially be for the prior video.
-                // So if the qualities have changed an update is needed.
-                qualityNeedsUpdating = true;
-                Logger.printDebug(() -> "VideoQualities: " + videoQualities);
-            }
-
-            if (userChangedDefaultQuality) {
-                userChangedDefaultQuality = false;
-                VideoQuality quality = videoQualities.get(userSelectedQualityIndex);
-                Logger.printDebug(() -> "User changed default quality to: " + quality);
-                changeDefaultQuality(quality.patch_getResolution());
-                return userSelectedQualityIndex;
-            }
-
-            if (!qualityNeedsUpdating) {
+            // After changing videos the qualities can initially be for the prior video.
+            // If the qualities have changed and the default is not auto then an update is needed.
+            if (!qualityNeedsUpdating && !availableQualitiesChanged) {
                 return originalQualityIndex;
             }
             qualityNeedsUpdating = false;
 
             // Find the highest quality that is equal to or less than the preferred.
-            VideoQuality qualityToUse = videoQualities.get(0); // First element is automatic mode.
-            int qualityIndexToUse = 0;
             int i = 0;
-            for (VideoQuality quality : videoQualities) {
+            for (VideoQuality quality : qualities) {
                 final int qualityResolution = quality.patch_getResolution();
-                if (qualityResolution > qualityToUse.patch_getResolution() && qualityResolution <= preferredQuality) {
-                    qualityToUse = quality;
-                    qualityIndexToUse = i;
-                    break;
+                if (qualityResolution != AUTOMATIC_VIDEO_QUALITY_VALUE && qualityResolution <= preferredQuality) {
+                    final boolean qualityNeedsChange = (i != originalQualityIndex);
+                    Logger.printDebug(() -> qualityNeedsChange
+                            ? "Changing video quality from: " + updatedCurrentQuality + " to: " + quality
+                            : "Video is already the preferred quality: " + quality
+                    );
+
+                    // On first load of a new regular video, if the video is already the
+                    // desired quality then the quality flyout will show 'Auto' (ie: Auto (720p)).
+                    //
+                    // To prevent user confusion, set the video index even if the
+                    // quality is already correct so the UI picker will not display "Auto".
+                    //
+                    // Only change Shorts quality if the quality actually needs to change,
+                    // because the "auto" option is not shown in the flyout
+                    // and setting the same quality again can cause the Short to restart.
+                    if (qualityNeedsChange || !ShortsPlayerState.isOpen()) {
+                        menu.patch_setQuality(qualities[i]);
+                        return i;
+                    }
+
+                    return originalQualityIndex;
                 }
                 i++;
             }
-
-            // If the desired quality index is equal to the original index,
-            // then the video is already set to the desired default quality.
-            String qualityToUseName = qualityToUse.patch_getQualityName();
-            if (qualityIndexToUse == originalQualityIndex) {
-                Logger.printDebug(() -> "Video is already preferred quality: " + qualityToUseName);
-            } else {
-                Logger.printDebug(() -> "Changing video quality from: "
-                        + videoQualities.get(originalQualityIndex).patch_getQualityName()
-                        + " to: " + qualityToUseName);
-            }
-
-            // On first load of a new video, if the video is already the desired quality
-            // then the quality flyout will show 'Auto' (ie: Auto (720p)).
-            //
-            // To prevent user confusion, set the video index even if the
-            // quality is already correct so the UI picker will not display "Auto".
-            menu.patch_setMenuIndexFromQuality(qualities[qualityIndexToUse]);
-
-            return qualityIndexToUse;
         } catch (Exception ex) {
             Logger.printException(() -> "setVideoQuality failure", ex);
-            return originalQualityIndex;
         }
-    }
-
-    /**
-     * Injection point. Fixes bad data used by YouTube.
-     */
-    public static int fixVideoQualityResolution(String name, int quality) {
-        final int correctQuality = 480;
-        if (name.equals("480p") && quality != correctQuality) {
-            Logger.printDebug(() -> "Fixing bad data of " + name + " from: " + quality
-                    + " to: " + correctQuality);
-            return correctQuality;
-        }
-
-        return quality;
+        return originalQualityIndex;
     }
 
     /**
      * Injection point.
-     * @param qualityIndex Element index of {@link #videoQualities}.
+     * @param userSelectedQualityIndex Element index of {@link #currentQualities}.
      */
-    public static void userChangedQuality(int qualityIndex) {
-        if (shouldRememberVideoQuality()) {
-            userSelectedQualityIndex = qualityIndex;
-            userChangedDefaultQuality = true;
+    public static void userChangedShortsQuality(int userSelectedQualityIndex) {
+        try {
+            if (shouldRememberVideoQuality()) {
+                if (currentQualities == null) {
+                    Logger.printDebug(() -> "Cannot save default quality, qualities is null");
+                    return;
+                }
+                VideoQuality quality = currentQualities.get(userSelectedQualityIndex);
+                saveDefaultQuality(quality.patch_getResolution());
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "userChangedShortsQuality failure", ex);
         }
     }
 
     /**
-     * Injection point.
+     * Injection point.  Regular videos.
      * @param videoResolution Human readable resolution: 480, 720, 1080.
      */
-    public static void userChangedQualityInFlyout(int videoResolution) {
+    public static void userChangedQuality(int videoResolution) {
         Utils.verifyOnMainThread();
-        if (!shouldRememberVideoQuality()) return;
 
-        changeDefaultQuality(videoResolution);
+        if (shouldRememberVideoQuality()) {
+            saveDefaultQuality(videoResolution);
+        }
     }
 
     /**
@@ -207,7 +240,24 @@ public class RememberVideoQualityPatch {
         Utils.verifyOnMainThread();
 
         Logger.printDebug(() -> "newVideoStarted");
+        currentQualities = null;
+        currentQuality = null;
+        currentMenuInterface = null;
         qualityNeedsUpdating = true;
-        videoQualities = null;
+
+        // Hide the quality button until playback starts and the qualities are available.
+        VideoQualityDialogButton.updateButtonIcon(null);
+    }
+
+    /**
+     * Injection point. Fixes bad data used by YouTube.
+     */
+    public static int fixVideoQualityResolution(String name, int quality) {
+        final int correctQuality = 480;
+        if (name.equals("480p") && quality != correctQuality) {
+            return correctQuality;
+        }
+
+        return quality;
     }
 }

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

@@ -671,11 +671,9 @@ public class CustomPlaybackSpeedPatch {
      */
     public static int getAdjustedBackgroundColor(boolean isHandleBar) {
         final int baseColor = Utils.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 Utils.isDarkModeEnabled()
-                ? Utils.adjustColorBrightness(baseColor, darkThemeFactor)  // Lighten for dark theme.
-                : Utils.adjustColorBrightness(baseColor, lightThemeFactor); // Darken for light theme.
+        final float darkThemeFactor = isHandleBar ? 1.25f : 1.115f; // 1.25f for handleBar, 1.115f for others in dark theme.
+        final float lightThemeFactor = isHandleBar ? 0.9f : 0.95f; // 0.9f for handleBar, 0.95f for others in light theme.
+        return Utils.adjustColorBrightness(baseColor, lightThemeFactor, darkThemeFactor);
     }
 }
 

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

@@ -172,6 +172,7 @@ public class Settings extends BaseSettings {
     public static final BooleanSetting HIDE_VIDEO_CHANNEL_WATERMARK = new BooleanSetting("revanced_hide_channel_watermark", TRUE);
     public static final BooleanSetting OPEN_VIDEOS_FULLSCREEN_PORTRAIT = new BooleanSetting("revanced_open_videos_fullscreen_portrait", FALSE);
     public static final BooleanSetting PLAYBACK_SPEED_DIALOG_BUTTON = new BooleanSetting("revanced_playback_speed_dialog_button", FALSE);
+    public static final BooleanSetting VIDEO_QUALITY_DIALOG_BUTTON = new BooleanSetting("revanced_video_quality_dialog_button", FALSE);
     public static final IntegerSetting PLAYER_OVERLAY_OPACITY = new IntegerSetting("revanced_player_overlay_opacity", 100, true);
     public static final BooleanSetting PLAYER_POPUP_PANELS = new BooleanSetting("revanced_hide_player_popup_panels", FALSE);
 

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

@@ -333,10 +333,8 @@ class AbstractPreferenceSearchData<T extends Preference> {
             return text;
         }
 
-        final int baseColor = Utils.getAppBackgroundColor();
-        final int adjustedColor = Utils.isDarkModeEnabled()
-                ? Utils.adjustColorBrightness(baseColor, 1.20f)  // Lighten for dark theme.
-                : Utils.adjustColorBrightness(baseColor, 0.95f); // Darken for light theme.
+        final int adjustedColor = Utils.adjustColorBrightness(Utils.getAppBackgroundColor(),
+                0.95f, 1.20f);
         BackgroundColorSpan highlightSpan = new BackgroundColorSpan(adjustedColor);
 
         SpannableStringBuilder spannable = new SpannableStringBuilder(text);

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

@@ -187,4 +187,56 @@ public class PlayerControlButton {
         if (view != null) view.setVisibility(View.GONE);
         isVisible = false;
     }
-}
+
+    /**
+     * Sets the icon of the button.
+     * @param resourceId Drawable identifier, or zero to hide the icon.
+     */
+    public void setIcon(int resourceId) {
+        try {
+            View button = buttonRef.get();
+            if (button instanceof ImageView imageButton) {
+                imageButton.setImageResource(resourceId);
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "setIcon failure", ex);
+        }
+    }
+
+    /**
+     * Starts an animation on the button.
+     * @param animation The animation to apply.
+     */
+    public void startAnimation(Animation animation) {
+        try {
+            View button = buttonRef.get();
+            if (button != null) {
+                button.startAnimation(animation);
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "startAnimation failure", ex);
+        }
+    }
+
+    /**
+     * Clears any animation on the button.
+     */
+    public void clearAnimation() {
+        try {
+            View button = buttonRef.get();
+            if (button != null) {
+                button.clearAnimation();
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "clearAnimation failure", ex);
+        }
+    }
+
+    /**
+     * Returns the View associated with this button.
+     * @return The button View.
+     */
+    public View getView() {
+        return buttonRef.get();
+    }
+}

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

@@ -0,0 +1,476 @@
+package app.revanced.extension.youtube.videoplayer;
+
+import static app.revanced.extension.shared.StringRef.str;
+import static app.revanced.extension.shared.Utils.dipToPixels;
+import static app.revanced.extension.youtube.patches.playback.quality.RememberVideoQualityPatch.AUTOMATIC_VIDEO_QUALITY_VALUE;
+import static app.revanced.extension.youtube.patches.playback.quality.RememberVideoQualityPatch.VIDEO_QUALITY_1080P_PREMIUM_NAME;
+import static app.revanced.extension.youtube.patches.playback.quality.RememberVideoQualityPatch.VideoQualityMenuInterface;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.RoundRectShape;
+import android.text.Spannable;
+import android.text.SpannableStringBuilder;
+import android.text.style.ForegroundColorSpan;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.animation.Animation;
+import android.view.animation.TranslateAnimation;
+import android.widget.ArrayAdapter;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.android.libraries.youtube.innertube.model.media.VideoQuality;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import app.revanced.extension.shared.Logger;
+import app.revanced.extension.shared.Utils;
+import app.revanced.extension.youtube.patches.playback.quality.RememberVideoQualityPatch;
+import app.revanced.extension.youtube.settings.Settings;
+
+@SuppressWarnings("unused")
+public class VideoQualityDialogButton {
+
+    private static final int DRAWABLE_LD = getDrawableIdentifier("revanced_video_quality_dialog_button_ld");
+    private static final int DRAWABLE_SD = getDrawableIdentifier("revanced_video_quality_dialog_button_sd");
+    private static final int DRAWABLE_HD = getDrawableIdentifier("revanced_video_quality_dialog_button_hd");
+    private static final int DRAWABLE_FHD = getDrawableIdentifier("revanced_video_quality_dialog_button_fhd");
+    private static final int DRAWABLE_FHD_PLUS = getDrawableIdentifier("revanced_video_quality_dialog_button_fhd_plus");
+    private static final int DRAWABLE_QHD = getDrawableIdentifier("revanced_video_quality_dialog_button_qhd");
+    private static final int DRAWABLE_4K = getDrawableIdentifier("revanced_video_quality_dialog_button_4k");
+    private static final int DRAWABLE_UNKNOWN = getDrawableIdentifier("revanced_video_quality_dialog_button_unknown");
+
+    @Nullable
+    private static PlayerControlButton instance;
+
+    /**
+     * The current resource name of the button icon.
+     */
+    private static int currentIconResource;
+
+    private static int getDrawableIdentifier(String resourceName) {
+        final int resourceId = Utils.getResourceIdentifier(resourceName, "drawable");
+        if (resourceId == 0) Logger.printException(() -> "Could not find resource: " + resourceName);
+        return resourceId;
+    }
+
+    /**
+     * Updates the button icon based on the current video quality.
+     */
+    public static void updateButtonIcon(@Nullable VideoQuality quality) {
+        try {
+            Utils.verifyOnMainThread();
+            if (instance == null) return;
+
+            final int resolution = quality == null
+                    ? AUTOMATIC_VIDEO_QUALITY_VALUE // Video is still loading.
+                    : quality.patch_getResolution();
+
+            final int iconResource = switch (resolution) {
+                case 144, 240, 360 -> DRAWABLE_LD;
+                case 480  -> DRAWABLE_SD;
+                case 720  -> DRAWABLE_HD;
+                case 1080 -> VIDEO_QUALITY_1080P_PREMIUM_NAME.equals(quality.patch_getQualityName())
+                        ? DRAWABLE_FHD_PLUS
+                        : DRAWABLE_FHD;
+                case 1440 -> DRAWABLE_QHD;
+                case 2160 -> DRAWABLE_4K;
+                default -> DRAWABLE_UNKNOWN;
+            };
+
+            if (iconResource != currentIconResource) {
+                currentIconResource = iconResource;
+
+                Utils.runOnMainThreadDelayed(() -> {
+                    if (iconResource != currentIconResource) {
+                        Logger.printDebug(() -> "Ignoring stale button update to: " + quality);
+                        return;
+                    }
+                    instance.setIcon(iconResource);
+                }, 100);
+            }
+        } catch (Exception ex) {
+            Logger.printException(() -> "updateButtonIcon failure", ex);
+        }
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void initializeButton(View controlsView) {
+        try {
+            instance = new PlayerControlButton(
+                    controlsView,
+                    "revanced_video_quality_dialog_button",
+                    "revanced_video_quality_dialog_button_placeholder",
+                    Settings.VIDEO_QUALITY_DIALOG_BUTTON::get,
+                    view -> {
+                        try {
+                            showVideoQualityDialog(view.getContext());
+                        } catch (Exception ex) {
+                            Logger.printException(() -> "Video quality button onClick failure", ex);
+                        }
+                    },
+                    view -> {
+                        try {
+                            List<VideoQuality> qualities = RememberVideoQualityPatch.getCurrentQualities();
+                            VideoQualityMenuInterface menu = RememberVideoQualityPatch.getCurrentMenuInterface();
+                            if (qualities == null || menu == null) {
+                                Logger.printDebug(() -> "Cannot reset quality, videoQualities is null");
+                                return true;
+                            }
+
+                            // Reset to default quality.
+                            final int defaultResolution = RememberVideoQualityPatch.getDefaultQualityResolution();
+                            for (VideoQuality quality : qualities) {
+                                final int resolution = quality.patch_getResolution();
+                                if (resolution != AUTOMATIC_VIDEO_QUALITY_VALUE && resolution <= defaultResolution) {
+                                    Logger.printDebug(() -> "Resetting quality to: " + quality);
+                                    menu.patch_setQuality(quality);
+                                    return true;
+                                }
+                            }
+
+                            // Existing hook cannot set default quality to auto.
+                            // Instead show the quality dialog.
+                            showVideoQualityDialog(view.getContext());
+                            return true;
+                        } catch (Exception ex) {
+                            Logger.printException(() -> "Video quality button reset failure", ex);
+                        }
+                        return false;
+                    }
+            );
+
+            // Set initial icon.
+            updateButtonIcon(RememberVideoQualityPatch.getCurrentQuality());
+        } catch (Exception ex) {
+            Logger.printException(() -> "initializeButton failure", ex);
+        }
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void setVisibilityImmediate(boolean visible) {
+        if (instance != null) {
+            instance.setVisibilityImmediate(visible);
+        }
+    }
+
+    /**
+     * Injection point.
+     */
+    public static void setVisibility(boolean visible, boolean animated) {
+        if (instance != null) {
+            instance.setVisibility(visible, animated);
+        }
+    }
+
+    /**
+     * Shows a dialog with available video qualities, excluding Auto, with a title showing the current quality.
+     */
+    private static void showVideoQualityDialog(Context context) {
+        try {
+            List<VideoQuality> currentQualities = RememberVideoQualityPatch.getCurrentQualities();
+            VideoQuality currentQuality = RememberVideoQualityPatch.getCurrentQuality();
+            if (currentQualities == null || currentQuality == null) {
+                Logger.printDebug(() -> "Cannot show qualities dialog, videoQualities is null");
+                return;
+            }
+            if (currentQualities.size() < 2) {
+                // Should never happen.
+                Logger.printException(() -> "Cannot show qualities dialog, no qualities available");
+                return;
+            }
+
+            VideoQualityMenuInterface menu = RememberVideoQualityPatch.getCurrentMenuInterface();
+            if (menu == null) {
+                Logger.printDebug(() -> "Cannot show qualities dialog, menu is null");
+                return;
+            }
+
+            // -1 adjustment for automatic quality at first index.
+            final int listViewSelectedIndex = currentQualities.indexOf(currentQuality) - 1;
+
+            List<String> qualityLabels = new ArrayList<>(currentQualities.size() - 1);
+            for (VideoQuality availableQuality : currentQualities) {
+                if (availableQuality.patch_getResolution() != AUTOMATIC_VIDEO_QUALITY_VALUE) {
+                    qualityLabels.add(availableQuality.patch_getQualityName());
+                }
+            }
+
+            Dialog dialog = new Dialog(context);
+            dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
+            dialog.setCanceledOnTouchOutside(true);
+            dialog.setCancelable(true);
+
+            final int dip4 = dipToPixels(4);   // Height for handle bar.
+            final int dip5 = dipToPixels(5);   // Padding for mainLayout.
+            final int dip6 = dipToPixels(6);   // Bottom margin.
+            final int dip8 = dipToPixels(8);   // Side padding.
+            final int dip16 = dipToPixels(16); // Left padding for ListView.
+            final int dip20 = dipToPixels(20); // Margin below handle.
+            final int dip40 = dipToPixels(40); // Width for handle bar.
+
+            LinearLayout mainLayout = new LinearLayout(context);
+            mainLayout.setOrientation(LinearLayout.VERTICAL);
+            mainLayout.setPadding(dip5, dip8, dip5, dip8);
+
+            ShapeDrawable background = new ShapeDrawable(new RoundRectShape(
+                    Utils.createCornerRadii(12), null, null));
+            background.getPaint().setColor(Utils.getDialogBackgroundColor());
+            mainLayout.setBackground(background);
+
+            View handleBar = new View(context);
+            ShapeDrawable handleBackground = new ShapeDrawable(new RoundRectShape(
+                    Utils.createCornerRadii(4), null, null));
+            final int baseColor = Utils.getDialogBackgroundColor();
+            final int adjustedHandleBarBackgroundColor = Utils.adjustColorBrightness(
+                    baseColor, 0.9f, 1.25f);
+            handleBackground.getPaint().setColor(adjustedHandleBarBackgroundColor);
+            handleBar.setBackground(handleBackground);
+            LinearLayout.LayoutParams handleParams = new LinearLayout.LayoutParams(dip40, dip4);
+            handleParams.gravity = Gravity.CENTER_HORIZONTAL;
+            handleParams.setMargins(0, 0, 0, dip20);
+            handleBar.setLayoutParams(handleParams);
+            mainLayout.addView(handleBar);
+
+            // Create SpannableStringBuilder for formatted text.
+            SpannableStringBuilder spannableTitle = new SpannableStringBuilder();
+            String titlePart = str("video_quality_quick_menu_title");
+            String separatorPart = str("video_quality_title_seperator");
+
+            // Append title part with default foreground color.
+            spannableTitle.append(titlePart);
+            spannableTitle.setSpan(
+                    new ForegroundColorSpan(Utils.getAppForegroundColor()),
+                    0,
+                    titlePart.length(),
+                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
+            );
+            spannableTitle.append("   "); // Space after title.
+
+            // Append separator part with adjusted title color.
+            int separatorStart = spannableTitle.length();
+            spannableTitle.append(separatorPart);
+            final int adjustedTitleForegroundColor = Utils.adjustColorBrightness(
+                    Utils.getAppForegroundColor(), 1.6f, 0.6f);
+            spannableTitle.setSpan(
+                    new ForegroundColorSpan(adjustedTitleForegroundColor),
+                    separatorStart,
+                    separatorStart + separatorPart.length(),
+                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
+            );
+            spannableTitle.append("   "); // Space after separator.
+
+            // Append quality label with adjusted title color.
+            final int qualityStart = spannableTitle.length();
+            spannableTitle.append(currentQuality.patch_getQualityName());
+            spannableTitle.setSpan(
+                    new ForegroundColorSpan(adjustedTitleForegroundColor),
+                    qualityStart,
+                    qualityStart + currentQuality.patch_getQualityName().length(),
+                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
+            );
+
+            // Add title with current quality.
+            TextView titleView = new TextView(context);
+            titleView.setText(spannableTitle);
+            titleView.setTextSize(16);
+            // Remove setTextColor since color is handled by SpannableStringBuilder.
+            LinearLayout.LayoutParams titleParams = new LinearLayout.LayoutParams(
+                    LinearLayout.LayoutParams.WRAP_CONTENT,
+                    LinearLayout.LayoutParams.WRAP_CONTENT);
+            titleParams.setMargins(dip8, 0, 0, dip20);
+            titleView.setLayoutParams(titleParams);
+            mainLayout.addView(titleView);
+
+            ListView listView = new ListView(context);
+            CustomQualityAdapter adapter = new CustomQualityAdapter(context, qualityLabels);
+            adapter.setSelectedPosition(listViewSelectedIndex);
+            listView.setAdapter(adapter);
+            listView.setDivider(null);
+            listView.setPadding(dip16, 0, 0, 0);
+
+            listView.setOnItemClickListener((parent, view, which, id) -> {
+                try {
+                    final int originalIndex = which + 1; // Adjust for automatic.
+                    VideoQuality selectedQuality = currentQualities.get(originalIndex);
+                    Logger.printDebug(() -> "User clicked on quality: " + selectedQuality);
+
+                    if (RememberVideoQualityPatch.shouldRememberVideoQuality()) {
+                        RememberVideoQualityPatch.saveDefaultQuality(selectedQuality.patch_getResolution());
+                    }
+                    // Don't update button icon now. Icon will update when the actual
+                    // quality is changed by YT.  This is needed to ensure the icon is correct
+                    // if YT ignores changing from 1080p Premium to regular 1080p.
+                    menu.patch_setQuality(selectedQuality);
+
+                    dialog.dismiss();
+                } catch (Exception ex) {
+                    Logger.printException(() -> "Video quality selection failure", ex);
+                }
+            });
+
+            LinearLayout.LayoutParams listViewParams = new LinearLayout.LayoutParams(
+                    LinearLayout.LayoutParams.MATCH_PARENT,
+                    LinearLayout.LayoutParams.WRAP_CONTENT);
+            listViewParams.setMargins(0, 0, 0, dip5);
+            listView.setLayoutParams(listViewParams);
+            mainLayout.addView(listView);
+
+            LinearLayout wrapperLayout = new LinearLayout(context);
+            wrapperLayout.setOrientation(LinearLayout.VERTICAL);
+            wrapperLayout.setPadding(dip8, 0, dip8, 0);
+            wrapperLayout.addView(mainLayout);
+            dialog.setContentView(wrapperLayout);
+
+            Window window = dialog.getWindow();
+            if (window != null) {
+                WindowManager.LayoutParams params = window.getAttributes();
+                params.gravity = Gravity.BOTTOM;
+                params.y = dip6;
+                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;
+                params.height = WindowManager.LayoutParams.WRAP_CONTENT;
+                window.setAttributes(params);
+                window.setBackgroundDrawable(null);
+            }
+
+            final int fadeDurationFast = Utils.getResourceInteger("fade_duration_fast");
+            Animation slideInABottomAnimation = Utils.getResourceAnimation("slide_in_bottom");
+            slideInABottomAnimation.setDuration(fadeDurationFast);
+            mainLayout.startAnimation(slideInABottomAnimation);
+
+            // noinspection ClickableViewAccessibility
+            mainLayout.setOnTouchListener(new View.OnTouchListener() {
+                final float dismissThreshold = dipToPixels(100);
+                float touchY;
+                float translationY;
+
+                @Override
+                public boolean onTouch(View v, MotionEvent event) {
+                    switch (event.getAction()) {
+                        case MotionEvent.ACTION_DOWN:
+                            touchY = event.getRawY();
+                            translationY = mainLayout.getTranslationY();
+                            return true;
+                        case MotionEvent.ACTION_MOVE:
+                            final float deltaY = event.getRawY() - touchY;
+                            if (deltaY >= 0) {
+                                mainLayout.setTranslationY(translationY + deltaY);
+                            }
+                            return true;
+                        case MotionEvent.ACTION_UP:
+                        case MotionEvent.ACTION_CANCEL:
+                            if (mainLayout.getTranslationY() > dismissThreshold) {
+                                //noinspection ExtractMethodRecommender
+                                final float remainingDistance = context.getResources().getDisplayMetrics().heightPixels
+                                        - mainLayout.getTop();
+                                TranslateAnimation slideOut = new TranslateAnimation(
+                                        0, 0, mainLayout.getTranslationY(), remainingDistance);
+                                slideOut.setDuration(fadeDurationFast);
+                                slideOut.setAnimationListener(new Animation.AnimationListener() {
+                                    @Override
+                                    public void onAnimationStart(Animation animation) {}
+                                    @Override
+                                    public void onAnimationEnd(Animation animation) {
+                                        dialog.dismiss();
+                                    }
+                                    @Override
+                                    public void onAnimationRepeat(Animation animation) {}
+                                });
+                                mainLayout.startAnimation(slideOut);
+                            } else {
+                                TranslateAnimation slideBack = new TranslateAnimation(
+                                        0, 0, mainLayout.getTranslationY(), 0);
+                                slideBack.setDuration(fadeDurationFast);
+                                mainLayout.startAnimation(slideBack);
+                                mainLayout.setTranslationY(0);
+                            }
+                            return true;
+                        default:
+                            return false;
+                    }
+                }
+            });
+
+            dialog.show();
+        } catch (Exception ex) {
+            Logger.printException(() -> "showVideoQualityDialog failure", ex);
+        }
+    }
+
+    private static class CustomQualityAdapter extends ArrayAdapter<String> {
+        private int selectedPosition = -1;
+
+        public CustomQualityAdapter(@NonNull Context context, @NonNull List<String> objects) {
+            super(context, 0, objects);
+        }
+
+        private void setSelectedPosition(int position) {
+            this.selectedPosition = position;
+            notifyDataSetChanged();
+        }
+
+        @NonNull
+        @Override
+        public View getView(int position, @Nullable View convertView, @NonNull ViewGroup parent) {
+            ViewHolder viewHolder;
+
+            if (convertView == null) {
+                convertView = LayoutInflater.from(getContext()).inflate(
+                        Utils.getResourceIdentifier("revanced_custom_list_item_checked", "layout"),
+                        parent,
+                        false
+                );
+                viewHolder = new ViewHolder();
+                viewHolder.checkIcon = convertView.findViewById(
+                        Utils.getResourceIdentifier("revanced_check_icon", "id")
+                );
+                viewHolder.placeholder = convertView.findViewById(
+                        Utils.getResourceIdentifier("revanced_check_icon_placeholder", "id")
+                );
+                viewHolder.textView = convertView.findViewById(
+                        Utils.getResourceIdentifier("revanced_item_text", "id")
+                );
+                convertView.setTag(viewHolder);
+            } else {
+                viewHolder = (ViewHolder) convertView.getTag();
+            }
+
+            viewHolder.textView.setText(getItem(position));
+            final boolean isSelected = position == selectedPosition;
+            viewHolder.checkIcon.setVisibility(isSelected ? View.VISIBLE : View.GONE);
+            viewHolder.placeholder.setVisibility(isSelected ? View.GONE : View.INVISIBLE);
+
+            return convertView;
+        }
+
+        private static class ViewHolder {
+            ImageView checkIcon;
+            View placeholder;
+            TextView textView;
+        }
+    }
+}