877 lines
34 KiB
Java
877 lines
34 KiB
Java
package androidx.customview.widget;
|
|
|
|
import android.content.Context;
|
|
import android.util.Log;
|
|
import android.view.MotionEvent;
|
|
import android.view.VelocityTracker;
|
|
import android.view.View;
|
|
import android.view.ViewConfiguration;
|
|
import android.view.ViewGroup;
|
|
import android.view.animation.Interpolator;
|
|
import android.widget.OverScroller;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.Px;
|
|
import androidx.core.view.ViewCompat;
|
|
import b.d.b.a.a;
|
|
import java.util.Arrays;
|
|
/* loaded from: classes.dex */
|
|
public class ViewDragHelper {
|
|
private static final int BASE_SETTLE_DURATION = 256;
|
|
public static final int DIRECTION_ALL = 3;
|
|
public static final int DIRECTION_HORIZONTAL = 1;
|
|
public static final int DIRECTION_VERTICAL = 2;
|
|
public static final int EDGE_ALL = 15;
|
|
public static final int EDGE_BOTTOM = 8;
|
|
public static final int EDGE_LEFT = 1;
|
|
public static final int EDGE_RIGHT = 2;
|
|
private static final int EDGE_SIZE = 20;
|
|
public static final int EDGE_TOP = 4;
|
|
public static final int INVALID_POINTER = -1;
|
|
private static final int MAX_SETTLE_DURATION = 600;
|
|
public static final int STATE_DRAGGING = 1;
|
|
public static final int STATE_IDLE = 0;
|
|
public static final int STATE_SETTLING = 2;
|
|
private static final String TAG = "ViewDragHelper";
|
|
private static final Interpolator sInterpolator = new AnonymousClass1();
|
|
private final Callback mCallback;
|
|
private View mCapturedView;
|
|
private int mDragState;
|
|
private int[] mEdgeDragsInProgress;
|
|
private int[] mEdgeDragsLocked;
|
|
private int mEdgeSize;
|
|
private int[] mInitialEdgesTouched;
|
|
private float[] mInitialMotionX;
|
|
private float[] mInitialMotionY;
|
|
private float[] mLastMotionX;
|
|
private float[] mLastMotionY;
|
|
private float mMaxVelocity;
|
|
private float mMinVelocity;
|
|
private final ViewGroup mParentView;
|
|
private int mPointersDown;
|
|
private boolean mReleaseInProgress;
|
|
private OverScroller mScroller;
|
|
private int mTouchSlop;
|
|
private int mTrackingEdges;
|
|
private VelocityTracker mVelocityTracker;
|
|
private int mActivePointerId = -1;
|
|
private final Runnable mSetIdleRunnable = new AnonymousClass2();
|
|
|
|
/* renamed from: androidx.customview.widget.ViewDragHelper$1 reason: invalid class name */
|
|
/* loaded from: classes.dex */
|
|
public static class AnonymousClass1 implements Interpolator {
|
|
@Override // android.animation.TimeInterpolator
|
|
public float getInterpolation(float f) {
|
|
float f2 = f - 1.0f;
|
|
return (f2 * f2 * f2 * f2 * f2) + 1.0f;
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.customview.widget.ViewDragHelper$2 reason: invalid class name */
|
|
/* loaded from: classes.dex */
|
|
public class AnonymousClass2 implements Runnable {
|
|
public AnonymousClass2() {
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
ViewDragHelper.this.setDragState(0);
|
|
}
|
|
}
|
|
|
|
/* loaded from: classes.dex */
|
|
public static abstract class Callback {
|
|
public int clampViewPositionHorizontal(@NonNull View view, int i, int i2) {
|
|
return 0;
|
|
}
|
|
|
|
public int clampViewPositionVertical(@NonNull View view, int i, int i2) {
|
|
return 0;
|
|
}
|
|
|
|
public int getOrderedChildIndex(int i) {
|
|
return i;
|
|
}
|
|
|
|
public int getViewHorizontalDragRange(@NonNull View view) {
|
|
return 0;
|
|
}
|
|
|
|
public int getViewVerticalDragRange(@NonNull View view) {
|
|
return 0;
|
|
}
|
|
|
|
public void onEdgeDragStarted(int i, int i2) {
|
|
}
|
|
|
|
public boolean onEdgeLock(int i) {
|
|
return false;
|
|
}
|
|
|
|
public void onEdgeTouched(int i, int i2) {
|
|
}
|
|
|
|
public void onViewCaptured(@NonNull View view, int i) {
|
|
}
|
|
|
|
public void onViewDragStateChanged(int i) {
|
|
}
|
|
|
|
public void onViewPositionChanged(@NonNull View view, int i, int i2, @Px int i3, @Px int i4) {
|
|
}
|
|
|
|
public void onViewReleased(@NonNull View view, float f, float f2) {
|
|
}
|
|
|
|
public abstract boolean tryCaptureView(@NonNull View view, int i);
|
|
}
|
|
|
|
private ViewDragHelper(@NonNull Context context, @NonNull ViewGroup viewGroup, @NonNull Callback callback) {
|
|
if (viewGroup == null) {
|
|
throw new IllegalArgumentException("Parent view may not be null");
|
|
} else if (callback != null) {
|
|
this.mParentView = viewGroup;
|
|
this.mCallback = callback;
|
|
ViewConfiguration viewConfiguration = ViewConfiguration.get(context);
|
|
this.mEdgeSize = (int) ((context.getResources().getDisplayMetrics().density * 20.0f) + 0.5f);
|
|
this.mTouchSlop = viewConfiguration.getScaledTouchSlop();
|
|
this.mMaxVelocity = viewConfiguration.getScaledMaximumFlingVelocity();
|
|
this.mMinVelocity = viewConfiguration.getScaledMinimumFlingVelocity();
|
|
this.mScroller = new OverScroller(context, sInterpolator);
|
|
} else {
|
|
throw new IllegalArgumentException("Callback may not be null");
|
|
}
|
|
}
|
|
|
|
private boolean checkNewEdgeDrag(float f, float f2, int i, int i2) {
|
|
float abs = Math.abs(f);
|
|
float abs2 = Math.abs(f2);
|
|
if ((this.mInitialEdgesTouched[i] & i2) != i2 || (this.mTrackingEdges & i2) == 0 || (this.mEdgeDragsLocked[i] & i2) == i2 || (this.mEdgeDragsInProgress[i] & i2) == i2) {
|
|
return false;
|
|
}
|
|
int i3 = this.mTouchSlop;
|
|
if (abs <= i3 && abs2 <= i3) {
|
|
return false;
|
|
}
|
|
if (abs >= abs2 * 0.5f || !this.mCallback.onEdgeLock(i2)) {
|
|
return (this.mEdgeDragsInProgress[i] & i2) == 0 && abs > ((float) this.mTouchSlop);
|
|
}
|
|
int[] iArr = this.mEdgeDragsLocked;
|
|
iArr[i] = iArr[i] | i2;
|
|
return false;
|
|
}
|
|
|
|
private boolean checkTouchSlop(View view, float f, float f2) {
|
|
if (view == null) {
|
|
return false;
|
|
}
|
|
boolean z2 = this.mCallback.getViewHorizontalDragRange(view) > 0;
|
|
boolean z3 = this.mCallback.getViewVerticalDragRange(view) > 0;
|
|
if (!z2 || !z3) {
|
|
return z2 ? Math.abs(f) > ((float) this.mTouchSlop) : z3 && Math.abs(f2) > ((float) this.mTouchSlop);
|
|
}
|
|
float f3 = f2 * f2;
|
|
int i = this.mTouchSlop;
|
|
return f3 + (f * f) > ((float) (i * i));
|
|
}
|
|
|
|
private float clampMag(float f, float f2, float f3) {
|
|
float abs = Math.abs(f);
|
|
if (abs < f2) {
|
|
return 0.0f;
|
|
}
|
|
return abs > f3 ? f > 0.0f ? f3 : -f3 : f;
|
|
}
|
|
|
|
private int clampMag(int i, int i2, int i3) {
|
|
int abs = Math.abs(i);
|
|
if (abs < i2) {
|
|
return 0;
|
|
}
|
|
return abs > i3 ? i > 0 ? i3 : -i3 : i;
|
|
}
|
|
|
|
private void clearMotionHistory() {
|
|
float[] fArr = this.mInitialMotionX;
|
|
if (fArr != null) {
|
|
Arrays.fill(fArr, 0.0f);
|
|
Arrays.fill(this.mInitialMotionY, 0.0f);
|
|
Arrays.fill(this.mLastMotionX, 0.0f);
|
|
Arrays.fill(this.mLastMotionY, 0.0f);
|
|
Arrays.fill(this.mInitialEdgesTouched, 0);
|
|
Arrays.fill(this.mEdgeDragsInProgress, 0);
|
|
Arrays.fill(this.mEdgeDragsLocked, 0);
|
|
this.mPointersDown = 0;
|
|
}
|
|
}
|
|
|
|
private void clearMotionHistory(int i) {
|
|
if (this.mInitialMotionX != null && isPointerDown(i)) {
|
|
this.mInitialMotionX[i] = 0.0f;
|
|
this.mInitialMotionY[i] = 0.0f;
|
|
this.mLastMotionX[i] = 0.0f;
|
|
this.mLastMotionY[i] = 0.0f;
|
|
this.mInitialEdgesTouched[i] = 0;
|
|
this.mEdgeDragsInProgress[i] = 0;
|
|
this.mEdgeDragsLocked[i] = 0;
|
|
this.mPointersDown = (~(1 << i)) & this.mPointersDown;
|
|
}
|
|
}
|
|
|
|
private int computeAxisDuration(int i, int i2, int i3) {
|
|
if (i == 0) {
|
|
return 0;
|
|
}
|
|
int width = this.mParentView.getWidth();
|
|
float f = width / 2;
|
|
float distanceInfluenceForSnapDuration = (distanceInfluenceForSnapDuration(Math.min(1.0f, Math.abs(i) / width)) * f) + f;
|
|
int abs = Math.abs(i2);
|
|
return Math.min(abs > 0 ? Math.round(Math.abs(distanceInfluenceForSnapDuration / abs) * 1000.0f) * 4 : (int) (((Math.abs(i) / i3) + 1.0f) * 256.0f), (int) MAX_SETTLE_DURATION);
|
|
}
|
|
|
|
private int computeSettleDuration(View view, int i, int i2, int i3, int i4) {
|
|
float f;
|
|
float f2;
|
|
float f3;
|
|
float f4;
|
|
int clampMag = clampMag(i3, (int) this.mMinVelocity, (int) this.mMaxVelocity);
|
|
int clampMag2 = clampMag(i4, (int) this.mMinVelocity, (int) this.mMaxVelocity);
|
|
int abs = Math.abs(i);
|
|
int abs2 = Math.abs(i2);
|
|
int abs3 = Math.abs(clampMag);
|
|
int abs4 = Math.abs(clampMag2);
|
|
int i5 = abs3 + abs4;
|
|
int i6 = abs + abs2;
|
|
if (clampMag != 0) {
|
|
f2 = abs3;
|
|
f = i5;
|
|
} else {
|
|
f2 = abs;
|
|
f = i6;
|
|
}
|
|
float f5 = f2 / f;
|
|
if (clampMag2 != 0) {
|
|
f4 = abs4;
|
|
f3 = i5;
|
|
} else {
|
|
f4 = abs2;
|
|
f3 = i6;
|
|
}
|
|
return (int) ((computeAxisDuration(i2, clampMag2, this.mCallback.getViewVerticalDragRange(view)) * (f4 / f3)) + (computeAxisDuration(i, clampMag, this.mCallback.getViewHorizontalDragRange(view)) * f5));
|
|
}
|
|
|
|
public static ViewDragHelper create(@NonNull ViewGroup viewGroup, float f, @NonNull Callback callback) {
|
|
ViewDragHelper create = create(viewGroup, callback);
|
|
create.mTouchSlop = (int) ((1.0f / f) * create.mTouchSlop);
|
|
return create;
|
|
}
|
|
|
|
public static ViewDragHelper create(@NonNull ViewGroup viewGroup, @NonNull Callback callback) {
|
|
return new ViewDragHelper(viewGroup.getContext(), viewGroup, callback);
|
|
}
|
|
|
|
private void dispatchViewReleased(float f, float f2) {
|
|
this.mReleaseInProgress = true;
|
|
this.mCallback.onViewReleased(this.mCapturedView, f, f2);
|
|
this.mReleaseInProgress = false;
|
|
if (this.mDragState == 1) {
|
|
setDragState(0);
|
|
}
|
|
}
|
|
|
|
private float distanceInfluenceForSnapDuration(float f) {
|
|
return (float) Math.sin((f - 0.5f) * 0.47123894f);
|
|
}
|
|
|
|
private void dragTo(int i, int i2, int i3, int i4) {
|
|
int left = this.mCapturedView.getLeft();
|
|
int top = this.mCapturedView.getTop();
|
|
if (i3 != 0) {
|
|
i = this.mCallback.clampViewPositionHorizontal(this.mCapturedView, i, i3);
|
|
ViewCompat.offsetLeftAndRight(this.mCapturedView, i - left);
|
|
}
|
|
if (i4 != 0) {
|
|
i2 = this.mCallback.clampViewPositionVertical(this.mCapturedView, i2, i4);
|
|
ViewCompat.offsetTopAndBottom(this.mCapturedView, i2 - top);
|
|
}
|
|
if (i3 != 0 || i4 != 0) {
|
|
this.mCallback.onViewPositionChanged(this.mCapturedView, i, i2, i - left, i2 - top);
|
|
}
|
|
}
|
|
|
|
private void ensureMotionHistorySizeForId(int i) {
|
|
float[] fArr = this.mInitialMotionX;
|
|
if (fArr == null || fArr.length <= i) {
|
|
int i2 = i + 1;
|
|
float[] fArr2 = new float[i2];
|
|
float[] fArr3 = new float[i2];
|
|
float[] fArr4 = new float[i2];
|
|
float[] fArr5 = new float[i2];
|
|
int[] iArr = new int[i2];
|
|
int[] iArr2 = new int[i2];
|
|
int[] iArr3 = new int[i2];
|
|
if (fArr != null) {
|
|
System.arraycopy(fArr, 0, fArr2, 0, fArr.length);
|
|
float[] fArr6 = this.mInitialMotionY;
|
|
System.arraycopy(fArr6, 0, fArr3, 0, fArr6.length);
|
|
float[] fArr7 = this.mLastMotionX;
|
|
System.arraycopy(fArr7, 0, fArr4, 0, fArr7.length);
|
|
float[] fArr8 = this.mLastMotionY;
|
|
System.arraycopy(fArr8, 0, fArr5, 0, fArr8.length);
|
|
int[] iArr4 = this.mInitialEdgesTouched;
|
|
System.arraycopy(iArr4, 0, iArr, 0, iArr4.length);
|
|
int[] iArr5 = this.mEdgeDragsInProgress;
|
|
System.arraycopy(iArr5, 0, iArr2, 0, iArr5.length);
|
|
int[] iArr6 = this.mEdgeDragsLocked;
|
|
System.arraycopy(iArr6, 0, iArr3, 0, iArr6.length);
|
|
}
|
|
this.mInitialMotionX = fArr2;
|
|
this.mInitialMotionY = fArr3;
|
|
this.mLastMotionX = fArr4;
|
|
this.mLastMotionY = fArr5;
|
|
this.mInitialEdgesTouched = iArr;
|
|
this.mEdgeDragsInProgress = iArr2;
|
|
this.mEdgeDragsLocked = iArr3;
|
|
}
|
|
}
|
|
|
|
private boolean forceSettleCapturedViewAt(int i, int i2, int i3, int i4) {
|
|
int left = this.mCapturedView.getLeft();
|
|
int top = this.mCapturedView.getTop();
|
|
int i5 = i - left;
|
|
int i6 = i2 - top;
|
|
if (i5 == 0 && i6 == 0) {
|
|
this.mScroller.abortAnimation();
|
|
setDragState(0);
|
|
return false;
|
|
}
|
|
this.mScroller.startScroll(left, top, i5, i6, computeSettleDuration(this.mCapturedView, i5, i6, i3, i4));
|
|
setDragState(2);
|
|
return true;
|
|
}
|
|
|
|
private int getEdgesTouched(int i, int i2) {
|
|
int i3 = i < this.mParentView.getLeft() + this.mEdgeSize ? 1 : 0;
|
|
if (i2 < this.mParentView.getTop() + this.mEdgeSize) {
|
|
i3 |= 4;
|
|
}
|
|
if (i > this.mParentView.getRight() - this.mEdgeSize) {
|
|
i3 |= 2;
|
|
}
|
|
return i2 > this.mParentView.getBottom() - this.mEdgeSize ? i3 | 8 : i3;
|
|
}
|
|
|
|
private boolean isValidPointerForActionMove(int i) {
|
|
if (isPointerDown(i)) {
|
|
return true;
|
|
}
|
|
Log.e(TAG, "Ignoring pointerId=" + i + " because ACTION_DOWN was not received for this pointer before ACTION_MOVE. It likely happened because ViewDragHelper did not receive all the events in the event stream.");
|
|
return false;
|
|
}
|
|
|
|
private void releaseViewForPointerUp() {
|
|
this.mVelocityTracker.computeCurrentVelocity(1000, this.mMaxVelocity);
|
|
dispatchViewReleased(clampMag(this.mVelocityTracker.getXVelocity(this.mActivePointerId), this.mMinVelocity, this.mMaxVelocity), clampMag(this.mVelocityTracker.getYVelocity(this.mActivePointerId), this.mMinVelocity, this.mMaxVelocity));
|
|
}
|
|
|
|
private void reportNewEdgeDrags(float f, float f2, int i) {
|
|
int i2 = 1;
|
|
if (!checkNewEdgeDrag(f, f2, i, 1)) {
|
|
i2 = 0;
|
|
}
|
|
if (checkNewEdgeDrag(f2, f, i, 4)) {
|
|
i2 |= 4;
|
|
}
|
|
if (checkNewEdgeDrag(f, f2, i, 2)) {
|
|
i2 |= 2;
|
|
}
|
|
if (checkNewEdgeDrag(f2, f, i, 8)) {
|
|
i2 |= 8;
|
|
}
|
|
if (i2 != 0) {
|
|
int[] iArr = this.mEdgeDragsInProgress;
|
|
iArr[i] = iArr[i] | i2;
|
|
this.mCallback.onEdgeDragStarted(i2, i);
|
|
}
|
|
}
|
|
|
|
private void saveInitialMotion(float f, float f2, int i) {
|
|
ensureMotionHistorySizeForId(i);
|
|
float[] fArr = this.mInitialMotionX;
|
|
this.mLastMotionX[i] = f;
|
|
fArr[i] = f;
|
|
float[] fArr2 = this.mInitialMotionY;
|
|
this.mLastMotionY[i] = f2;
|
|
fArr2[i] = f2;
|
|
this.mInitialEdgesTouched[i] = getEdgesTouched((int) f, (int) f2);
|
|
this.mPointersDown |= 1 << i;
|
|
}
|
|
|
|
private void saveLastMotion(MotionEvent motionEvent) {
|
|
int pointerCount = motionEvent.getPointerCount();
|
|
for (int i = 0; i < pointerCount; i++) {
|
|
int pointerId = motionEvent.getPointerId(i);
|
|
if (isValidPointerForActionMove(pointerId)) {
|
|
float x2 = motionEvent.getX(i);
|
|
float y2 = motionEvent.getY(i);
|
|
this.mLastMotionX[pointerId] = x2;
|
|
this.mLastMotionY[pointerId] = y2;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void abort() {
|
|
cancel();
|
|
if (this.mDragState == 2) {
|
|
int currX = this.mScroller.getCurrX();
|
|
int currY = this.mScroller.getCurrY();
|
|
this.mScroller.abortAnimation();
|
|
int currX2 = this.mScroller.getCurrX();
|
|
int currY2 = this.mScroller.getCurrY();
|
|
this.mCallback.onViewPositionChanged(this.mCapturedView, currX2, currY2, currX2 - currX, currY2 - currY);
|
|
}
|
|
setDragState(0);
|
|
}
|
|
|
|
public boolean canScroll(@NonNull View view, boolean z2, int i, int i2, int i3, int i4) {
|
|
int i5;
|
|
if (view instanceof ViewGroup) {
|
|
ViewGroup viewGroup = (ViewGroup) view;
|
|
int scrollX = view.getScrollX();
|
|
int scrollY = view.getScrollY();
|
|
for (int childCount = viewGroup.getChildCount() - 1; childCount >= 0; childCount--) {
|
|
View childAt = viewGroup.getChildAt(childCount);
|
|
int i6 = i3 + scrollX;
|
|
if (i6 >= childAt.getLeft() && i6 < childAt.getRight() && (i5 = i4 + scrollY) >= childAt.getTop() && i5 < childAt.getBottom() && canScroll(childAt, true, i, i2, i6 - childAt.getLeft(), i5 - childAt.getTop())) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return z2 && (view.canScrollHorizontally(-i) || view.canScrollVertically(-i2));
|
|
}
|
|
|
|
public void cancel() {
|
|
this.mActivePointerId = -1;
|
|
clearMotionHistory();
|
|
VelocityTracker velocityTracker = this.mVelocityTracker;
|
|
if (velocityTracker != null) {
|
|
velocityTracker.recycle();
|
|
this.mVelocityTracker = null;
|
|
}
|
|
}
|
|
|
|
public void captureChildView(@NonNull View view, int i) {
|
|
if (view.getParent() == this.mParentView) {
|
|
this.mCapturedView = view;
|
|
this.mActivePointerId = i;
|
|
this.mCallback.onViewCaptured(view, i);
|
|
setDragState(1);
|
|
return;
|
|
}
|
|
StringBuilder S = a.S("captureChildView: parameter must be a descendant of the ViewDragHelper's tracked parent view (");
|
|
S.append(this.mParentView);
|
|
S.append(")");
|
|
throw new IllegalArgumentException(S.toString());
|
|
}
|
|
|
|
public boolean checkTouchSlop(int i) {
|
|
int length = this.mInitialMotionX.length;
|
|
for (int i2 = 0; i2 < length; i2++) {
|
|
if (checkTouchSlop(i, i2)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean checkTouchSlop(int i, int i2) {
|
|
if (!isPointerDown(i2)) {
|
|
return false;
|
|
}
|
|
boolean z2 = (i & 1) == 1;
|
|
boolean z3 = (i & 2) == 2;
|
|
float f = this.mLastMotionX[i2] - this.mInitialMotionX[i2];
|
|
float f2 = this.mLastMotionY[i2] - this.mInitialMotionY[i2];
|
|
if (!z2 || !z3) {
|
|
return z2 ? Math.abs(f) > ((float) this.mTouchSlop) : z3 && Math.abs(f2) > ((float) this.mTouchSlop);
|
|
}
|
|
float f3 = f2 * f2;
|
|
int i3 = this.mTouchSlop;
|
|
return f3 + (f * f) > ((float) (i3 * i3));
|
|
}
|
|
|
|
public boolean continueSettling(boolean z2) {
|
|
if (this.mDragState == 2) {
|
|
boolean computeScrollOffset = this.mScroller.computeScrollOffset();
|
|
int currX = this.mScroller.getCurrX();
|
|
int currY = this.mScroller.getCurrY();
|
|
int left = currX - this.mCapturedView.getLeft();
|
|
int top = currY - this.mCapturedView.getTop();
|
|
if (left != 0) {
|
|
ViewCompat.offsetLeftAndRight(this.mCapturedView, left);
|
|
}
|
|
if (top != 0) {
|
|
ViewCompat.offsetTopAndBottom(this.mCapturedView, top);
|
|
}
|
|
if (!(left == 0 && top == 0)) {
|
|
this.mCallback.onViewPositionChanged(this.mCapturedView, currX, currY, left, top);
|
|
}
|
|
if (computeScrollOffset && currX == this.mScroller.getFinalX() && currY == this.mScroller.getFinalY()) {
|
|
this.mScroller.abortAnimation();
|
|
computeScrollOffset = false;
|
|
}
|
|
if (!computeScrollOffset) {
|
|
if (z2) {
|
|
this.mParentView.post(this.mSetIdleRunnable);
|
|
} else {
|
|
setDragState(0);
|
|
}
|
|
}
|
|
}
|
|
return this.mDragState == 2;
|
|
}
|
|
|
|
@Nullable
|
|
public View findTopChildUnder(int i, int i2) {
|
|
for (int childCount = this.mParentView.getChildCount() - 1; childCount >= 0; childCount--) {
|
|
View childAt = this.mParentView.getChildAt(this.mCallback.getOrderedChildIndex(childCount));
|
|
if (i >= childAt.getLeft() && i < childAt.getRight() && i2 >= childAt.getTop() && i2 < childAt.getBottom()) {
|
|
return childAt;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void flingCapturedView(int i, int i2, int i3, int i4) {
|
|
if (this.mReleaseInProgress) {
|
|
this.mScroller.fling(this.mCapturedView.getLeft(), this.mCapturedView.getTop(), (int) this.mVelocityTracker.getXVelocity(this.mActivePointerId), (int) this.mVelocityTracker.getYVelocity(this.mActivePointerId), i, i3, i2, i4);
|
|
setDragState(2);
|
|
return;
|
|
}
|
|
throw new IllegalStateException("Cannot flingCapturedView outside of a call to Callback#onViewReleased");
|
|
}
|
|
|
|
public int getActivePointerId() {
|
|
return this.mActivePointerId;
|
|
}
|
|
|
|
@Nullable
|
|
public View getCapturedView() {
|
|
return this.mCapturedView;
|
|
}
|
|
|
|
@Px
|
|
public int getEdgeSize() {
|
|
return this.mEdgeSize;
|
|
}
|
|
|
|
public float getMinVelocity() {
|
|
return this.mMinVelocity;
|
|
}
|
|
|
|
@Px
|
|
public int getTouchSlop() {
|
|
return this.mTouchSlop;
|
|
}
|
|
|
|
public int getViewDragState() {
|
|
return this.mDragState;
|
|
}
|
|
|
|
public boolean isCapturedViewUnder(int i, int i2) {
|
|
return isViewUnder(this.mCapturedView, i, i2);
|
|
}
|
|
|
|
public boolean isEdgeTouched(int i) {
|
|
int length = this.mInitialEdgesTouched.length;
|
|
for (int i2 = 0; i2 < length; i2++) {
|
|
if (isEdgeTouched(i, i2)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isEdgeTouched(int i, int i2) {
|
|
return isPointerDown(i2) && (i & this.mInitialEdgesTouched[i2]) != 0;
|
|
}
|
|
|
|
public boolean isPointerDown(int i) {
|
|
return ((1 << i) & this.mPointersDown) != 0;
|
|
}
|
|
|
|
public boolean isViewUnder(@Nullable View view, int i, int i2) {
|
|
return view != null && i >= view.getLeft() && i < view.getRight() && i2 >= view.getTop() && i2 < view.getBottom();
|
|
}
|
|
|
|
public void processTouchEvent(@NonNull MotionEvent motionEvent) {
|
|
int i;
|
|
int actionMasked = motionEvent.getActionMasked();
|
|
int actionIndex = motionEvent.getActionIndex();
|
|
if (actionMasked == 0) {
|
|
cancel();
|
|
}
|
|
if (this.mVelocityTracker == null) {
|
|
this.mVelocityTracker = VelocityTracker.obtain();
|
|
}
|
|
this.mVelocityTracker.addMovement(motionEvent);
|
|
int i2 = 0;
|
|
if (actionMasked == 0) {
|
|
float x2 = motionEvent.getX();
|
|
float y2 = motionEvent.getY();
|
|
int pointerId = motionEvent.getPointerId(0);
|
|
View findTopChildUnder = findTopChildUnder((int) x2, (int) y2);
|
|
saveInitialMotion(x2, y2, pointerId);
|
|
tryCaptureViewForDrag(findTopChildUnder, pointerId);
|
|
int i3 = this.mInitialEdgesTouched[pointerId];
|
|
int i4 = this.mTrackingEdges;
|
|
if ((i3 & i4) != 0) {
|
|
this.mCallback.onEdgeTouched(i3 & i4, pointerId);
|
|
}
|
|
} else if (actionMasked == 1) {
|
|
if (this.mDragState == 1) {
|
|
releaseViewForPointerUp();
|
|
}
|
|
cancel();
|
|
} else if (actionMasked != 2) {
|
|
if (actionMasked == 3) {
|
|
if (this.mDragState == 1) {
|
|
dispatchViewReleased(0.0f, 0.0f);
|
|
}
|
|
cancel();
|
|
} else if (actionMasked == 5) {
|
|
int pointerId2 = motionEvent.getPointerId(actionIndex);
|
|
float x3 = motionEvent.getX(actionIndex);
|
|
float y3 = motionEvent.getY(actionIndex);
|
|
saveInitialMotion(x3, y3, pointerId2);
|
|
if (this.mDragState == 0) {
|
|
tryCaptureViewForDrag(findTopChildUnder((int) x3, (int) y3), pointerId2);
|
|
int i5 = this.mInitialEdgesTouched[pointerId2];
|
|
int i6 = this.mTrackingEdges;
|
|
if ((i5 & i6) != 0) {
|
|
this.mCallback.onEdgeTouched(i5 & i6, pointerId2);
|
|
}
|
|
} else if (isCapturedViewUnder((int) x3, (int) y3)) {
|
|
tryCaptureViewForDrag(this.mCapturedView, pointerId2);
|
|
}
|
|
} else if (actionMasked == 6) {
|
|
int pointerId3 = motionEvent.getPointerId(actionIndex);
|
|
if (this.mDragState == 1 && pointerId3 == this.mActivePointerId) {
|
|
int pointerCount = motionEvent.getPointerCount();
|
|
while (true) {
|
|
if (i2 >= pointerCount) {
|
|
i = -1;
|
|
break;
|
|
}
|
|
int pointerId4 = motionEvent.getPointerId(i2);
|
|
if (pointerId4 != this.mActivePointerId) {
|
|
View findTopChildUnder2 = findTopChildUnder((int) motionEvent.getX(i2), (int) motionEvent.getY(i2));
|
|
View view = this.mCapturedView;
|
|
if (findTopChildUnder2 == view && tryCaptureViewForDrag(view, pointerId4)) {
|
|
i = this.mActivePointerId;
|
|
break;
|
|
}
|
|
}
|
|
i2++;
|
|
}
|
|
if (i == -1) {
|
|
releaseViewForPointerUp();
|
|
}
|
|
}
|
|
clearMotionHistory(pointerId3);
|
|
}
|
|
} else if (this.mDragState != 1) {
|
|
int pointerCount2 = motionEvent.getPointerCount();
|
|
while (i2 < pointerCount2) {
|
|
int pointerId5 = motionEvent.getPointerId(i2);
|
|
if (isValidPointerForActionMove(pointerId5)) {
|
|
float x4 = motionEvent.getX(i2);
|
|
float y4 = motionEvent.getY(i2);
|
|
float f = x4 - this.mInitialMotionX[pointerId5];
|
|
float f2 = y4 - this.mInitialMotionY[pointerId5];
|
|
reportNewEdgeDrags(f, f2, pointerId5);
|
|
if (this.mDragState != 1) {
|
|
View findTopChildUnder3 = findTopChildUnder((int) x4, (int) y4);
|
|
if (checkTouchSlop(findTopChildUnder3, f, f2) && tryCaptureViewForDrag(findTopChildUnder3, pointerId5)) {
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
i2++;
|
|
}
|
|
saveLastMotion(motionEvent);
|
|
} else if (isValidPointerForActionMove(this.mActivePointerId)) {
|
|
int findPointerIndex = motionEvent.findPointerIndex(this.mActivePointerId);
|
|
float x5 = motionEvent.getX(findPointerIndex);
|
|
float y5 = motionEvent.getY(findPointerIndex);
|
|
float[] fArr = this.mLastMotionX;
|
|
int i7 = this.mActivePointerId;
|
|
int i8 = (int) (x5 - fArr[i7]);
|
|
int i9 = (int) (y5 - this.mLastMotionY[i7]);
|
|
dragTo(this.mCapturedView.getLeft() + i8, this.mCapturedView.getTop() + i9, i8, i9);
|
|
saveLastMotion(motionEvent);
|
|
}
|
|
}
|
|
|
|
public void setDragState(int i) {
|
|
this.mParentView.removeCallbacks(this.mSetIdleRunnable);
|
|
if (this.mDragState != i) {
|
|
this.mDragState = i;
|
|
this.mCallback.onViewDragStateChanged(i);
|
|
if (this.mDragState == 0) {
|
|
this.mCapturedView = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setEdgeTrackingEnabled(int i) {
|
|
this.mTrackingEdges = i;
|
|
}
|
|
|
|
public void setMinVelocity(float f) {
|
|
this.mMinVelocity = f;
|
|
}
|
|
|
|
public boolean settleCapturedViewAt(int i, int i2) {
|
|
if (this.mReleaseInProgress) {
|
|
return forceSettleCapturedViewAt(i, i2, (int) this.mVelocityTracker.getXVelocity(this.mActivePointerId), (int) this.mVelocityTracker.getYVelocity(this.mActivePointerId));
|
|
}
|
|
throw new IllegalStateException("Cannot settleCapturedViewAt outside of a call to Callback#onViewReleased");
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:47:0x00dd, code lost:
|
|
if (r12 != r11) goto L_0x00e6;
|
|
*/
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
*/
|
|
public boolean shouldInterceptTouchEvent(@NonNull MotionEvent motionEvent) {
|
|
boolean z2;
|
|
View findTopChildUnder;
|
|
int actionMasked = motionEvent.getActionMasked();
|
|
int actionIndex = motionEvent.getActionIndex();
|
|
if (actionMasked == 0) {
|
|
cancel();
|
|
}
|
|
if (this.mVelocityTracker == null) {
|
|
this.mVelocityTracker = VelocityTracker.obtain();
|
|
}
|
|
this.mVelocityTracker.addMovement(motionEvent);
|
|
if (actionMasked != 0) {
|
|
if (actionMasked != 1) {
|
|
if (actionMasked != 2) {
|
|
if (actionMasked != 3) {
|
|
if (actionMasked == 5) {
|
|
int pointerId = motionEvent.getPointerId(actionIndex);
|
|
float x2 = motionEvent.getX(actionIndex);
|
|
float y2 = motionEvent.getY(actionIndex);
|
|
saveInitialMotion(x2, y2, pointerId);
|
|
int i = this.mDragState;
|
|
if (i == 0) {
|
|
int i2 = this.mInitialEdgesTouched[pointerId];
|
|
int i3 = this.mTrackingEdges;
|
|
if ((i2 & i3) != 0) {
|
|
this.mCallback.onEdgeTouched(i2 & i3, pointerId);
|
|
}
|
|
} else if (i == 2 && (findTopChildUnder = findTopChildUnder((int) x2, (int) y2)) == this.mCapturedView) {
|
|
tryCaptureViewForDrag(findTopChildUnder, pointerId);
|
|
}
|
|
} else if (actionMasked == 6) {
|
|
clearMotionHistory(motionEvent.getPointerId(actionIndex));
|
|
}
|
|
}
|
|
} else if (!(this.mInitialMotionX == null || this.mInitialMotionY == null)) {
|
|
int pointerCount = motionEvent.getPointerCount();
|
|
for (int i4 = 0; i4 < pointerCount; i4++) {
|
|
int pointerId2 = motionEvent.getPointerId(i4);
|
|
if (isValidPointerForActionMove(pointerId2)) {
|
|
float x3 = motionEvent.getX(i4);
|
|
float y3 = motionEvent.getY(i4);
|
|
float f = x3 - this.mInitialMotionX[pointerId2];
|
|
float f2 = y3 - this.mInitialMotionY[pointerId2];
|
|
View findTopChildUnder2 = findTopChildUnder((int) x3, (int) y3);
|
|
boolean z3 = findTopChildUnder2 != null && checkTouchSlop(findTopChildUnder2, f, f2);
|
|
if (z3) {
|
|
int left = findTopChildUnder2.getLeft();
|
|
int i5 = (int) f;
|
|
int clampViewPositionHorizontal = this.mCallback.clampViewPositionHorizontal(findTopChildUnder2, left + i5, i5);
|
|
int top = findTopChildUnder2.getTop();
|
|
int i6 = (int) f2;
|
|
int clampViewPositionVertical = this.mCallback.clampViewPositionVertical(findTopChildUnder2, top + i6, i6);
|
|
int viewHorizontalDragRange = this.mCallback.getViewHorizontalDragRange(findTopChildUnder2);
|
|
int viewVerticalDragRange = this.mCallback.getViewVerticalDragRange(findTopChildUnder2);
|
|
if (viewHorizontalDragRange != 0) {
|
|
if (viewHorizontalDragRange > 0) {
|
|
}
|
|
}
|
|
if (viewVerticalDragRange != 0) {
|
|
if (viewVerticalDragRange > 0 && clampViewPositionVertical == top) {
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
reportNewEdgeDrags(f, f2, pointerId2);
|
|
if (this.mDragState != 1) {
|
|
if (z3 && tryCaptureViewForDrag(findTopChildUnder2, pointerId2)) {
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
saveLastMotion(motionEvent);
|
|
}
|
|
z2 = false;
|
|
}
|
|
cancel();
|
|
z2 = false;
|
|
} else {
|
|
float x4 = motionEvent.getX();
|
|
float y4 = motionEvent.getY();
|
|
z2 = false;
|
|
int pointerId3 = motionEvent.getPointerId(0);
|
|
saveInitialMotion(x4, y4, pointerId3);
|
|
View findTopChildUnder3 = findTopChildUnder((int) x4, (int) y4);
|
|
if (findTopChildUnder3 == this.mCapturedView && this.mDragState == 2) {
|
|
tryCaptureViewForDrag(findTopChildUnder3, pointerId3);
|
|
}
|
|
int i7 = this.mInitialEdgesTouched[pointerId3];
|
|
int i8 = this.mTrackingEdges;
|
|
if ((i7 & i8) != 0) {
|
|
this.mCallback.onEdgeTouched(i7 & i8, pointerId3);
|
|
}
|
|
}
|
|
if (this.mDragState == 1) {
|
|
return true;
|
|
}
|
|
return z2;
|
|
}
|
|
|
|
public boolean smoothSlideViewTo(@NonNull View view, int i, int i2) {
|
|
this.mCapturedView = view;
|
|
this.mActivePointerId = -1;
|
|
boolean forceSettleCapturedViewAt = forceSettleCapturedViewAt(i, i2, 0, 0);
|
|
if (!forceSettleCapturedViewAt && this.mDragState == 0 && this.mCapturedView != null) {
|
|
this.mCapturedView = null;
|
|
}
|
|
return forceSettleCapturedViewAt;
|
|
}
|
|
|
|
public boolean tryCaptureViewForDrag(View view, int i) {
|
|
if (view == this.mCapturedView && this.mActivePointerId == i) {
|
|
return true;
|
|
}
|
|
if (view == null || !this.mCallback.tryCaptureView(view, i)) {
|
|
return false;
|
|
}
|
|
this.mActivePointerId = i;
|
|
captureChildView(view, i);
|
|
return true;
|
|
}
|
|
}
|