Daniel Elliott
f9d20bb3fc
- 28,932 files - Full Java source code - Smali files - Resources Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
443 lines
15 KiB
Java
443 lines
15 KiB
Java
package androidx.core.widget;
|
|
|
|
import android.content.res.Resources;
|
|
import android.os.SystemClock;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.ViewConfiguration;
|
|
import android.view.animation.AccelerateInterpolator;
|
|
import android.view.animation.AnimationUtils;
|
|
import android.view.animation.Interpolator;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.core.view.ViewCompat;
|
|
|
|
/* loaded from: classes.dex */
|
|
public abstract class AutoScrollHelper implements View.OnTouchListener {
|
|
private static final int DEFAULT_ACTIVATION_DELAY = ViewConfiguration.getTapTimeout();
|
|
private static final int DEFAULT_EDGE_TYPE = 1;
|
|
private static final float DEFAULT_MAXIMUM_EDGE = Float.MAX_VALUE;
|
|
private static final int DEFAULT_MAXIMUM_VELOCITY_DIPS = 1575;
|
|
private static final int DEFAULT_MINIMUM_VELOCITY_DIPS = 315;
|
|
private static final int DEFAULT_RAMP_DOWN_DURATION = 500;
|
|
private static final int DEFAULT_RAMP_UP_DURATION = 500;
|
|
private static final float DEFAULT_RELATIVE_EDGE = 0.2f;
|
|
private static final float DEFAULT_RELATIVE_VELOCITY = 1.0f;
|
|
public static final int EDGE_TYPE_INSIDE = 0;
|
|
public static final int EDGE_TYPE_INSIDE_EXTEND = 1;
|
|
public static final int EDGE_TYPE_OUTSIDE = 2;
|
|
private static final int HORIZONTAL = 0;
|
|
public static final float NO_MAX = Float.MAX_VALUE;
|
|
public static final float NO_MIN = 0.0f;
|
|
public static final float RELATIVE_UNSPECIFIED = 0.0f;
|
|
private static final int VERTICAL = 1;
|
|
private int mActivationDelay;
|
|
private boolean mAlreadyDelayed;
|
|
boolean mAnimating;
|
|
private int mEdgeType;
|
|
private boolean mEnabled;
|
|
private boolean mExclusive;
|
|
boolean mNeedsCancel;
|
|
boolean mNeedsReset;
|
|
private Runnable mRunnable;
|
|
final View mTarget;
|
|
final ClampedScroller mScroller = new ClampedScroller();
|
|
private final Interpolator mEdgeInterpolator = new AccelerateInterpolator();
|
|
private float[] mRelativeEdges = {0.0f, 0.0f};
|
|
private float[] mMaximumEdges = {Float.MAX_VALUE, Float.MAX_VALUE};
|
|
private float[] mRelativeVelocity = {0.0f, 0.0f};
|
|
private float[] mMinimumVelocity = {0.0f, 0.0f};
|
|
private float[] mMaximumVelocity = {Float.MAX_VALUE, Float.MAX_VALUE};
|
|
|
|
public static float constrain(float f, float f2, float f3) {
|
|
return f > f3 ? f3 : f < f2 ? f2 : f;
|
|
}
|
|
|
|
public static int constrain(int i, int i2, int i3) {
|
|
return i > i3 ? i3 : i < i2 ? i2 : i;
|
|
}
|
|
|
|
private float constrainEdgeValue(float f, float f2) {
|
|
if (f2 == 0.0f) {
|
|
return 0.0f;
|
|
}
|
|
int i = this.mEdgeType;
|
|
if (i == 0 || i == 1) {
|
|
if (f < f2) {
|
|
if (f >= 0.0f) {
|
|
return DEFAULT_RELATIVE_VELOCITY - (f / f2);
|
|
}
|
|
if (this.mAnimating && i == 1) {
|
|
return DEFAULT_RELATIVE_VELOCITY;
|
|
}
|
|
}
|
|
} else if (i == 2 && f < 0.0f) {
|
|
return f / (-f2);
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
public abstract boolean canTargetScrollHorizontally(int i);
|
|
|
|
public abstract boolean canTargetScrollVertically(int i);
|
|
|
|
public boolean isEnabled() {
|
|
return this.mEnabled;
|
|
}
|
|
|
|
public boolean isExclusive() {
|
|
return this.mExclusive;
|
|
}
|
|
|
|
public abstract void scrollTargetBy(int i, int i2);
|
|
|
|
@NonNull
|
|
public AutoScrollHelper setActivationDelay(int i) {
|
|
this.mActivationDelay = i;
|
|
return this;
|
|
}
|
|
|
|
@NonNull
|
|
public AutoScrollHelper setEdgeType(int i) {
|
|
this.mEdgeType = i;
|
|
return this;
|
|
}
|
|
|
|
public AutoScrollHelper setExclusive(boolean z) {
|
|
this.mExclusive = z;
|
|
return this;
|
|
}
|
|
|
|
public AutoScrollHelper(@NonNull View view) {
|
|
this.mTarget = view;
|
|
float f = Resources.getSystem().getDisplayMetrics().density;
|
|
float f2 = (int) ((1575.0f * f) + 0.5f);
|
|
setMaximumVelocity(f2, f2);
|
|
float f3 = (int) ((f * 315.0f) + 0.5f);
|
|
setMinimumVelocity(f3, f3);
|
|
setEdgeType(1);
|
|
setMaximumEdges(Float.MAX_VALUE, Float.MAX_VALUE);
|
|
setRelativeEdges(DEFAULT_RELATIVE_EDGE, DEFAULT_RELATIVE_EDGE);
|
|
setRelativeVelocity(DEFAULT_RELATIVE_VELOCITY, DEFAULT_RELATIVE_VELOCITY);
|
|
setActivationDelay(DEFAULT_ACTIVATION_DELAY);
|
|
setRampUpDuration(500);
|
|
setRampDownDuration(500);
|
|
}
|
|
|
|
public AutoScrollHelper setEnabled(boolean z) {
|
|
if (this.mEnabled && !z) {
|
|
requestStop();
|
|
}
|
|
this.mEnabled = z;
|
|
return this;
|
|
}
|
|
|
|
@NonNull
|
|
public AutoScrollHelper setMaximumVelocity(float f, float f2) {
|
|
float[] fArr = this.mMaximumVelocity;
|
|
fArr[0] = f / 1000.0f;
|
|
fArr[1] = f2 / 1000.0f;
|
|
return this;
|
|
}
|
|
|
|
@NonNull
|
|
public AutoScrollHelper setMinimumVelocity(float f, float f2) {
|
|
float[] fArr = this.mMinimumVelocity;
|
|
fArr[0] = f / 1000.0f;
|
|
fArr[1] = f2 / 1000.0f;
|
|
return this;
|
|
}
|
|
|
|
@NonNull
|
|
public AutoScrollHelper setRelativeVelocity(float f, float f2) {
|
|
float[] fArr = this.mRelativeVelocity;
|
|
fArr[0] = f / 1000.0f;
|
|
fArr[1] = f2 / 1000.0f;
|
|
return this;
|
|
}
|
|
|
|
@NonNull
|
|
public AutoScrollHelper setRelativeEdges(float f, float f2) {
|
|
float[] fArr = this.mRelativeEdges;
|
|
fArr[0] = f;
|
|
fArr[1] = f2;
|
|
return this;
|
|
}
|
|
|
|
@NonNull
|
|
public AutoScrollHelper setMaximumEdges(float f, float f2) {
|
|
float[] fArr = this.mMaximumEdges;
|
|
fArr[0] = f;
|
|
fArr[1] = f2;
|
|
return this;
|
|
}
|
|
|
|
@NonNull
|
|
public AutoScrollHelper setRampUpDuration(int i) {
|
|
this.mScroller.setRampUpDuration(i);
|
|
return this;
|
|
}
|
|
|
|
@NonNull
|
|
public AutoScrollHelper setRampDownDuration(int i) {
|
|
this.mScroller.setRampDownDuration(i);
|
|
return this;
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:11:0x0013, code lost:
|
|
|
|
if (r0 != 3) goto L20;
|
|
*/
|
|
@Override // android.view.View.OnTouchListener
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public boolean onTouch(android.view.View r6, android.view.MotionEvent r7) {
|
|
/*
|
|
r5 = this;
|
|
boolean r0 = r5.mEnabled
|
|
r1 = 0
|
|
if (r0 != 0) goto L6
|
|
return r1
|
|
L6:
|
|
int r0 = r7.getActionMasked()
|
|
r2 = 1
|
|
if (r0 == 0) goto L1a
|
|
if (r0 == r2) goto L16
|
|
r3 = 2
|
|
if (r0 == r3) goto L1e
|
|
r6 = 3
|
|
if (r0 == r6) goto L16
|
|
goto L58
|
|
L16:
|
|
r5.requestStop()
|
|
goto L58
|
|
L1a:
|
|
r5.mNeedsCancel = r2
|
|
r5.mAlreadyDelayed = r1
|
|
L1e:
|
|
float r0 = r7.getX()
|
|
int r3 = r6.getWidth()
|
|
float r3 = (float) r3
|
|
android.view.View r4 = r5.mTarget
|
|
int r4 = r4.getWidth()
|
|
float r4 = (float) r4
|
|
float r0 = r5.computeTargetVelocity(r1, r0, r3, r4)
|
|
float r7 = r7.getY()
|
|
int r6 = r6.getHeight()
|
|
float r6 = (float) r6
|
|
android.view.View r3 = r5.mTarget
|
|
int r3 = r3.getHeight()
|
|
float r3 = (float) r3
|
|
float r6 = r5.computeTargetVelocity(r2, r7, r6, r3)
|
|
androidx.core.widget.AutoScrollHelper$ClampedScroller r7 = r5.mScroller
|
|
r7.setTargetVelocity(r0, r6)
|
|
boolean r6 = r5.mAnimating
|
|
if (r6 != 0) goto L58
|
|
boolean r6 = r5.shouldAnimate()
|
|
if (r6 == 0) goto L58
|
|
r5.startAnimating()
|
|
L58:
|
|
boolean r6 = r5.mExclusive
|
|
if (r6 == 0) goto L61
|
|
boolean r6 = r5.mAnimating
|
|
if (r6 == 0) goto L61
|
|
r1 = r2
|
|
L61:
|
|
return r1
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.core.widget.AutoScrollHelper.onTouch(android.view.View, android.view.MotionEvent):boolean");
|
|
}
|
|
|
|
public boolean shouldAnimate() {
|
|
ClampedScroller clampedScroller = this.mScroller;
|
|
int verticalDirection = clampedScroller.getVerticalDirection();
|
|
int horizontalDirection = clampedScroller.getHorizontalDirection();
|
|
return (verticalDirection != 0 && canTargetScrollVertically(verticalDirection)) || (horizontalDirection != 0 && canTargetScrollHorizontally(horizontalDirection));
|
|
}
|
|
|
|
private void startAnimating() {
|
|
int i;
|
|
if (this.mRunnable == null) {
|
|
this.mRunnable = new ScrollAnimationRunnable();
|
|
}
|
|
this.mAnimating = true;
|
|
this.mNeedsReset = true;
|
|
if (!this.mAlreadyDelayed && (i = this.mActivationDelay) > 0) {
|
|
ViewCompat.postOnAnimationDelayed(this.mTarget, this.mRunnable, i);
|
|
} else {
|
|
this.mRunnable.run();
|
|
}
|
|
this.mAlreadyDelayed = true;
|
|
}
|
|
|
|
private void requestStop() {
|
|
if (this.mNeedsReset) {
|
|
this.mAnimating = false;
|
|
} else {
|
|
this.mScroller.requestStop();
|
|
}
|
|
}
|
|
|
|
private float computeTargetVelocity(int i, float f, float f2, float f3) {
|
|
float edgeValue = getEdgeValue(this.mRelativeEdges[i], f2, this.mMaximumEdges[i], f);
|
|
if (edgeValue == 0.0f) {
|
|
return 0.0f;
|
|
}
|
|
float f4 = this.mRelativeVelocity[i];
|
|
float f5 = this.mMinimumVelocity[i];
|
|
float f6 = this.mMaximumVelocity[i];
|
|
float f7 = f4 * f3;
|
|
if (edgeValue > 0.0f) {
|
|
return constrain(edgeValue * f7, f5, f6);
|
|
}
|
|
return -constrain((-edgeValue) * f7, f5, f6);
|
|
}
|
|
|
|
private float getEdgeValue(float f, float f2, float f3, float f4) {
|
|
float interpolation;
|
|
float constrain = constrain(f * f2, 0.0f, f3);
|
|
float constrainEdgeValue = constrainEdgeValue(f2 - f4, constrain) - constrainEdgeValue(f4, constrain);
|
|
if (constrainEdgeValue < 0.0f) {
|
|
interpolation = -this.mEdgeInterpolator.getInterpolation(-constrainEdgeValue);
|
|
} else {
|
|
if (constrainEdgeValue <= 0.0f) {
|
|
return 0.0f;
|
|
}
|
|
interpolation = this.mEdgeInterpolator.getInterpolation(constrainEdgeValue);
|
|
}
|
|
return constrain(interpolation, -1.0f, DEFAULT_RELATIVE_VELOCITY);
|
|
}
|
|
|
|
public void cancelTargetTouch() {
|
|
long uptimeMillis = SystemClock.uptimeMillis();
|
|
MotionEvent obtain = MotionEvent.obtain(uptimeMillis, uptimeMillis, 3, 0.0f, 0.0f, 0);
|
|
this.mTarget.onTouchEvent(obtain);
|
|
obtain.recycle();
|
|
}
|
|
|
|
public class ScrollAnimationRunnable implements Runnable {
|
|
public ScrollAnimationRunnable() {
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
AutoScrollHelper autoScrollHelper = AutoScrollHelper.this;
|
|
if (autoScrollHelper.mAnimating) {
|
|
if (autoScrollHelper.mNeedsReset) {
|
|
autoScrollHelper.mNeedsReset = false;
|
|
autoScrollHelper.mScroller.start();
|
|
}
|
|
ClampedScroller clampedScroller = AutoScrollHelper.this.mScroller;
|
|
if (clampedScroller.isFinished() || !AutoScrollHelper.this.shouldAnimate()) {
|
|
AutoScrollHelper.this.mAnimating = false;
|
|
return;
|
|
}
|
|
AutoScrollHelper autoScrollHelper2 = AutoScrollHelper.this;
|
|
if (autoScrollHelper2.mNeedsCancel) {
|
|
autoScrollHelper2.mNeedsCancel = false;
|
|
autoScrollHelper2.cancelTargetTouch();
|
|
}
|
|
clampedScroller.computeScrollDelta();
|
|
AutoScrollHelper.this.scrollTargetBy(clampedScroller.getDeltaX(), clampedScroller.getDeltaY());
|
|
ViewCompat.postOnAnimation(AutoScrollHelper.this.mTarget, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class ClampedScroller {
|
|
private int mEffectiveRampDown;
|
|
private int mRampDownDuration;
|
|
private int mRampUpDuration;
|
|
private float mStopValue;
|
|
private float mTargetVelocityX;
|
|
private float mTargetVelocityY;
|
|
private long mStartTime = Long.MIN_VALUE;
|
|
private long mStopTime = -1;
|
|
private long mDeltaTime = 0;
|
|
private int mDeltaX = 0;
|
|
private int mDeltaY = 0;
|
|
|
|
private float interpolateValue(float f) {
|
|
return ((-4.0f) * f * f) + (f * 4.0f);
|
|
}
|
|
|
|
public int getDeltaX() {
|
|
return this.mDeltaX;
|
|
}
|
|
|
|
public int getDeltaY() {
|
|
return this.mDeltaY;
|
|
}
|
|
|
|
public void setRampDownDuration(int i) {
|
|
this.mRampDownDuration = i;
|
|
}
|
|
|
|
public void setRampUpDuration(int i) {
|
|
this.mRampUpDuration = i;
|
|
}
|
|
|
|
public void setTargetVelocity(float f, float f2) {
|
|
this.mTargetVelocityX = f;
|
|
this.mTargetVelocityY = f2;
|
|
}
|
|
|
|
public void start() {
|
|
long currentAnimationTimeMillis = AnimationUtils.currentAnimationTimeMillis();
|
|
this.mStartTime = currentAnimationTimeMillis;
|
|
this.mStopTime = -1L;
|
|
this.mDeltaTime = currentAnimationTimeMillis;
|
|
this.mStopValue = 0.5f;
|
|
this.mDeltaX = 0;
|
|
this.mDeltaY = 0;
|
|
}
|
|
|
|
public void requestStop() {
|
|
long currentAnimationTimeMillis = AnimationUtils.currentAnimationTimeMillis();
|
|
this.mEffectiveRampDown = AutoScrollHelper.constrain((int) (currentAnimationTimeMillis - this.mStartTime), 0, this.mRampDownDuration);
|
|
this.mStopValue = getValueAt(currentAnimationTimeMillis);
|
|
this.mStopTime = currentAnimationTimeMillis;
|
|
}
|
|
|
|
public boolean isFinished() {
|
|
return this.mStopTime > 0 && AnimationUtils.currentAnimationTimeMillis() > this.mStopTime + ((long) this.mEffectiveRampDown);
|
|
}
|
|
|
|
private float getValueAt(long j) {
|
|
if (j < this.mStartTime) {
|
|
return 0.0f;
|
|
}
|
|
long j2 = this.mStopTime;
|
|
if (j2 < 0 || j < j2) {
|
|
return AutoScrollHelper.constrain((j - r0) / this.mRampUpDuration, 0.0f, AutoScrollHelper.DEFAULT_RELATIVE_VELOCITY) * 0.5f;
|
|
}
|
|
float f = this.mStopValue;
|
|
return (AutoScrollHelper.DEFAULT_RELATIVE_VELOCITY - f) + (f * AutoScrollHelper.constrain((j - j2) / this.mEffectiveRampDown, 0.0f, AutoScrollHelper.DEFAULT_RELATIVE_VELOCITY));
|
|
}
|
|
|
|
public void computeScrollDelta() {
|
|
if (this.mDeltaTime == 0) {
|
|
throw new RuntimeException("Cannot compute scroll delta before calling start()");
|
|
}
|
|
long currentAnimationTimeMillis = AnimationUtils.currentAnimationTimeMillis();
|
|
float interpolateValue = interpolateValue(getValueAt(currentAnimationTimeMillis));
|
|
long j = currentAnimationTimeMillis - this.mDeltaTime;
|
|
this.mDeltaTime = currentAnimationTimeMillis;
|
|
float f = j * interpolateValue;
|
|
this.mDeltaX = (int) (this.mTargetVelocityX * f);
|
|
this.mDeltaY = (int) (f * this.mTargetVelocityY);
|
|
}
|
|
|
|
public int getHorizontalDirection() {
|
|
float f = this.mTargetVelocityX;
|
|
return (int) (f / Math.abs(f));
|
|
}
|
|
|
|
public int getVerticalDirection() {
|
|
float f = this.mTargetVelocityY;
|
|
return (int) (f / Math.abs(f));
|
|
}
|
|
}
|
|
}
|