mirror of
https://github.com/material-components/material-components-android.git
synced 2026-01-18 19:11:39 +08:00
072578dde6
Move the unchecked and checked state calculation off from each invalidate() call to onCreateDrawableState() so we can make sure we will only calculate the states when needed. PiperOrigin-RevId: 452092712
696 lines
24 KiB
Java
696 lines
24 KiB
Java
/*
|
|
* Copyright (C) 2022 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.google.android.material.materialswitch;
|
|
|
|
import com.google.android.material.R;
|
|
|
|
import static androidx.core.graphics.ColorUtils.blendARGB;
|
|
import static com.google.android.material.theme.overlay.MaterialThemeOverlay.wrap;
|
|
|
|
import android.annotation.SuppressLint;
|
|
import android.content.Context;
|
|
import android.content.res.ColorStateList;
|
|
import android.graphics.PorterDuff;
|
|
import android.graphics.PorterDuff.Mode;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.graphics.drawable.LayerDrawable;
|
|
import android.os.Build.VERSION;
|
|
import android.os.Build.VERSION_CODES;
|
|
import androidx.appcompat.content.res.AppCompatResources;
|
|
import androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat;
|
|
import androidx.appcompat.widget.DrawableUtils;
|
|
import androidx.appcompat.widget.SwitchCompat;
|
|
import androidx.appcompat.widget.TintTypedArray;
|
|
import android.util.AttributeSet;
|
|
import android.view.Gravity;
|
|
import androidx.annotation.DrawableRes;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.core.graphics.drawable.DrawableCompat;
|
|
import com.google.android.material.internal.ThemeEnforcement;
|
|
import com.google.android.material.internal.ViewUtils;
|
|
import java.lang.reflect.Field;
|
|
import java.util.Arrays;
|
|
|
|
/**
|
|
* A class that creates a Material Themed Switch. This class is intended to provide a brand new
|
|
* Switch design and replace the obsolete
|
|
* {@link com.google.android.material.switchmaterial.SwitchMaterial} class.
|
|
*/
|
|
public class MaterialSwitch extends SwitchCompat {
|
|
private static final int DEF_STYLE_RES = R.style.Widget_Material3_CompoundButton_MaterialSwitch;
|
|
private static final int[] STATE_SET_WITH_ICON = { R.attr.state_with_icon };
|
|
|
|
@NonNull private final SwitchWidth switchWidth = SwitchWidth.create(this);
|
|
@NonNull private final ThumbPosition thumbPosition = new ThumbPosition();
|
|
|
|
@Nullable private Drawable thumbDrawable;
|
|
@Nullable private Drawable thumbIconDrawable;
|
|
|
|
@Nullable private Drawable trackDrawable;
|
|
@Nullable private Drawable trackDecorationDrawable;
|
|
|
|
@Nullable private ColorStateList thumbTintList;
|
|
@Nullable private ColorStateList thumbIconTintList;
|
|
@NonNull private PorterDuff.Mode thumbIconTintMode;
|
|
@Nullable private ColorStateList trackTintList;
|
|
@Nullable private ColorStateList trackDecorationTintList;
|
|
@NonNull private PorterDuff.Mode trackDecorationTintMode;
|
|
|
|
private int[] currentStateUnchecked;
|
|
private int[] currentStateChecked;
|
|
|
|
public MaterialSwitch(@NonNull Context context) {
|
|
this(context, null);
|
|
}
|
|
|
|
public MaterialSwitch(@NonNull Context context, @Nullable AttributeSet attrs) {
|
|
this(context, attrs, R.attr.materialSwitchStyle);
|
|
}
|
|
|
|
public MaterialSwitch(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
|
|
super(wrap(context, attrs, defStyleAttr, DEF_STYLE_RES), attrs, defStyleAttr);
|
|
// Ensure we are using the correctly themed context rather than the context that was passed in.
|
|
context = getContext();
|
|
|
|
thumbDrawable = super.getThumbDrawable();
|
|
thumbTintList = super.getThumbTintList();
|
|
super.setThumbTintList(null); // Always use our custom tinting logic
|
|
|
|
trackDrawable = super.getTrackDrawable();
|
|
trackTintList = super.getTrackTintList();
|
|
super.setTrackTintList(null); // Always use our custom tinting logic
|
|
|
|
TintTypedArray attributes =
|
|
ThemeEnforcement.obtainTintedStyledAttributes(
|
|
context, attrs, R.styleable.MaterialSwitch, defStyleAttr, DEF_STYLE_RES);
|
|
|
|
thumbIconDrawable = attributes.getDrawable(R.styleable.MaterialSwitch_thumbIcon);
|
|
thumbIconTintList = attributes.getColorStateList(R.styleable.MaterialSwitch_thumbIconTint);
|
|
thumbIconTintMode =
|
|
DrawableUtils.parseTintMode(
|
|
attributes.getInt(R.styleable.MaterialSwitch_thumbIconTintMode, -1), Mode.SRC_IN);
|
|
|
|
trackDecorationDrawable =
|
|
attributes.getDrawable(R.styleable.MaterialSwitch_trackDecoration);
|
|
trackDecorationTintList =
|
|
attributes.getColorStateList(R.styleable.MaterialSwitch_trackDecorationTint);
|
|
trackDecorationTintMode =
|
|
DrawableUtils.parseTintMode(
|
|
attributes.getInt(R.styleable.MaterialSwitch_trackDecorationTintMode, -1), Mode.SRC_IN);
|
|
|
|
attributes.recycle();
|
|
|
|
refreshThumbDrawable();
|
|
refreshTrackDrawable();
|
|
}
|
|
|
|
// TODO(b/227338106): remove this workaround and move to use setEnforceSwitchWidth(false) after
|
|
// AppCompat 1.6.0-stable is released.
|
|
@Override
|
|
public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
|
|
switchWidth.set(getSwitchMinWidth());
|
|
}
|
|
|
|
@Override
|
|
public void invalidate() {
|
|
// ThumbPosition update will trigger invalidate(), update thumb/track tint here.
|
|
if (thumbPosition != null) {
|
|
// This may happen when super classes' constructors call this method.
|
|
updateDrawableTints();
|
|
}
|
|
super.invalidate();
|
|
}
|
|
|
|
@Override
|
|
protected int[] onCreateDrawableState(int extraSpace) {
|
|
int[] drawableState = super.onCreateDrawableState(extraSpace + 1);
|
|
|
|
if (thumbIconDrawable != null) {
|
|
mergeDrawableStates(drawableState, STATE_SET_WITH_ICON);
|
|
}
|
|
|
|
currentStateUnchecked = getUncheckedState(drawableState);
|
|
currentStateChecked = getCheckedState(drawableState);
|
|
|
|
return drawableState;
|
|
}
|
|
|
|
// TODO(b/227338106): remove this workaround and move to use setEnforceSwitchWidth(false) after
|
|
// AppCompat 1.6.0-stable is released.
|
|
@Override
|
|
public int getCompoundPaddingLeft() {
|
|
if (!ViewUtils.isLayoutRtl(this)) {
|
|
return super.getCompoundPaddingLeft();
|
|
}
|
|
// Compound paddings are used during onMeasure() to decide the component width, at that time
|
|
// the switch width is not overridden yet so we need to adjust the value to make measurement
|
|
// right. This can be removed after the workaround is removed.
|
|
return super.getCompoundPaddingLeft() - switchWidth.get() + getSwitchMinWidth();
|
|
}
|
|
|
|
// TODO(b/227338106): remove this workaround and move to use setEnforceSwitchWidth(false) after
|
|
// AppCompat 1.6.0-stable is released.
|
|
@Override
|
|
public int getCompoundPaddingRight() {
|
|
if (ViewUtils.isLayoutRtl(this)) {
|
|
return super.getCompoundPaddingRight();
|
|
}
|
|
// Compound paddings are used during onMeasure() to decide the component width, at that time
|
|
// the switch width is not overridden yet so we need to adjust the value to make measurement
|
|
// right. This can be removed after the workaround is removed.
|
|
return super.getCompoundPaddingRight() - switchWidth.get() + getSwitchMinWidth();
|
|
}
|
|
|
|
@Override
|
|
public void setThumbDrawable(@Nullable Drawable drawable) {
|
|
thumbDrawable = drawable;
|
|
refreshThumbDrawable();
|
|
}
|
|
|
|
@Override
|
|
@Nullable
|
|
public Drawable getThumbDrawable() {
|
|
return thumbDrawable;
|
|
}
|
|
|
|
@Override
|
|
public void setThumbTintList(@Nullable ColorStateList tintList) {
|
|
thumbTintList = tintList;
|
|
refreshThumbDrawable();
|
|
}
|
|
|
|
@Override
|
|
@Nullable
|
|
public ColorStateList getThumbTintList() {
|
|
return thumbTintList;
|
|
}
|
|
|
|
@Override
|
|
public void setThumbTintMode(@Nullable PorterDuff.Mode tintMode) {
|
|
super.setThumbTintMode(tintMode);
|
|
refreshThumbDrawable();
|
|
}
|
|
|
|
/**
|
|
* Sets the drawable used for the thumb icon that will be drawn upon the thumb.
|
|
*
|
|
* @param resId Resource ID of a thumb icon drawable
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_thumbIcon
|
|
*/
|
|
public void setThumbIconResource(@DrawableRes int resId) {
|
|
setThumbIconDrawable(AppCompatResources.getDrawable(getContext(), resId));
|
|
}
|
|
|
|
/**
|
|
* Sets the drawable used for the thumb icon that will be drawn upon the thumb.
|
|
*
|
|
* @param icon Thumb icon drawable
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_thumbIcon
|
|
*/
|
|
public void setThumbIconDrawable(@Nullable Drawable icon) {
|
|
thumbIconDrawable = icon;
|
|
refreshThumbDrawable();
|
|
}
|
|
|
|
/**
|
|
* Gets the drawable used for the thumb icon that will be drawn upon the thumb.
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_thumbIcon
|
|
*/
|
|
@Nullable
|
|
public Drawable getThumbIconDrawable() {
|
|
return thumbIconDrawable;
|
|
}
|
|
|
|
/**
|
|
* Applies a tint to the thumb icon drawable. Does not modify the current
|
|
* tint mode, which is {@link PorterDuff.Mode#SRC_IN} by default.
|
|
* <p>
|
|
* Subsequent calls to {@link #setThumbIconDrawable(Drawable)} will
|
|
* automatically mutate the drawable and apply the specified tint and tint
|
|
* mode using {@link DrawableCompat#setTintList(Drawable, ColorStateList)}.
|
|
*
|
|
* @param tintList the tint to apply, may be {@code null} to clear tint
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_thumbIconTint
|
|
*/
|
|
public void setThumbIconTintList(@Nullable ColorStateList tintList) {
|
|
thumbIconTintList = tintList;
|
|
refreshThumbDrawable();
|
|
}
|
|
|
|
/**
|
|
* Returns the tint applied to the thumb icon drawable
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_thumbIconTint
|
|
*/
|
|
@Nullable
|
|
public ColorStateList getThumbIconTintList() {
|
|
return thumbIconTintList;
|
|
}
|
|
|
|
/**
|
|
* Specifies the blending mode used to apply the tint specified by
|
|
* {@link #setThumbIconTintList(ColorStateList)}} to the thumb icon drawable.
|
|
* The default mode is {@link PorterDuff.Mode#SRC_IN}.
|
|
*
|
|
* @param tintMode the blending mode used to apply the tint
|
|
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_thumbIconTintMode
|
|
*/
|
|
public void setThumbIconTintMode(@NonNull PorterDuff.Mode tintMode) {
|
|
thumbIconTintMode = tintMode;
|
|
refreshThumbDrawable();
|
|
}
|
|
|
|
/**
|
|
* Returns the blending mode used to apply the tint to the thumb icon drawable
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_thumbIconTintMode
|
|
*/
|
|
@NonNull
|
|
public PorterDuff.Mode getThumbIconTintMode() {
|
|
return thumbIconTintMode;
|
|
}
|
|
|
|
@Override
|
|
public void setTrackDrawable(@Nullable Drawable track) {
|
|
trackDrawable = track;
|
|
refreshTrackDrawable();
|
|
}
|
|
|
|
@Override
|
|
@Nullable
|
|
public Drawable getTrackDrawable() {
|
|
return trackDrawable;
|
|
}
|
|
|
|
@Override
|
|
public void setTrackTintList(@Nullable ColorStateList tintList) {
|
|
trackTintList = tintList;
|
|
refreshTrackDrawable();
|
|
}
|
|
|
|
@Override
|
|
@Nullable
|
|
public ColorStateList getTrackTintList() {
|
|
return trackTintList;
|
|
}
|
|
|
|
@Override
|
|
public void setTrackTintMode(@Nullable PorterDuff.Mode tintMode) {
|
|
super.setTrackTintMode(tintMode);
|
|
refreshTrackDrawable();
|
|
}
|
|
|
|
/**
|
|
* Set the drawable used for the track decoration that will be drawn upon the track.
|
|
*
|
|
* @param resId Resource ID of a track decoration drawable
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_trackDecoration
|
|
*/
|
|
public void setTrackDecorationResource(@DrawableRes int resId) {
|
|
setTrackDecorationDrawable(AppCompatResources.getDrawable(getContext(), resId));
|
|
}
|
|
|
|
/**
|
|
* Set the drawable used for the track decoration that will be drawn upon the track.
|
|
*
|
|
* @param trackDecoration Track decoration drawable
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_trackDecoration
|
|
*/
|
|
public void setTrackDecorationDrawable(@Nullable Drawable trackDecoration) {
|
|
trackDecorationDrawable = trackDecoration;
|
|
refreshTrackDrawable();
|
|
}
|
|
|
|
/**
|
|
* Get the drawable used for the track decoration that will be drawn upon the track.
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_trackDecoration
|
|
*/
|
|
@Nullable
|
|
public Drawable getTrackDecorationDrawable() {
|
|
return trackDecorationDrawable;
|
|
}
|
|
|
|
/**
|
|
* Applies a tint to the track decoration drawable. Does not modify the current
|
|
* tint mode, which is {@link PorterDuff.Mode#SRC_IN} by default.
|
|
*
|
|
* <p>Subsequent calls to {@link #setTrackDecorationDrawable(Drawable)} will
|
|
* automatically mutate the drawable and apply the specified tint and tint
|
|
* mode using {@link DrawableCompat#setTintList(Drawable, ColorStateList)}.
|
|
*
|
|
* @param tintList the tint to apply, may be {@code null} to clear tint
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_trackDecorationTint
|
|
*/
|
|
public void setTrackDecorationTintList(@Nullable ColorStateList tintList) {
|
|
trackDecorationTintList = tintList;
|
|
refreshTrackDrawable();
|
|
}
|
|
|
|
/**
|
|
* Returns the tint applied to the track decoration drawable
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_trackDecorationTint
|
|
*/
|
|
@Nullable
|
|
public ColorStateList getTrackDecorationTintList() {
|
|
return trackDecorationTintList;
|
|
}
|
|
|
|
/**
|
|
* Specifies the blending mode used to apply the tint specified by
|
|
* {@link #setTrackDecorationTintList(ColorStateList)}} to the track decoration drawable.
|
|
* The default mode is {@link PorterDuff.Mode#SRC_IN}.
|
|
*
|
|
* @param tintMode the blending mode used to apply the tint
|
|
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_trackDecorationTintMode
|
|
*/
|
|
public void setTrackDecorationTintMode(@NonNull PorterDuff.Mode tintMode) {
|
|
trackDecorationTintMode = tintMode;
|
|
refreshTrackDrawable();
|
|
}
|
|
|
|
/**
|
|
* Returns the blending mode used to apply the tint to the track decoration drawable
|
|
*
|
|
* @attr ref com.google.android.material.R.styleable#MaterialSwitch_trackDecorationTintMode
|
|
*/
|
|
@NonNull
|
|
public PorterDuff.Mode getTrackDecorationTintMode() {
|
|
return trackDecorationTintMode;
|
|
}
|
|
|
|
// TODO(b/227338106): remove this workaround to use super.getThumbPosition() directly after
|
|
// AppCompat 1.6.0-stable is released.
|
|
private float getThumbPos() {
|
|
return thumbPosition.get();
|
|
}
|
|
|
|
private void refreshThumbDrawable() {
|
|
thumbDrawable =
|
|
createTintableDrawableIfNeeded(thumbDrawable, thumbTintList, getThumbTintMode());
|
|
thumbIconDrawable =
|
|
createTintableDrawableIfNeeded(thumbIconDrawable, thumbIconTintList, thumbIconTintMode);
|
|
|
|
updateDrawableTints();
|
|
|
|
super.setThumbDrawable(compositeThumbAndIconDrawable(thumbDrawable, thumbIconDrawable));
|
|
|
|
refreshDrawableState();
|
|
}
|
|
|
|
@Nullable
|
|
private static Drawable compositeThumbAndIconDrawable(
|
|
@Nullable Drawable thumbDrawable, @Nullable Drawable thumbIconDrawable) {
|
|
if (thumbDrawable == null) {
|
|
return thumbIconDrawable;
|
|
}
|
|
if (thumbIconDrawable == null) {
|
|
return thumbDrawable;
|
|
}
|
|
LayerDrawable drawable = new LayerDrawable(new Drawable[]{thumbDrawable, thumbIconDrawable});
|
|
int iconNewWidth;
|
|
int iconNewHeight;
|
|
if (thumbIconDrawable.getIntrinsicWidth() <= thumbDrawable.getIntrinsicWidth()
|
|
&& thumbIconDrawable.getIntrinsicHeight() <= thumbDrawable.getIntrinsicHeight()) {
|
|
// If the icon is smaller than the thumb in both its width and height, keep icon's size.
|
|
iconNewWidth = thumbIconDrawable.getIntrinsicWidth();
|
|
iconNewHeight = thumbIconDrawable.getIntrinsicHeight();
|
|
} else {
|
|
float thumbIconRatio =
|
|
(float) thumbIconDrawable.getIntrinsicWidth() / thumbIconDrawable.getIntrinsicHeight();
|
|
float thumbRatio =
|
|
(float) thumbDrawable.getIntrinsicWidth() / thumbDrawable.getIntrinsicHeight();
|
|
if (thumbIconRatio >= thumbRatio) {
|
|
// If the icon is wider in ratio than the thumb, shrink it according to its width.
|
|
iconNewWidth = thumbDrawable.getIntrinsicWidth();
|
|
iconNewHeight = (int) (iconNewWidth / thumbIconRatio);
|
|
} else {
|
|
// If the icon is taller in ratio than the thumb, shrink it according to its height.
|
|
iconNewHeight = thumbDrawable.getIntrinsicHeight();
|
|
iconNewWidth = (int) (thumbIconRatio * iconNewHeight);
|
|
}
|
|
}
|
|
// Centers the icon inside the thumb. Before M there's no layer gravity support, we need to use
|
|
// layer insets to adjust the icon position manually.
|
|
if (VERSION.SDK_INT >= VERSION_CODES.M) {
|
|
drawable.setLayerSize(1, iconNewWidth, iconNewHeight);
|
|
drawable.setLayerGravity(1, Gravity.CENTER);
|
|
} else {
|
|
int horizontalInset = (thumbDrawable.getIntrinsicWidth() - iconNewWidth) / 2;
|
|
int verticalInset = (thumbDrawable.getIntrinsicHeight() - iconNewHeight) / 2;
|
|
drawable.setLayerInset(1, horizontalInset, verticalInset, horizontalInset, verticalInset);
|
|
}
|
|
return drawable;
|
|
}
|
|
|
|
private void refreshTrackDrawable() {
|
|
trackDrawable =
|
|
createTintableDrawableIfNeeded(trackDrawable, trackTintList, getTrackTintMode());
|
|
trackDecorationDrawable =
|
|
createTintableDrawableIfNeeded(
|
|
trackDecorationDrawable, trackDecorationTintList, trackDecorationTintMode);
|
|
|
|
updateDrawableTints();
|
|
|
|
Drawable finalTrackDrawable;
|
|
if (trackDrawable != null && trackDecorationDrawable != null) {
|
|
finalTrackDrawable =
|
|
new LayerDrawable(new Drawable[]{ trackDrawable, trackDecorationDrawable});
|
|
} else if (trackDrawable != null) {
|
|
finalTrackDrawable = trackDrawable;
|
|
} else {
|
|
finalTrackDrawable = trackDecorationDrawable;
|
|
}
|
|
if (finalTrackDrawable != null) {
|
|
setSwitchMinWidth(finalTrackDrawable.getIntrinsicWidth());
|
|
}
|
|
super.setTrackDrawable(finalTrackDrawable);
|
|
}
|
|
|
|
private void updateDrawableTints() {
|
|
if (thumbTintList == null
|
|
&& thumbIconTintList == null
|
|
&& trackTintList == null
|
|
&& trackDecorationTintList == null) {
|
|
// Early return to avoid heavy operation.
|
|
return;
|
|
}
|
|
|
|
float thumbPosition = getThumbPos();
|
|
|
|
if (thumbTintList != null) {
|
|
setInterpolatedDrawableTintIfPossible(
|
|
thumbDrawable, thumbTintList, currentStateUnchecked, currentStateChecked, thumbPosition);
|
|
}
|
|
|
|
if (thumbIconTintList != null) {
|
|
setInterpolatedDrawableTintIfPossible(
|
|
thumbIconDrawable,
|
|
thumbIconTintList,
|
|
currentStateUnchecked,
|
|
currentStateChecked,
|
|
thumbPosition);
|
|
}
|
|
|
|
if (trackTintList != null) {
|
|
setInterpolatedDrawableTintIfPossible(
|
|
trackDrawable, trackTintList, currentStateUnchecked, currentStateChecked, thumbPosition);
|
|
}
|
|
|
|
if (trackDecorationTintList != null) {
|
|
setInterpolatedDrawableTintIfPossible(
|
|
trackDecorationDrawable,
|
|
trackDecorationTintList,
|
|
currentStateUnchecked,
|
|
currentStateChecked,
|
|
thumbPosition);
|
|
}
|
|
}
|
|
|
|
/** Returns a new state that removes the checked state from the input state. */
|
|
private static int[] getUncheckedState(int[] state) {
|
|
int[] newState = new int[state.length];
|
|
int i = 0;
|
|
for (int subState : state) {
|
|
if (subState != android.R.attr.state_checked) {
|
|
newState[i++] = subState;
|
|
}
|
|
}
|
|
return newState;
|
|
}
|
|
|
|
/** Returns a new state that adds the checked state to the input state. */
|
|
private static int[] getCheckedState(int[] state) {
|
|
for (int i = 0; i < state.length; i++) {
|
|
if (state[i] == android.R.attr.state_checked) {
|
|
return state;
|
|
} else if (state[i] == 0) {
|
|
int[] newState = state.clone();
|
|
newState[i] = android.R.attr.state_checked;
|
|
return newState;
|
|
}
|
|
}
|
|
int[] newState = Arrays.copyOf(state, state.length + 1);
|
|
newState[state.length] = android.R.attr.state_checked;
|
|
return newState;
|
|
}
|
|
|
|
/**
|
|
* Tints the given drawable with the interpolated color according to the provided thumb position
|
|
* between unchecked and checked states. The reference color in unchecked and checked states will
|
|
* be retrieved from the given {@link ColorStateList} according to the provided states.
|
|
*/
|
|
private static void setInterpolatedDrawableTintIfPossible(
|
|
@Nullable Drawable drawable,
|
|
@Nullable ColorStateList tint,
|
|
@NonNull int[] stateUnchecked,
|
|
@NonNull int[] stateChecked,
|
|
float thumbPosition) {
|
|
if (drawable == null || tint == null) {
|
|
return;
|
|
}
|
|
// TODO(b/232529333): remove this workaround after updating AppCompat version to 1.6.
|
|
if (drawable instanceof AnimatedStateListDrawableCompat
|
|
&& VERSION.SDK_INT < VERSION_CODES.LOLLIPOP) {
|
|
DrawableCompat.setTintList(
|
|
drawable,
|
|
ColorStateList.valueOf(
|
|
blendARGB(
|
|
tint.getColorForState(stateUnchecked, 0),
|
|
tint.getColorForState(stateChecked, 0),
|
|
thumbPosition)));
|
|
return;
|
|
}
|
|
DrawableCompat.setTint(
|
|
drawable,
|
|
blendARGB(
|
|
tint.getColorForState(stateUnchecked, 0),
|
|
tint.getColorForState(stateChecked, 0),
|
|
thumbPosition));
|
|
}
|
|
|
|
private static Drawable createTintableDrawableIfNeeded(
|
|
Drawable drawable, ColorStateList tintList, Mode tintMode) {
|
|
if (drawable == null) {
|
|
return null;
|
|
}
|
|
if (tintList != null) {
|
|
drawable = DrawableCompat.wrap(drawable).mutate();
|
|
if (tintMode != null) {
|
|
DrawableCompat.setTintMode(drawable, tintMode);
|
|
}
|
|
}
|
|
return drawable;
|
|
}
|
|
|
|
// TODO(b/227338106): remove this workaround and move to use setEnforceSwitchWidth(false) after
|
|
// AppCompat 1.6.0-stable is released.
|
|
@SuppressLint("PrivateApi")
|
|
private static final class SwitchWidth {
|
|
|
|
@NonNull private final MaterialSwitch materialSwitch;
|
|
@Nullable private final Field switchWidthField;
|
|
|
|
@NonNull
|
|
static SwitchWidth create(@NonNull MaterialSwitch materialSwitch) {
|
|
return new SwitchWidth(materialSwitch, createSwitchWidthField());
|
|
}
|
|
|
|
private SwitchWidth(@NonNull MaterialSwitch materialSwitch, @Nullable Field switchWidthField) {
|
|
this.materialSwitch = materialSwitch;
|
|
this.switchWidthField = switchWidthField;
|
|
}
|
|
|
|
int get() {
|
|
try {
|
|
if (switchWidthField != null) {
|
|
return switchWidthField.getInt(materialSwitch);
|
|
}
|
|
} catch (IllegalAccessException e) {
|
|
// Fall through
|
|
}
|
|
// Return getSwitchMinWidth() so no width adjustment will be done.
|
|
return materialSwitch.getSwitchMinWidth();
|
|
}
|
|
|
|
void set(int switchWidth) {
|
|
try {
|
|
if (switchWidthField != null) {
|
|
switchWidthField.setInt(materialSwitch, switchWidth);
|
|
}
|
|
} catch (IllegalAccessException e) {
|
|
// Fall through
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
private static Field createSwitchWidthField() {
|
|
try {
|
|
Field switchWidthField = SwitchCompat.class.getDeclaredField("mSwitchWidth");
|
|
switchWidthField.setAccessible(true);
|
|
return switchWidthField;
|
|
} catch (NoSuchFieldException | SecurityException e) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO(b/227338106): remove this workaround to use super.getThumbPosition() directly after
|
|
// AppCompat 1.6.0-stable is released.
|
|
@SuppressLint("PrivateApi")
|
|
private final class ThumbPosition {
|
|
private final Field thumbPositionField;
|
|
|
|
private ThumbPosition() {
|
|
thumbPositionField = createThumbPositionField();
|
|
}
|
|
|
|
float get() {
|
|
try {
|
|
if (thumbPositionField != null) {
|
|
return thumbPositionField.getFloat(MaterialSwitch.this);
|
|
}
|
|
} catch (IllegalAccessException e) {
|
|
// Fall through
|
|
}
|
|
return isChecked() ? 1 : 0;
|
|
}
|
|
|
|
private Field createThumbPositionField() {
|
|
try {
|
|
Field thumbPositionField = SwitchCompat.class.getDeclaredField("mThumbPosition");
|
|
thumbPositionField.setAccessible(true);
|
|
return thumbPositionField;
|
|
} catch (Exception e) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|