mirror of
https://github.com/revanced/revanced-patches.git
synced 2025-06-12 05:07:45 +02:00
feat(YouTube - Settings): Add a color picker (#4981)
Co-authored-by: LisoUseInAIKyrios <118716522+LisoUseInAIKyrios@users.noreply.github.com>
This commit is contained in:
MarcaD
@ -23,6 +23,7 @@ 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;
|
||||
@ -557,14 +558,14 @@ public class Utils {
|
||||
);
|
||||
}
|
||||
|
||||
public static boolean isDarkModeEnabled(Context context) {
|
||||
Configuration config = context.getResources().getConfiguration();
|
||||
public static boolean isDarkModeEnabled() {
|
||||
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;
|
||||
}
|
||||
|
||||
@ -640,7 +641,11 @@ public class Utils {
|
||||
|| networkType == NetworkType.OTHER;
|
||||
}
|
||||
|
||||
@SuppressLint({"MissingPermission", "deprecation"}) // Permission already included in YouTube.
|
||||
/**
|
||||
* Calling extension code must ensure the target app has the
|
||||
* <code>ACCESS_NETWORK_STATE</code> app manifest permission.
|
||||
*/
|
||||
@SuppressWarnings({"deprecation", "MissingPermission"})
|
||||
public static NetworkType getNetworkType() {
|
||||
Context networkContext = getContext();
|
||||
if (networkContext == null) {
|
||||
@ -852,6 +857,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));
|
||||
}
|
||||
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
Reference in New Issue
Block a user