941 lines
35 KiB
Java
941 lines
35 KiB
Java
package androidx.appcompat.widget;
|
|
|
|
import android.animation.ObjectAnimator;
|
|
import android.content.Context;
|
|
import android.content.res.ColorStateList;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.PorterDuff;
|
|
import android.graphics.Rect;
|
|
import android.graphics.Region;
|
|
import android.graphics.Typeface;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.text.Layout;
|
|
import android.text.StaticLayout;
|
|
import android.text.TextPaint;
|
|
import android.text.TextUtils;
|
|
import android.text.method.TransformationMethod;
|
|
import android.util.AttributeSet;
|
|
import android.util.Property;
|
|
import android.view.ActionMode;
|
|
import android.view.MotionEvent;
|
|
import android.view.VelocityTracker;
|
|
import android.view.ViewConfiguration;
|
|
import android.view.accessibility.AccessibilityEvent;
|
|
import android.view.accessibility.AccessibilityNodeInfo;
|
|
import android.widget.CompoundButton;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.appcompat.R;
|
|
import androidx.appcompat.content.res.AppCompatResources;
|
|
import androidx.appcompat.text.AllCapsTransformationMethod;
|
|
import androidx.core.graphics.drawable.DrawableCompat;
|
|
import androidx.core.view.ViewCompat;
|
|
import androidx.core.widget.TextViewCompat;
|
|
public class SwitchCompat extends CompoundButton {
|
|
private static final String ACCESSIBILITY_EVENT_CLASS_NAME = "android.widget.Switch";
|
|
private static final int[] CHECKED_STATE_SET = {16842912};
|
|
private static final int MONOSPACE = 3;
|
|
private static final int SANS = 1;
|
|
private static final int SERIF = 2;
|
|
private static final int THUMB_ANIMATION_DURATION = 250;
|
|
private static final Property<SwitchCompat, Float> THUMB_POS = new AnonymousClass1(Float.class, "thumbPos");
|
|
private static final int TOUCH_MODE_DOWN = 1;
|
|
private static final int TOUCH_MODE_DRAGGING = 2;
|
|
private static final int TOUCH_MODE_IDLE = 0;
|
|
private boolean mHasThumbTint;
|
|
private boolean mHasThumbTintMode;
|
|
private boolean mHasTrackTint;
|
|
private boolean mHasTrackTintMode;
|
|
private int mMinFlingVelocity;
|
|
private Layout mOffLayout;
|
|
private Layout mOnLayout;
|
|
public ObjectAnimator mPositionAnimator;
|
|
private boolean mShowText;
|
|
private boolean mSplitTrack;
|
|
private int mSwitchBottom;
|
|
private int mSwitchHeight;
|
|
private int mSwitchLeft;
|
|
private int mSwitchMinWidth;
|
|
private int mSwitchPadding;
|
|
private int mSwitchRight;
|
|
private int mSwitchTop;
|
|
private TransformationMethod mSwitchTransformationMethod;
|
|
private int mSwitchWidth;
|
|
private final Rect mTempRect;
|
|
private ColorStateList mTextColors;
|
|
private final AppCompatTextHelper mTextHelper;
|
|
private CharSequence mTextOff;
|
|
private CharSequence mTextOn;
|
|
private final TextPaint mTextPaint;
|
|
private Drawable mThumbDrawable;
|
|
public float mThumbPosition;
|
|
private int mThumbTextPadding;
|
|
private ColorStateList mThumbTintList;
|
|
private PorterDuff.Mode mThumbTintMode;
|
|
private int mThumbWidth;
|
|
private int mTouchMode;
|
|
private int mTouchSlop;
|
|
private float mTouchX;
|
|
private float mTouchY;
|
|
private Drawable mTrackDrawable;
|
|
private ColorStateList mTrackTintList;
|
|
private PorterDuff.Mode mTrackTintMode;
|
|
private VelocityTracker mVelocityTracker;
|
|
|
|
/* renamed from: androidx.appcompat.widget.SwitchCompat$1 reason: invalid class name */
|
|
public class AnonymousClass1 extends Property<SwitchCompat, Float> {
|
|
public AnonymousClass1(Class cls, String str) {
|
|
super(cls, str);
|
|
}
|
|
|
|
public Float get(SwitchCompat switchCompat) {
|
|
return Float.valueOf(switchCompat.mThumbPosition);
|
|
}
|
|
|
|
public void set(SwitchCompat switchCompat, Float f) {
|
|
switchCompat.setThumbPosition(f.floatValue());
|
|
}
|
|
}
|
|
|
|
public SwitchCompat(@NonNull Context context) {
|
|
this(context, null);
|
|
}
|
|
|
|
public SwitchCompat(@NonNull Context context, @Nullable AttributeSet attributeSet) {
|
|
this(context, attributeSet, R.attr.switchStyle);
|
|
}
|
|
|
|
public SwitchCompat(@NonNull Context context, @Nullable AttributeSet attributeSet, int i) {
|
|
super(context, attributeSet, i);
|
|
this.mThumbTintList = null;
|
|
this.mThumbTintMode = null;
|
|
this.mHasThumbTint = false;
|
|
this.mHasThumbTintMode = false;
|
|
this.mTrackTintList = null;
|
|
this.mTrackTintMode = null;
|
|
this.mHasTrackTint = false;
|
|
this.mHasTrackTintMode = false;
|
|
this.mVelocityTracker = VelocityTracker.obtain();
|
|
this.mTempRect = new Rect();
|
|
ThemeUtils.checkAppCompatTheme(this, getContext());
|
|
TextPaint textPaint = new TextPaint(1);
|
|
this.mTextPaint = textPaint;
|
|
textPaint.density = getResources().getDisplayMetrics().density;
|
|
int[] iArr = R.styleable.SwitchCompat;
|
|
TintTypedArray obtainStyledAttributes = TintTypedArray.obtainStyledAttributes(context, attributeSet, iArr, i, 0);
|
|
ViewCompat.saveAttributeDataForStyleable(this, context, iArr, attributeSet, obtainStyledAttributes.getWrappedTypeArray(), i, 0);
|
|
Drawable drawable = obtainStyledAttributes.getDrawable(R.styleable.SwitchCompat_android_thumb);
|
|
this.mThumbDrawable = drawable;
|
|
if (drawable != null) {
|
|
drawable.setCallback(this);
|
|
}
|
|
Drawable drawable2 = obtainStyledAttributes.getDrawable(R.styleable.SwitchCompat_track);
|
|
this.mTrackDrawable = drawable2;
|
|
if (drawable2 != null) {
|
|
drawable2.setCallback(this);
|
|
}
|
|
this.mTextOn = obtainStyledAttributes.getText(R.styleable.SwitchCompat_android_textOn);
|
|
this.mTextOff = obtainStyledAttributes.getText(R.styleable.SwitchCompat_android_textOff);
|
|
this.mShowText = obtainStyledAttributes.getBoolean(R.styleable.SwitchCompat_showText, true);
|
|
this.mThumbTextPadding = obtainStyledAttributes.getDimensionPixelSize(R.styleable.SwitchCompat_thumbTextPadding, 0);
|
|
this.mSwitchMinWidth = obtainStyledAttributes.getDimensionPixelSize(R.styleable.SwitchCompat_switchMinWidth, 0);
|
|
this.mSwitchPadding = obtainStyledAttributes.getDimensionPixelSize(R.styleable.SwitchCompat_switchPadding, 0);
|
|
this.mSplitTrack = obtainStyledAttributes.getBoolean(R.styleable.SwitchCompat_splitTrack, false);
|
|
ColorStateList colorStateList = obtainStyledAttributes.getColorStateList(R.styleable.SwitchCompat_thumbTint);
|
|
if (colorStateList != null) {
|
|
this.mThumbTintList = colorStateList;
|
|
this.mHasThumbTint = true;
|
|
}
|
|
PorterDuff.Mode parseTintMode = DrawableUtils.parseTintMode(obtainStyledAttributes.getInt(R.styleable.SwitchCompat_thumbTintMode, -1), null);
|
|
if (this.mThumbTintMode != parseTintMode) {
|
|
this.mThumbTintMode = parseTintMode;
|
|
this.mHasThumbTintMode = true;
|
|
}
|
|
if (this.mHasThumbTint || this.mHasThumbTintMode) {
|
|
applyThumbTint();
|
|
}
|
|
ColorStateList colorStateList2 = obtainStyledAttributes.getColorStateList(R.styleable.SwitchCompat_trackTint);
|
|
if (colorStateList2 != null) {
|
|
this.mTrackTintList = colorStateList2;
|
|
this.mHasTrackTint = true;
|
|
}
|
|
PorterDuff.Mode parseTintMode2 = DrawableUtils.parseTintMode(obtainStyledAttributes.getInt(R.styleable.SwitchCompat_trackTintMode, -1), null);
|
|
if (this.mTrackTintMode != parseTintMode2) {
|
|
this.mTrackTintMode = parseTintMode2;
|
|
this.mHasTrackTintMode = true;
|
|
}
|
|
if (this.mHasTrackTint || this.mHasTrackTintMode) {
|
|
applyTrackTint();
|
|
}
|
|
int resourceId = obtainStyledAttributes.getResourceId(R.styleable.SwitchCompat_switchTextAppearance, 0);
|
|
if (resourceId != 0) {
|
|
setSwitchTextAppearance(context, resourceId);
|
|
}
|
|
AppCompatTextHelper appCompatTextHelper = new AppCompatTextHelper(this);
|
|
this.mTextHelper = appCompatTextHelper;
|
|
appCompatTextHelper.loadFromAttributes(attributeSet, i);
|
|
obtainStyledAttributes.recycle();
|
|
ViewConfiguration viewConfiguration = ViewConfiguration.get(context);
|
|
this.mTouchSlop = viewConfiguration.getScaledTouchSlop();
|
|
this.mMinFlingVelocity = viewConfiguration.getScaledMinimumFlingVelocity();
|
|
refreshDrawableState();
|
|
setChecked(isChecked());
|
|
}
|
|
|
|
private void animateThumbToCheckedState(boolean z2) {
|
|
ObjectAnimator ofFloat = ObjectAnimator.ofFloat(this, THUMB_POS, z2 ? 1.0f : 0.0f);
|
|
this.mPositionAnimator = ofFloat;
|
|
ofFloat.setDuration(250L);
|
|
this.mPositionAnimator.setAutoCancel(true);
|
|
this.mPositionAnimator.start();
|
|
}
|
|
|
|
private void applyThumbTint() {
|
|
Drawable drawable = this.mThumbDrawable;
|
|
if (drawable == null) {
|
|
return;
|
|
}
|
|
if (this.mHasThumbTint || this.mHasThumbTintMode) {
|
|
Drawable mutate = DrawableCompat.wrap(drawable).mutate();
|
|
this.mThumbDrawable = mutate;
|
|
if (this.mHasThumbTint) {
|
|
DrawableCompat.setTintList(mutate, this.mThumbTintList);
|
|
}
|
|
if (this.mHasThumbTintMode) {
|
|
DrawableCompat.setTintMode(this.mThumbDrawable, this.mThumbTintMode);
|
|
}
|
|
if (this.mThumbDrawable.isStateful()) {
|
|
this.mThumbDrawable.setState(getDrawableState());
|
|
}
|
|
}
|
|
}
|
|
|
|
private void applyTrackTint() {
|
|
Drawable drawable = this.mTrackDrawable;
|
|
if (drawable == null) {
|
|
return;
|
|
}
|
|
if (this.mHasTrackTint || this.mHasTrackTintMode) {
|
|
Drawable mutate = DrawableCompat.wrap(drawable).mutate();
|
|
this.mTrackDrawable = mutate;
|
|
if (this.mHasTrackTint) {
|
|
DrawableCompat.setTintList(mutate, this.mTrackTintList);
|
|
}
|
|
if (this.mHasTrackTintMode) {
|
|
DrawableCompat.setTintMode(this.mTrackDrawable, this.mTrackTintMode);
|
|
}
|
|
if (this.mTrackDrawable.isStateful()) {
|
|
this.mTrackDrawable.setState(getDrawableState());
|
|
}
|
|
}
|
|
}
|
|
|
|
private void cancelPositionAnimator() {
|
|
ObjectAnimator objectAnimator = this.mPositionAnimator;
|
|
if (objectAnimator != null) {
|
|
objectAnimator.cancel();
|
|
}
|
|
}
|
|
|
|
private void cancelSuperTouch(MotionEvent motionEvent) {
|
|
MotionEvent obtain = MotionEvent.obtain(motionEvent);
|
|
obtain.setAction(3);
|
|
super.onTouchEvent(obtain);
|
|
obtain.recycle();
|
|
}
|
|
|
|
private static float constrain(float f, float f2, float f3) {
|
|
return f < f2 ? f2 : f > f3 ? f3 : f;
|
|
}
|
|
|
|
private boolean getTargetCheckedState() {
|
|
return this.mThumbPosition > 0.5f;
|
|
}
|
|
|
|
private int getThumbOffset() {
|
|
return (int) (((ViewUtils.isLayoutRtl(this) ? 1.0f - this.mThumbPosition : this.mThumbPosition) * ((float) getThumbScrollRange())) + 0.5f);
|
|
}
|
|
|
|
private int getThumbScrollRange() {
|
|
Drawable drawable = this.mTrackDrawable;
|
|
if (drawable == null) {
|
|
return 0;
|
|
}
|
|
Rect rect = this.mTempRect;
|
|
drawable.getPadding(rect);
|
|
Drawable drawable2 = this.mThumbDrawable;
|
|
Rect opticalBounds = drawable2 != null ? DrawableUtils.getOpticalBounds(drawable2) : DrawableUtils.INSETS_NONE;
|
|
return ((((this.mSwitchWidth - this.mThumbWidth) - rect.left) - rect.right) - opticalBounds.left) - opticalBounds.right;
|
|
}
|
|
|
|
private boolean hitThumb(float f, float f2) {
|
|
if (this.mThumbDrawable == null) {
|
|
return false;
|
|
}
|
|
int thumbOffset = getThumbOffset();
|
|
this.mThumbDrawable.getPadding(this.mTempRect);
|
|
int i = this.mSwitchTop;
|
|
int i2 = this.mTouchSlop;
|
|
int i3 = i - i2;
|
|
int i4 = (this.mSwitchLeft + thumbOffset) - i2;
|
|
Rect rect = this.mTempRect;
|
|
return f > ((float) i4) && f < ((float) ((((this.mThumbWidth + i4) + rect.left) + rect.right) + i2)) && f2 > ((float) i3) && f2 < ((float) (this.mSwitchBottom + i2));
|
|
}
|
|
|
|
private Layout makeLayout(CharSequence charSequence) {
|
|
TransformationMethod transformationMethod = this.mSwitchTransformationMethod;
|
|
if (transformationMethod != null) {
|
|
charSequence = transformationMethod.getTransformation(charSequence, this);
|
|
}
|
|
TextPaint textPaint = this.mTextPaint;
|
|
return new StaticLayout(charSequence, textPaint, charSequence != null ? (int) Math.ceil((double) Layout.getDesiredWidth(charSequence, textPaint)) : 0, Layout.Alignment.ALIGN_NORMAL, 1.0f, 0.0f, true);
|
|
}
|
|
|
|
private void setSwitchTypefaceByIndex(int i, int i2) {
|
|
setSwitchTypeface(i != 1 ? i != 2 ? i != 3 ? null : Typeface.MONOSPACE : Typeface.SERIF : Typeface.SANS_SERIF, i2);
|
|
}
|
|
|
|
private void stopDrag(MotionEvent motionEvent) {
|
|
this.mTouchMode = 0;
|
|
boolean z2 = true;
|
|
boolean z3 = motionEvent.getAction() == 1 && isEnabled();
|
|
boolean isChecked = isChecked();
|
|
if (z3) {
|
|
this.mVelocityTracker.computeCurrentVelocity(1000);
|
|
float xVelocity = this.mVelocityTracker.getXVelocity();
|
|
if (Math.abs(xVelocity) <= ((float) this.mMinFlingVelocity)) {
|
|
z2 = getTargetCheckedState();
|
|
} else if (!ViewUtils.isLayoutRtl(this) ? xVelocity <= 0.0f : xVelocity >= 0.0f) {
|
|
z2 = false;
|
|
}
|
|
} else {
|
|
z2 = isChecked;
|
|
}
|
|
if (z2 != isChecked) {
|
|
playSoundEffect(0);
|
|
}
|
|
setChecked(z2);
|
|
cancelSuperTouch(motionEvent);
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void draw(Canvas canvas) {
|
|
int i;
|
|
int i2;
|
|
Rect rect = this.mTempRect;
|
|
int i3 = this.mSwitchLeft;
|
|
int i4 = this.mSwitchTop;
|
|
int i5 = this.mSwitchRight;
|
|
int i6 = this.mSwitchBottom;
|
|
int thumbOffset = getThumbOffset() + i3;
|
|
Drawable drawable = this.mThumbDrawable;
|
|
Rect opticalBounds = drawable != null ? DrawableUtils.getOpticalBounds(drawable) : DrawableUtils.INSETS_NONE;
|
|
Drawable drawable2 = this.mTrackDrawable;
|
|
if (drawable2 != null) {
|
|
drawable2.getPadding(rect);
|
|
int i7 = rect.left;
|
|
thumbOffset += i7;
|
|
if (opticalBounds != null) {
|
|
int i8 = opticalBounds.left;
|
|
if (i8 > i7) {
|
|
i3 += i8 - i7;
|
|
}
|
|
int i9 = opticalBounds.top;
|
|
int i10 = rect.top;
|
|
i = i9 > i10 ? (i9 - i10) + i4 : i4;
|
|
int i11 = opticalBounds.right;
|
|
int i12 = rect.right;
|
|
if (i11 > i12) {
|
|
i5 -= i11 - i12;
|
|
}
|
|
int i13 = opticalBounds.bottom;
|
|
int i14 = rect.bottom;
|
|
if (i13 > i14) {
|
|
i2 = i6 - (i13 - i14);
|
|
this.mTrackDrawable.setBounds(i3, i, i5, i2);
|
|
}
|
|
} else {
|
|
i = i4;
|
|
}
|
|
i2 = i6;
|
|
this.mTrackDrawable.setBounds(i3, i, i5, i2);
|
|
}
|
|
Drawable drawable3 = this.mThumbDrawable;
|
|
if (drawable3 != null) {
|
|
drawable3.getPadding(rect);
|
|
int i15 = thumbOffset - rect.left;
|
|
int i16 = thumbOffset + this.mThumbWidth + rect.right;
|
|
this.mThumbDrawable.setBounds(i15, i4, i16, i6);
|
|
Drawable background = getBackground();
|
|
if (background != null) {
|
|
DrawableCompat.setHotspotBounds(background, i15, i4, i16, i6);
|
|
}
|
|
}
|
|
super.draw(canvas);
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.TextView, android.view.View
|
|
public void drawableHotspotChanged(float f, float f2) {
|
|
super.drawableHotspotChanged(f, f2);
|
|
Drawable drawable = this.mThumbDrawable;
|
|
if (drawable != null) {
|
|
DrawableCompat.setHotspot(drawable, f, f2);
|
|
}
|
|
Drawable drawable2 = this.mTrackDrawable;
|
|
if (drawable2 != null) {
|
|
DrawableCompat.setHotspot(drawable2, f, f2);
|
|
}
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.TextView, android.view.View
|
|
public void drawableStateChanged() {
|
|
super.drawableStateChanged();
|
|
int[] drawableState = getDrawableState();
|
|
Drawable drawable = this.mThumbDrawable;
|
|
boolean z2 = false;
|
|
if (drawable != null && drawable.isStateful()) {
|
|
z2 = false | drawable.setState(drawableState);
|
|
}
|
|
Drawable drawable2 = this.mTrackDrawable;
|
|
if (drawable2 != null && drawable2.isStateful()) {
|
|
z2 |= drawable2.setState(drawableState);
|
|
}
|
|
if (z2) {
|
|
invalidate();
|
|
}
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.TextView
|
|
public int getCompoundPaddingLeft() {
|
|
if (!ViewUtils.isLayoutRtl(this)) {
|
|
return super.getCompoundPaddingLeft();
|
|
}
|
|
int compoundPaddingLeft = super.getCompoundPaddingLeft() + this.mSwitchWidth;
|
|
return !TextUtils.isEmpty(getText()) ? compoundPaddingLeft + this.mSwitchPadding : compoundPaddingLeft;
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.TextView
|
|
public int getCompoundPaddingRight() {
|
|
if (ViewUtils.isLayoutRtl(this)) {
|
|
return super.getCompoundPaddingRight();
|
|
}
|
|
int compoundPaddingRight = super.getCompoundPaddingRight() + this.mSwitchWidth;
|
|
return !TextUtils.isEmpty(getText()) ? compoundPaddingRight + this.mSwitchPadding : compoundPaddingRight;
|
|
}
|
|
|
|
public boolean getShowText() {
|
|
return this.mShowText;
|
|
}
|
|
|
|
public boolean getSplitTrack() {
|
|
return this.mSplitTrack;
|
|
}
|
|
|
|
public int getSwitchMinWidth() {
|
|
return this.mSwitchMinWidth;
|
|
}
|
|
|
|
public int getSwitchPadding() {
|
|
return this.mSwitchPadding;
|
|
}
|
|
|
|
public CharSequence getTextOff() {
|
|
return this.mTextOff;
|
|
}
|
|
|
|
public CharSequence getTextOn() {
|
|
return this.mTextOn;
|
|
}
|
|
|
|
public Drawable getThumbDrawable() {
|
|
return this.mThumbDrawable;
|
|
}
|
|
|
|
public int getThumbTextPadding() {
|
|
return this.mThumbTextPadding;
|
|
}
|
|
|
|
@Nullable
|
|
public ColorStateList getThumbTintList() {
|
|
return this.mThumbTintList;
|
|
}
|
|
|
|
@Nullable
|
|
public PorterDuff.Mode getThumbTintMode() {
|
|
return this.mThumbTintMode;
|
|
}
|
|
|
|
public Drawable getTrackDrawable() {
|
|
return this.mTrackDrawable;
|
|
}
|
|
|
|
@Nullable
|
|
public ColorStateList getTrackTintList() {
|
|
return this.mTrackTintList;
|
|
}
|
|
|
|
@Nullable
|
|
public PorterDuff.Mode getTrackTintMode() {
|
|
return this.mTrackTintMode;
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.TextView, android.view.View
|
|
public void jumpDrawablesToCurrentState() {
|
|
super.jumpDrawablesToCurrentState();
|
|
Drawable drawable = this.mThumbDrawable;
|
|
if (drawable != null) {
|
|
drawable.jumpToCurrentState();
|
|
}
|
|
Drawable drawable2 = this.mTrackDrawable;
|
|
if (drawable2 != null) {
|
|
drawable2.jumpToCurrentState();
|
|
}
|
|
ObjectAnimator objectAnimator = this.mPositionAnimator;
|
|
if (objectAnimator != null && objectAnimator.isStarted()) {
|
|
this.mPositionAnimator.end();
|
|
this.mPositionAnimator = null;
|
|
}
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.TextView, android.view.View
|
|
public int[] onCreateDrawableState(int i) {
|
|
int[] onCreateDrawableState = super.onCreateDrawableState(i + 1);
|
|
if (isChecked()) {
|
|
CompoundButton.mergeDrawableStates(onCreateDrawableState, CHECKED_STATE_SET);
|
|
}
|
|
return onCreateDrawableState;
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.TextView, android.view.View
|
|
public void onDraw(Canvas canvas) {
|
|
int i;
|
|
super.onDraw(canvas);
|
|
Rect rect = this.mTempRect;
|
|
Drawable drawable = this.mTrackDrawable;
|
|
if (drawable != null) {
|
|
drawable.getPadding(rect);
|
|
} else {
|
|
rect.setEmpty();
|
|
}
|
|
int i2 = this.mSwitchTop;
|
|
int i3 = this.mSwitchBottom;
|
|
int i4 = i2 + rect.top;
|
|
int i5 = i3 - rect.bottom;
|
|
Drawable drawable2 = this.mThumbDrawable;
|
|
if (drawable != null) {
|
|
if (!this.mSplitTrack || drawable2 == null) {
|
|
drawable.draw(canvas);
|
|
} else {
|
|
Rect opticalBounds = DrawableUtils.getOpticalBounds(drawable2);
|
|
drawable2.copyBounds(rect);
|
|
rect.left += opticalBounds.left;
|
|
rect.right -= opticalBounds.right;
|
|
int save = canvas.save();
|
|
canvas.clipRect(rect, Region.Op.DIFFERENCE);
|
|
drawable.draw(canvas);
|
|
canvas.restoreToCount(save);
|
|
}
|
|
}
|
|
int save2 = canvas.save();
|
|
if (drawable2 != null) {
|
|
drawable2.draw(canvas);
|
|
}
|
|
Layout layout = getTargetCheckedState() ? this.mOnLayout : this.mOffLayout;
|
|
if (layout != null) {
|
|
int[] drawableState = getDrawableState();
|
|
ColorStateList colorStateList = this.mTextColors;
|
|
if (colorStateList != null) {
|
|
this.mTextPaint.setColor(colorStateList.getColorForState(drawableState, 0));
|
|
}
|
|
this.mTextPaint.drawableState = drawableState;
|
|
if (drawable2 != null) {
|
|
Rect bounds = drawable2.getBounds();
|
|
i = bounds.left + bounds.right;
|
|
} else {
|
|
i = getWidth();
|
|
}
|
|
canvas.translate((float) ((i / 2) - (layout.getWidth() / 2)), (float) (((i4 + i5) / 2) - (layout.getHeight() / 2)));
|
|
layout.draw(canvas);
|
|
}
|
|
canvas.restoreToCount(save2);
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onInitializeAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
|
|
super.onInitializeAccessibilityEvent(accessibilityEvent);
|
|
accessibilityEvent.setClassName(ACCESSIBILITY_EVENT_CLASS_NAME);
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo accessibilityNodeInfo) {
|
|
super.onInitializeAccessibilityNodeInfo(accessibilityNodeInfo);
|
|
accessibilityNodeInfo.setClassName(ACCESSIBILITY_EVENT_CLASS_NAME);
|
|
CharSequence charSequence = isChecked() ? this.mTextOn : this.mTextOff;
|
|
if (!TextUtils.isEmpty(charSequence)) {
|
|
CharSequence text = accessibilityNodeInfo.getText();
|
|
if (TextUtils.isEmpty(text)) {
|
|
accessibilityNodeInfo.setText(charSequence);
|
|
return;
|
|
}
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(text);
|
|
sb.append(' ');
|
|
sb.append(charSequence);
|
|
accessibilityNodeInfo.setText(sb);
|
|
}
|
|
}
|
|
|
|
@Override // android.widget.TextView, android.view.View
|
|
public void onLayout(boolean z2, int i, int i2, int i3, int i4) {
|
|
int i5;
|
|
int i6;
|
|
int i7;
|
|
int i8;
|
|
int i9;
|
|
super.onLayout(z2, i, i2, i3, i4);
|
|
int i10 = 0;
|
|
if (this.mThumbDrawable != null) {
|
|
Rect rect = this.mTempRect;
|
|
Drawable drawable = this.mTrackDrawable;
|
|
if (drawable != null) {
|
|
drawable.getPadding(rect);
|
|
} else {
|
|
rect.setEmpty();
|
|
}
|
|
Rect opticalBounds = DrawableUtils.getOpticalBounds(this.mThumbDrawable);
|
|
i5 = Math.max(0, opticalBounds.left - rect.left);
|
|
i10 = Math.max(0, opticalBounds.right - rect.right);
|
|
} else {
|
|
i5 = 0;
|
|
}
|
|
if (ViewUtils.isLayoutRtl(this)) {
|
|
i7 = getPaddingLeft() + i5;
|
|
i6 = ((this.mSwitchWidth + i7) - i5) - i10;
|
|
} else {
|
|
i6 = (getWidth() - getPaddingRight()) - i10;
|
|
i7 = (i6 - this.mSwitchWidth) + i5 + i10;
|
|
}
|
|
int gravity = getGravity() & 112;
|
|
if (gravity == 16) {
|
|
int paddingTop = getPaddingTop();
|
|
int i11 = this.mSwitchHeight;
|
|
int height = (((getHeight() + paddingTop) - getPaddingBottom()) / 2) - (i11 / 2);
|
|
i8 = i11 + height;
|
|
i9 = height;
|
|
} else if (gravity != 80) {
|
|
i9 = getPaddingTop();
|
|
i8 = this.mSwitchHeight + i9;
|
|
} else {
|
|
i8 = getHeight() - getPaddingBottom();
|
|
i9 = i8 - this.mSwitchHeight;
|
|
}
|
|
this.mSwitchLeft = i7;
|
|
this.mSwitchTop = i9;
|
|
this.mSwitchBottom = i8;
|
|
this.mSwitchRight = i6;
|
|
}
|
|
|
|
@Override // android.widget.TextView, android.view.View
|
|
public void onMeasure(int i, int i2) {
|
|
int i3;
|
|
int i4;
|
|
int i5;
|
|
if (this.mShowText) {
|
|
if (this.mOnLayout == null) {
|
|
this.mOnLayout = makeLayout(this.mTextOn);
|
|
}
|
|
if (this.mOffLayout == null) {
|
|
this.mOffLayout = makeLayout(this.mTextOff);
|
|
}
|
|
}
|
|
Rect rect = this.mTempRect;
|
|
Drawable drawable = this.mThumbDrawable;
|
|
int i6 = 0;
|
|
if (drawable != null) {
|
|
drawable.getPadding(rect);
|
|
i4 = (this.mThumbDrawable.getIntrinsicWidth() - rect.left) - rect.right;
|
|
i3 = this.mThumbDrawable.getIntrinsicHeight();
|
|
} else {
|
|
i4 = 0;
|
|
i3 = 0;
|
|
}
|
|
if (this.mShowText) {
|
|
i5 = (this.mThumbTextPadding * 2) + Math.max(this.mOnLayout.getWidth(), this.mOffLayout.getWidth());
|
|
} else {
|
|
i5 = 0;
|
|
}
|
|
this.mThumbWidth = Math.max(i5, i4);
|
|
Drawable drawable2 = this.mTrackDrawable;
|
|
if (drawable2 != null) {
|
|
drawable2.getPadding(rect);
|
|
i6 = this.mTrackDrawable.getIntrinsicHeight();
|
|
} else {
|
|
rect.setEmpty();
|
|
}
|
|
int i7 = rect.left;
|
|
int i8 = rect.right;
|
|
Drawable drawable3 = this.mThumbDrawable;
|
|
if (drawable3 != null) {
|
|
Rect opticalBounds = DrawableUtils.getOpticalBounds(drawable3);
|
|
i7 = Math.max(i7, opticalBounds.left);
|
|
i8 = Math.max(i8, opticalBounds.right);
|
|
}
|
|
int max = Math.max(this.mSwitchMinWidth, (this.mThumbWidth * 2) + i7 + i8);
|
|
int max2 = Math.max(i6, i3);
|
|
this.mSwitchWidth = max;
|
|
this.mSwitchHeight = max2;
|
|
super.onMeasure(i, i2);
|
|
if (getMeasuredHeight() < max2) {
|
|
setMeasuredDimension(getMeasuredWidthAndState(), max2);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onPopulateAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
|
|
super.onPopulateAccessibilityEvent(accessibilityEvent);
|
|
CharSequence charSequence = isChecked() ? this.mTextOn : this.mTextOff;
|
|
if (charSequence != null) {
|
|
accessibilityEvent.getText().add(charSequence);
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:6:0x0012, code lost:
|
|
if (r0 != 3) goto L_0x00b9;
|
|
*/
|
|
@Override // android.widget.TextView, android.view.View
|
|
public boolean onTouchEvent(MotionEvent motionEvent) {
|
|
this.mVelocityTracker.addMovement(motionEvent);
|
|
int actionMasked = motionEvent.getActionMasked();
|
|
if (actionMasked != 0) {
|
|
if (actionMasked != 1) {
|
|
if (actionMasked == 2) {
|
|
int i = this.mTouchMode;
|
|
if (i == 1) {
|
|
float x2 = motionEvent.getX();
|
|
float y2 = motionEvent.getY();
|
|
if (Math.abs(x2 - this.mTouchX) > ((float) this.mTouchSlop) || Math.abs(y2 - this.mTouchY) > ((float) this.mTouchSlop)) {
|
|
this.mTouchMode = 2;
|
|
getParent().requestDisallowInterceptTouchEvent(true);
|
|
this.mTouchX = x2;
|
|
this.mTouchY = y2;
|
|
return true;
|
|
}
|
|
} else if (i == 2) {
|
|
float x3 = motionEvent.getX();
|
|
int thumbScrollRange = getThumbScrollRange();
|
|
float f = x3 - this.mTouchX;
|
|
float f2 = thumbScrollRange != 0 ? f / ((float) thumbScrollRange) : f > 0.0f ? 1.0f : -1.0f;
|
|
if (ViewUtils.isLayoutRtl(this)) {
|
|
f2 = -f2;
|
|
}
|
|
float constrain = constrain(this.mThumbPosition + f2, 0.0f, 1.0f);
|
|
if (constrain != this.mThumbPosition) {
|
|
this.mTouchX = x3;
|
|
setThumbPosition(constrain);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (this.mTouchMode == 2) {
|
|
stopDrag(motionEvent);
|
|
super.onTouchEvent(motionEvent);
|
|
return true;
|
|
}
|
|
this.mTouchMode = 0;
|
|
this.mVelocityTracker.clear();
|
|
} else {
|
|
float x4 = motionEvent.getX();
|
|
float y3 = motionEvent.getY();
|
|
if (isEnabled() && hitThumb(x4, y3)) {
|
|
this.mTouchMode = 1;
|
|
this.mTouchX = x4;
|
|
this.mTouchY = y3;
|
|
}
|
|
}
|
|
return super.onTouchEvent(motionEvent);
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.Checkable
|
|
public void setChecked(boolean z2) {
|
|
super.setChecked(z2);
|
|
boolean isChecked = isChecked();
|
|
if (getWindowToken() == null || !ViewCompat.isLaidOut(this)) {
|
|
cancelPositionAnimator();
|
|
setThumbPosition(isChecked ? 1.0f : 0.0f);
|
|
return;
|
|
}
|
|
animateThumbToCheckedState(isChecked);
|
|
}
|
|
|
|
@Override // android.widget.TextView
|
|
public void setCustomSelectionActionModeCallback(ActionMode.Callback callback) {
|
|
super.setCustomSelectionActionModeCallback(TextViewCompat.wrapCustomSelectionActionModeCallback(this, callback));
|
|
}
|
|
|
|
public void setShowText(boolean z2) {
|
|
if (this.mShowText != z2) {
|
|
this.mShowText = z2;
|
|
requestLayout();
|
|
}
|
|
}
|
|
|
|
public void setSplitTrack(boolean z2) {
|
|
this.mSplitTrack = z2;
|
|
invalidate();
|
|
}
|
|
|
|
public void setSwitchMinWidth(int i) {
|
|
this.mSwitchMinWidth = i;
|
|
requestLayout();
|
|
}
|
|
|
|
public void setSwitchPadding(int i) {
|
|
this.mSwitchPadding = i;
|
|
requestLayout();
|
|
}
|
|
|
|
public void setSwitchTextAppearance(Context context, int i) {
|
|
TintTypedArray obtainStyledAttributes = TintTypedArray.obtainStyledAttributes(context, i, R.styleable.TextAppearance);
|
|
ColorStateList colorStateList = obtainStyledAttributes.getColorStateList(R.styleable.TextAppearance_android_textColor);
|
|
if (colorStateList != null) {
|
|
this.mTextColors = colorStateList;
|
|
} else {
|
|
this.mTextColors = getTextColors();
|
|
}
|
|
int dimensionPixelSize = obtainStyledAttributes.getDimensionPixelSize(R.styleable.TextAppearance_android_textSize, 0);
|
|
if (dimensionPixelSize != 0) {
|
|
float f = (float) dimensionPixelSize;
|
|
if (f != this.mTextPaint.getTextSize()) {
|
|
this.mTextPaint.setTextSize(f);
|
|
requestLayout();
|
|
}
|
|
}
|
|
setSwitchTypefaceByIndex(obtainStyledAttributes.getInt(R.styleable.TextAppearance_android_typeface, -1), obtainStyledAttributes.getInt(R.styleable.TextAppearance_android_textStyle, -1));
|
|
if (obtainStyledAttributes.getBoolean(R.styleable.TextAppearance_textAllCaps, false)) {
|
|
this.mSwitchTransformationMethod = new AllCapsTransformationMethod(getContext());
|
|
} else {
|
|
this.mSwitchTransformationMethod = null;
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
|
|
public void setSwitchTypeface(Typeface typeface) {
|
|
if ((this.mTextPaint.getTypeface() != null && !this.mTextPaint.getTypeface().equals(typeface)) || (this.mTextPaint.getTypeface() == null && typeface != null)) {
|
|
this.mTextPaint.setTypeface(typeface);
|
|
requestLayout();
|
|
invalidate();
|
|
}
|
|
}
|
|
|
|
public void setSwitchTypeface(Typeface typeface, int i) {
|
|
float f = 0.0f;
|
|
boolean z2 = false;
|
|
if (i > 0) {
|
|
Typeface defaultFromStyle = typeface == null ? Typeface.defaultFromStyle(i) : Typeface.create(typeface, i);
|
|
setSwitchTypeface(defaultFromStyle);
|
|
int i2 = (~(defaultFromStyle != null ? defaultFromStyle.getStyle() : 0)) & i;
|
|
TextPaint textPaint = this.mTextPaint;
|
|
if ((i2 & 1) != 0) {
|
|
z2 = true;
|
|
}
|
|
textPaint.setFakeBoldText(z2);
|
|
TextPaint textPaint2 = this.mTextPaint;
|
|
if ((i2 & 2) != 0) {
|
|
f = -0.25f;
|
|
}
|
|
textPaint2.setTextSkewX(f);
|
|
return;
|
|
}
|
|
this.mTextPaint.setFakeBoldText(false);
|
|
this.mTextPaint.setTextSkewX(0.0f);
|
|
setSwitchTypeface(typeface);
|
|
}
|
|
|
|
public void setTextOff(CharSequence charSequence) {
|
|
this.mTextOff = charSequence;
|
|
requestLayout();
|
|
}
|
|
|
|
public void setTextOn(CharSequence charSequence) {
|
|
this.mTextOn = charSequence;
|
|
requestLayout();
|
|
}
|
|
|
|
public void setThumbDrawable(Drawable drawable) {
|
|
Drawable drawable2 = this.mThumbDrawable;
|
|
if (drawable2 != null) {
|
|
drawable2.setCallback(null);
|
|
}
|
|
this.mThumbDrawable = drawable;
|
|
if (drawable != null) {
|
|
drawable.setCallback(this);
|
|
}
|
|
requestLayout();
|
|
}
|
|
|
|
public void setThumbPosition(float f) {
|
|
this.mThumbPosition = f;
|
|
invalidate();
|
|
}
|
|
|
|
public void setThumbResource(int i) {
|
|
setThumbDrawable(AppCompatResources.getDrawable(getContext(), i));
|
|
}
|
|
|
|
public void setThumbTextPadding(int i) {
|
|
this.mThumbTextPadding = i;
|
|
requestLayout();
|
|
}
|
|
|
|
public void setThumbTintList(@Nullable ColorStateList colorStateList) {
|
|
this.mThumbTintList = colorStateList;
|
|
this.mHasThumbTint = true;
|
|
applyThumbTint();
|
|
}
|
|
|
|
public void setThumbTintMode(@Nullable PorterDuff.Mode mode) {
|
|
this.mThumbTintMode = mode;
|
|
this.mHasThumbTintMode = true;
|
|
applyThumbTint();
|
|
}
|
|
|
|
public void setTrackDrawable(Drawable drawable) {
|
|
Drawable drawable2 = this.mTrackDrawable;
|
|
if (drawable2 != null) {
|
|
drawable2.setCallback(null);
|
|
}
|
|
this.mTrackDrawable = drawable;
|
|
if (drawable != null) {
|
|
drawable.setCallback(this);
|
|
}
|
|
requestLayout();
|
|
}
|
|
|
|
public void setTrackResource(int i) {
|
|
setTrackDrawable(AppCompatResources.getDrawable(getContext(), i));
|
|
}
|
|
|
|
public void setTrackTintList(@Nullable ColorStateList colorStateList) {
|
|
this.mTrackTintList = colorStateList;
|
|
this.mHasTrackTint = true;
|
|
applyTrackTint();
|
|
}
|
|
|
|
public void setTrackTintMode(@Nullable PorterDuff.Mode mode) {
|
|
this.mTrackTintMode = mode;
|
|
this.mHasTrackTintMode = true;
|
|
applyTrackTint();
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.Checkable
|
|
public void toggle() {
|
|
setChecked(!isChecked());
|
|
}
|
|
|
|
@Override // android.widget.CompoundButton, android.widget.TextView, android.view.View
|
|
public boolean verifyDrawable(Drawable drawable) {
|
|
return super.verifyDrawable(drawable) || drawable == this.mThumbDrawable || drawable == this.mTrackDrawable;
|
|
}
|
|
}
|