1390 lines
63 KiB
Java
1390 lines
63 KiB
Java
package androidx.recyclerview.widget;
|
|
|
|
import android.animation.Animator;
|
|
import android.animation.ValueAnimator;
|
|
import android.content.res.Resources;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Rect;
|
|
import android.util.Log;
|
|
import android.view.GestureDetector;
|
|
import android.view.MotionEvent;
|
|
import android.view.VelocityTracker;
|
|
import android.view.View;
|
|
import android.view.ViewConfiguration;
|
|
import android.view.ViewParent;
|
|
import android.view.animation.Interpolator;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.core.view.GestureDetectorCompat;
|
|
import androidx.core.view.ViewCompat;
|
|
import androidx.recyclerview.R;
|
|
import androidx.recyclerview.widget.RecyclerView;
|
|
import c.d.b.a.a;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
public class ItemTouchHelper extends RecyclerView.ItemDecoration implements RecyclerView.OnChildAttachStateChangeListener {
|
|
public static final int ACTION_MODE_DRAG_MASK = 16711680;
|
|
private static final int ACTION_MODE_IDLE_MASK = 255;
|
|
public static final int ACTION_MODE_SWIPE_MASK = 65280;
|
|
public static final int ACTION_STATE_DRAG = 2;
|
|
public static final int ACTION_STATE_IDLE = 0;
|
|
public static final int ACTION_STATE_SWIPE = 1;
|
|
private static final int ACTIVE_POINTER_ID_NONE = -1;
|
|
public static final int ANIMATION_TYPE_DRAG = 8;
|
|
public static final int ANIMATION_TYPE_SWIPE_CANCEL = 4;
|
|
public static final int ANIMATION_TYPE_SWIPE_SUCCESS = 2;
|
|
private static final boolean DEBUG = false;
|
|
public static final int DIRECTION_FLAG_COUNT = 8;
|
|
public static final int DOWN = 2;
|
|
public static final int END = 32;
|
|
public static final int LEFT = 4;
|
|
private static final int PIXELS_PER_SECOND = 1000;
|
|
public static final int RIGHT = 8;
|
|
public static final int START = 16;
|
|
private static final String TAG = "ItemTouchHelper";
|
|
public static final int UP = 1;
|
|
private int mActionState = 0;
|
|
public int mActivePointerId = -1;
|
|
@NonNull
|
|
public Callback mCallback;
|
|
private RecyclerView.ChildDrawingOrderCallback mChildDrawingOrderCallback = null;
|
|
private List<Integer> mDistances;
|
|
private long mDragScrollStartTimeInMs;
|
|
public float mDx;
|
|
public float mDy;
|
|
public GestureDetectorCompat mGestureDetector;
|
|
public float mInitialTouchX;
|
|
public float mInitialTouchY;
|
|
private ItemTouchHelperGestureListener mItemTouchHelperGestureListener;
|
|
private float mMaxSwipeVelocity;
|
|
private final RecyclerView.OnItemTouchListener mOnItemTouchListener = new AnonymousClass2();
|
|
public View mOverdrawChild = null;
|
|
public int mOverdrawChildPosition = -1;
|
|
public final List<View> mPendingCleanup = new ArrayList();
|
|
public List<RecoverAnimation> mRecoverAnimations = new ArrayList();
|
|
public RecyclerView mRecyclerView;
|
|
public final Runnable mScrollRunnable = new AnonymousClass1();
|
|
public RecyclerView.ViewHolder mSelected = null;
|
|
public int mSelectedFlags;
|
|
private float mSelectedStartX;
|
|
private float mSelectedStartY;
|
|
private int mSlop;
|
|
private List<RecyclerView.ViewHolder> mSwapTargets;
|
|
private float mSwipeEscapeVelocity;
|
|
private final float[] mTmpPosition = new float[2];
|
|
private Rect mTmpRect;
|
|
public VelocityTracker mVelocityTracker;
|
|
|
|
/* renamed from: androidx.recyclerview.widget.ItemTouchHelper$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements Runnable {
|
|
public AnonymousClass1() {
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
if (itemTouchHelper.mSelected != null && itemTouchHelper.scrollIfNecessary()) {
|
|
ItemTouchHelper itemTouchHelper2 = ItemTouchHelper.this;
|
|
RecyclerView.ViewHolder viewHolder = itemTouchHelper2.mSelected;
|
|
if (viewHolder != null) {
|
|
itemTouchHelper2.moveIfNecessary(viewHolder);
|
|
}
|
|
ItemTouchHelper itemTouchHelper3 = ItemTouchHelper.this;
|
|
itemTouchHelper3.mRecyclerView.removeCallbacks(itemTouchHelper3.mScrollRunnable);
|
|
ViewCompat.postOnAnimation(ItemTouchHelper.this.mRecyclerView, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.recyclerview.widget.ItemTouchHelper$2 reason: invalid class name */
|
|
public class AnonymousClass2 implements RecyclerView.OnItemTouchListener {
|
|
public AnonymousClass2() {
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnItemTouchListener
|
|
public boolean onInterceptTouchEvent(@NonNull RecyclerView recyclerView, @NonNull MotionEvent motionEvent) {
|
|
int findPointerIndex;
|
|
RecoverAnimation findAnimation;
|
|
ItemTouchHelper.this.mGestureDetector.onTouchEvent(motionEvent);
|
|
int actionMasked = motionEvent.getActionMasked();
|
|
if (actionMasked == 0) {
|
|
ItemTouchHelper.this.mActivePointerId = motionEvent.getPointerId(0);
|
|
ItemTouchHelper.this.mInitialTouchX = motionEvent.getX();
|
|
ItemTouchHelper.this.mInitialTouchY = motionEvent.getY();
|
|
ItemTouchHelper.this.obtainVelocityTracker();
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
if (itemTouchHelper.mSelected == null && (findAnimation = itemTouchHelper.findAnimation(motionEvent)) != null) {
|
|
ItemTouchHelper itemTouchHelper2 = ItemTouchHelper.this;
|
|
itemTouchHelper2.mInitialTouchX -= findAnimation.mX;
|
|
itemTouchHelper2.mInitialTouchY -= findAnimation.mY;
|
|
itemTouchHelper2.endRecoverAnimation(findAnimation.mViewHolder, true);
|
|
if (ItemTouchHelper.this.mPendingCleanup.remove(findAnimation.mViewHolder.itemView)) {
|
|
ItemTouchHelper itemTouchHelper3 = ItemTouchHelper.this;
|
|
itemTouchHelper3.mCallback.clearView(itemTouchHelper3.mRecyclerView, findAnimation.mViewHolder);
|
|
}
|
|
ItemTouchHelper.this.select(findAnimation.mViewHolder, findAnimation.mActionState);
|
|
ItemTouchHelper itemTouchHelper4 = ItemTouchHelper.this;
|
|
itemTouchHelper4.updateDxDy(motionEvent, itemTouchHelper4.mSelectedFlags, 0);
|
|
}
|
|
} else if (actionMasked == 3 || actionMasked == 1) {
|
|
ItemTouchHelper itemTouchHelper5 = ItemTouchHelper.this;
|
|
itemTouchHelper5.mActivePointerId = -1;
|
|
itemTouchHelper5.select(null, 0);
|
|
} else {
|
|
int i = ItemTouchHelper.this.mActivePointerId;
|
|
if (i != -1 && (findPointerIndex = motionEvent.findPointerIndex(i)) >= 0) {
|
|
ItemTouchHelper.this.checkSelectForSwipe(actionMasked, motionEvent, findPointerIndex);
|
|
}
|
|
}
|
|
VelocityTracker velocityTracker = ItemTouchHelper.this.mVelocityTracker;
|
|
if (velocityTracker != null) {
|
|
velocityTracker.addMovement(motionEvent);
|
|
}
|
|
return ItemTouchHelper.this.mSelected != null;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnItemTouchListener
|
|
public void onRequestDisallowInterceptTouchEvent(boolean z2) {
|
|
if (z2) {
|
|
ItemTouchHelper.this.select(null, 0);
|
|
}
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnItemTouchListener
|
|
public void onTouchEvent(@NonNull RecyclerView recyclerView, @NonNull MotionEvent motionEvent) {
|
|
ItemTouchHelper.this.mGestureDetector.onTouchEvent(motionEvent);
|
|
VelocityTracker velocityTracker = ItemTouchHelper.this.mVelocityTracker;
|
|
if (velocityTracker != null) {
|
|
velocityTracker.addMovement(motionEvent);
|
|
}
|
|
if (ItemTouchHelper.this.mActivePointerId != -1) {
|
|
int actionMasked = motionEvent.getActionMasked();
|
|
int findPointerIndex = motionEvent.findPointerIndex(ItemTouchHelper.this.mActivePointerId);
|
|
if (findPointerIndex >= 0) {
|
|
ItemTouchHelper.this.checkSelectForSwipe(actionMasked, motionEvent, findPointerIndex);
|
|
}
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
RecyclerView.ViewHolder viewHolder = itemTouchHelper.mSelected;
|
|
if (viewHolder != null) {
|
|
int i = 0;
|
|
if (actionMasked != 1) {
|
|
if (actionMasked != 2) {
|
|
if (actionMasked == 3) {
|
|
VelocityTracker velocityTracker2 = itemTouchHelper.mVelocityTracker;
|
|
if (velocityTracker2 != null) {
|
|
velocityTracker2.clear();
|
|
}
|
|
} else if (actionMasked == 6) {
|
|
int actionIndex = motionEvent.getActionIndex();
|
|
int pointerId = motionEvent.getPointerId(actionIndex);
|
|
ItemTouchHelper itemTouchHelper2 = ItemTouchHelper.this;
|
|
if (pointerId == itemTouchHelper2.mActivePointerId) {
|
|
if (actionIndex == 0) {
|
|
i = 1;
|
|
}
|
|
itemTouchHelper2.mActivePointerId = motionEvent.getPointerId(i);
|
|
ItemTouchHelper itemTouchHelper3 = ItemTouchHelper.this;
|
|
itemTouchHelper3.updateDxDy(motionEvent, itemTouchHelper3.mSelectedFlags, actionIndex);
|
|
return;
|
|
}
|
|
return;
|
|
} else {
|
|
return;
|
|
}
|
|
} else if (findPointerIndex >= 0) {
|
|
itemTouchHelper.updateDxDy(motionEvent, itemTouchHelper.mSelectedFlags, findPointerIndex);
|
|
ItemTouchHelper.this.moveIfNecessary(viewHolder);
|
|
ItemTouchHelper itemTouchHelper4 = ItemTouchHelper.this;
|
|
itemTouchHelper4.mRecyclerView.removeCallbacks(itemTouchHelper4.mScrollRunnable);
|
|
ItemTouchHelper.this.mScrollRunnable.run();
|
|
ItemTouchHelper.this.mRecyclerView.invalidate();
|
|
return;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
ItemTouchHelper.this.select(null, 0);
|
|
ItemTouchHelper.this.mActivePointerId = -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.recyclerview.widget.ItemTouchHelper$3 reason: invalid class name */
|
|
public class AnonymousClass3 extends RecoverAnimation {
|
|
public final /* synthetic */ RecyclerView.ViewHolder val$prevSelected;
|
|
public final /* synthetic */ int val$swipeDir;
|
|
|
|
/* JADX INFO: super call moved to the top of the method (can break code semantics) */
|
|
public AnonymousClass3(RecyclerView.ViewHolder viewHolder, int i, int i2, float f, float f2, float f3, float f4, int i3, RecyclerView.ViewHolder viewHolder2) {
|
|
super(viewHolder, i, i2, f, f2, f3, f4);
|
|
this.val$swipeDir = i3;
|
|
this.val$prevSelected = viewHolder2;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.ItemTouchHelper.RecoverAnimation, android.animation.Animator.AnimatorListener
|
|
public void onAnimationEnd(Animator animator) {
|
|
super.onAnimationEnd(animator);
|
|
if (!this.mOverridden) {
|
|
if (this.val$swipeDir <= 0) {
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
itemTouchHelper.mCallback.clearView(itemTouchHelper.mRecyclerView, this.val$prevSelected);
|
|
} else {
|
|
ItemTouchHelper.this.mPendingCleanup.add(this.val$prevSelected.itemView);
|
|
this.mIsPendingCleanup = true;
|
|
int i = this.val$swipeDir;
|
|
if (i > 0) {
|
|
ItemTouchHelper.this.postDispatchSwipe(this, i);
|
|
}
|
|
}
|
|
ItemTouchHelper itemTouchHelper2 = ItemTouchHelper.this;
|
|
View view = itemTouchHelper2.mOverdrawChild;
|
|
View view2 = this.val$prevSelected.itemView;
|
|
if (view == view2) {
|
|
itemTouchHelper2.removeChildDrawingOrderCallbackIfNecessary(view2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.recyclerview.widget.ItemTouchHelper$4 reason: invalid class name */
|
|
public class AnonymousClass4 implements Runnable {
|
|
public final /* synthetic */ RecoverAnimation val$anim;
|
|
public final /* synthetic */ int val$swipeDir;
|
|
|
|
public AnonymousClass4(RecoverAnimation recoverAnimation, int i) {
|
|
this.val$anim = recoverAnimation;
|
|
this.val$swipeDir = i;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
RecyclerView recyclerView = ItemTouchHelper.this.mRecyclerView;
|
|
if (recyclerView != null && recyclerView.isAttachedToWindow()) {
|
|
RecoverAnimation recoverAnimation = this.val$anim;
|
|
if (!recoverAnimation.mOverridden && recoverAnimation.mViewHolder.getAdapterPosition() != -1) {
|
|
RecyclerView.ItemAnimator itemAnimator = ItemTouchHelper.this.mRecyclerView.getItemAnimator();
|
|
if ((itemAnimator == null || !itemAnimator.isRunning(null)) && !ItemTouchHelper.this.hasRunningRecoverAnim()) {
|
|
ItemTouchHelper.this.mCallback.onSwiped(this.val$anim.mViewHolder, this.val$swipeDir);
|
|
} else {
|
|
ItemTouchHelper.this.mRecyclerView.post(this);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.recyclerview.widget.ItemTouchHelper$5 reason: invalid class name */
|
|
public class AnonymousClass5 implements RecyclerView.ChildDrawingOrderCallback {
|
|
public AnonymousClass5() {
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.ChildDrawingOrderCallback
|
|
public int onGetChildDrawingOrder(int i, int i2) {
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
View view = itemTouchHelper.mOverdrawChild;
|
|
if (view == null) {
|
|
return i2;
|
|
}
|
|
int i3 = itemTouchHelper.mOverdrawChildPosition;
|
|
if (i3 == -1) {
|
|
i3 = itemTouchHelper.mRecyclerView.indexOfChild(view);
|
|
ItemTouchHelper.this.mOverdrawChildPosition = i3;
|
|
}
|
|
return i2 == i + -1 ? i3 : i2 < i3 ? i2 : i2 + 1;
|
|
}
|
|
}
|
|
|
|
public static abstract class Callback {
|
|
private static final int ABS_HORIZONTAL_DIR_FLAGS = 789516;
|
|
public static final int DEFAULT_DRAG_ANIMATION_DURATION = 200;
|
|
public static final int DEFAULT_SWIPE_ANIMATION_DURATION = 250;
|
|
private static final long DRAG_SCROLL_ACCELERATION_LIMIT_TIME_MS = 2000;
|
|
public static final int RELATIVE_DIR_FLAGS = 3158064;
|
|
private static final Interpolator sDragScrollInterpolator = new AnonymousClass1();
|
|
private static final Interpolator sDragViewScrollCapInterpolator = new AnonymousClass2();
|
|
private int mCachedMaxScrollSpeed = -1;
|
|
|
|
/* renamed from: androidx.recyclerview.widget.ItemTouchHelper$Callback$1 reason: invalid class name */
|
|
public static class AnonymousClass1 implements Interpolator {
|
|
@Override // android.animation.TimeInterpolator
|
|
public float getInterpolation(float f) {
|
|
return f * f * f * f * f;
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.recyclerview.widget.ItemTouchHelper$Callback$2 reason: invalid class name */
|
|
public static class AnonymousClass2 implements Interpolator {
|
|
@Override // android.animation.TimeInterpolator
|
|
public float getInterpolation(float f) {
|
|
float f2 = f - 1.0f;
|
|
return (f2 * f2 * f2 * f2 * f2) + 1.0f;
|
|
}
|
|
}
|
|
|
|
public static int convertToRelativeDirection(int i, int i2) {
|
|
int i3;
|
|
int i4 = i & 789516;
|
|
if (i4 == 0) {
|
|
return i;
|
|
}
|
|
int i5 = i & (~i4);
|
|
if (i2 == 0) {
|
|
i3 = i4 << 2;
|
|
} else {
|
|
int i6 = i4 << 1;
|
|
i5 |= -789517 & i6;
|
|
i3 = (i6 & 789516) << 2;
|
|
}
|
|
return i5 | i3;
|
|
}
|
|
|
|
@NonNull
|
|
public static ItemTouchUIUtil getDefaultUIUtil() {
|
|
return ItemTouchUIUtilImpl.INSTANCE;
|
|
}
|
|
|
|
private int getMaxDragScroll(RecyclerView recyclerView) {
|
|
if (this.mCachedMaxScrollSpeed == -1) {
|
|
this.mCachedMaxScrollSpeed = recyclerView.getResources().getDimensionPixelSize(R.dimen.item_touch_helper_max_drag_scroll_per_frame);
|
|
}
|
|
return this.mCachedMaxScrollSpeed;
|
|
}
|
|
|
|
public static int makeFlag(int i, int i2) {
|
|
return i2 << (i * 8);
|
|
}
|
|
|
|
public static int makeMovementFlags(int i, int i2) {
|
|
int makeFlag = makeFlag(0, i2 | i);
|
|
return makeFlag(2, i) | makeFlag(1, i2) | makeFlag;
|
|
}
|
|
|
|
public boolean canDropOver(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder, @NonNull RecyclerView.ViewHolder viewHolder2) {
|
|
return true;
|
|
}
|
|
|
|
public RecyclerView.ViewHolder chooseDropTarget(@NonNull RecyclerView.ViewHolder viewHolder, @NonNull List<RecyclerView.ViewHolder> list, int i, int i2) {
|
|
int bottom;
|
|
int abs;
|
|
int top;
|
|
int abs2;
|
|
int left;
|
|
int abs3;
|
|
int right;
|
|
int abs4;
|
|
int width = viewHolder.itemView.getWidth() + i;
|
|
int height = viewHolder.itemView.getHeight() + i2;
|
|
int left2 = i - viewHolder.itemView.getLeft();
|
|
int top2 = i2 - viewHolder.itemView.getTop();
|
|
int size = list.size();
|
|
RecyclerView.ViewHolder viewHolder2 = null;
|
|
int i3 = -1;
|
|
for (int i4 = 0; i4 < size; i4++) {
|
|
RecyclerView.ViewHolder viewHolder3 = list.get(i4);
|
|
if (left2 > 0 && (right = viewHolder3.itemView.getRight() - width) < 0 && viewHolder3.itemView.getRight() > viewHolder.itemView.getRight() && (abs4 = Math.abs(right)) > i3) {
|
|
viewHolder2 = viewHolder3;
|
|
i3 = abs4;
|
|
}
|
|
if (left2 < 0 && (left = viewHolder3.itemView.getLeft() - i) > 0 && viewHolder3.itemView.getLeft() < viewHolder.itemView.getLeft() && (abs3 = Math.abs(left)) > i3) {
|
|
viewHolder2 = viewHolder3;
|
|
i3 = abs3;
|
|
}
|
|
if (top2 < 0 && (top = viewHolder3.itemView.getTop() - i2) > 0 && viewHolder3.itemView.getTop() < viewHolder.itemView.getTop() && (abs2 = Math.abs(top)) > i3) {
|
|
viewHolder2 = viewHolder3;
|
|
i3 = abs2;
|
|
}
|
|
if (top2 > 0 && (bottom = viewHolder3.itemView.getBottom() - height) < 0 && viewHolder3.itemView.getBottom() > viewHolder.itemView.getBottom() && (abs = Math.abs(bottom)) > i3) {
|
|
viewHolder2 = viewHolder3;
|
|
i3 = abs;
|
|
}
|
|
}
|
|
return viewHolder2;
|
|
}
|
|
|
|
public void clearView(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder) {
|
|
ItemTouchUIUtilImpl.INSTANCE.clearView(viewHolder.itemView);
|
|
}
|
|
|
|
public int convertToAbsoluteDirection(int i, int i2) {
|
|
int i3;
|
|
int i4 = i & 3158064;
|
|
if (i4 == 0) {
|
|
return i;
|
|
}
|
|
int i5 = i & (~i4);
|
|
if (i2 == 0) {
|
|
i3 = i4 >> 2;
|
|
} else {
|
|
int i6 = i4 >> 1;
|
|
i5 |= -3158065 & i6;
|
|
i3 = (i6 & 3158064) >> 2;
|
|
}
|
|
return i5 | i3;
|
|
}
|
|
|
|
public final int getAbsoluteMovementFlags(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
return convertToAbsoluteDirection(getMovementFlags(recyclerView, viewHolder), ViewCompat.getLayoutDirection(recyclerView));
|
|
}
|
|
|
|
public long getAnimationDuration(@NonNull RecyclerView recyclerView, int i, float f, float f2) {
|
|
RecyclerView.ItemAnimator itemAnimator = recyclerView.getItemAnimator();
|
|
return itemAnimator == null ? i == 8 ? 200 : 250 : i == 8 ? itemAnimator.getMoveDuration() : itemAnimator.getRemoveDuration();
|
|
}
|
|
|
|
public int getBoundingBoxMargin() {
|
|
return 0;
|
|
}
|
|
|
|
public float getMoveThreshold(@NonNull RecyclerView.ViewHolder viewHolder) {
|
|
return 0.5f;
|
|
}
|
|
|
|
public abstract int getMovementFlags(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder);
|
|
|
|
public float getSwipeEscapeVelocity(float f) {
|
|
return f;
|
|
}
|
|
|
|
public float getSwipeThreshold(@NonNull RecyclerView.ViewHolder viewHolder) {
|
|
return 0.5f;
|
|
}
|
|
|
|
public float getSwipeVelocityThreshold(float f) {
|
|
return f;
|
|
}
|
|
|
|
public boolean hasDragFlag(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
return (getAbsoluteMovementFlags(recyclerView, viewHolder) & 16711680) != 0;
|
|
}
|
|
|
|
public boolean hasSwipeFlag(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
return (getAbsoluteMovementFlags(recyclerView, viewHolder) & 65280) != 0;
|
|
}
|
|
|
|
public int interpolateOutOfBoundsScroll(@NonNull RecyclerView recyclerView, int i, int i2, int i3, long j) {
|
|
float f = 1.0f;
|
|
int interpolation = (int) (sDragViewScrollCapInterpolator.getInterpolation(Math.min(1.0f, (((float) Math.abs(i2)) * 1.0f) / ((float) i))) * ((float) (((int) Math.signum((float) i2)) * getMaxDragScroll(recyclerView))));
|
|
if (j <= 2000) {
|
|
f = ((float) j) / 2000.0f;
|
|
}
|
|
int interpolation2 = (int) (sDragScrollInterpolator.getInterpolation(f) * ((float) interpolation));
|
|
return interpolation2 == 0 ? i2 > 0 ? 1 : -1 : interpolation2;
|
|
}
|
|
|
|
public boolean isItemViewSwipeEnabled() {
|
|
return true;
|
|
}
|
|
|
|
public boolean isLongPressDragEnabled() {
|
|
return true;
|
|
}
|
|
|
|
public void onChildDraw(@NonNull Canvas canvas, @NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder, float f, float f2, int i, boolean z2) {
|
|
ItemTouchUIUtilImpl.INSTANCE.onDraw(canvas, recyclerView, viewHolder.itemView, f, f2, i, z2);
|
|
}
|
|
|
|
public void onChildDrawOver(@NonNull Canvas canvas, @NonNull RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, float f, float f2, int i, boolean z2) {
|
|
ItemTouchUIUtilImpl.INSTANCE.onDrawOver(canvas, recyclerView, viewHolder.itemView, f, f2, i, z2);
|
|
}
|
|
|
|
public void onDraw(Canvas canvas, RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, List<RecoverAnimation> list, int i, float f, float f2) {
|
|
int size = list.size();
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
RecoverAnimation recoverAnimation = list.get(i2);
|
|
recoverAnimation.update();
|
|
int save = canvas.save();
|
|
onChildDraw(canvas, recyclerView, recoverAnimation.mViewHolder, recoverAnimation.mX, recoverAnimation.mY, recoverAnimation.mActionState, false);
|
|
canvas.restoreToCount(save);
|
|
}
|
|
if (viewHolder != null) {
|
|
int save2 = canvas.save();
|
|
onChildDraw(canvas, recyclerView, viewHolder, f, f2, i, true);
|
|
canvas.restoreToCount(save2);
|
|
}
|
|
}
|
|
|
|
public void onDrawOver(Canvas canvas, RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, List<RecoverAnimation> list, int i, float f, float f2) {
|
|
int size = list.size();
|
|
boolean z2 = false;
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
RecoverAnimation recoverAnimation = list.get(i2);
|
|
int save = canvas.save();
|
|
onChildDrawOver(canvas, recyclerView, recoverAnimation.mViewHolder, recoverAnimation.mX, recoverAnimation.mY, recoverAnimation.mActionState, false);
|
|
canvas.restoreToCount(save);
|
|
}
|
|
if (viewHolder != null) {
|
|
int save2 = canvas.save();
|
|
onChildDrawOver(canvas, recyclerView, viewHolder, f, f2, i, true);
|
|
canvas.restoreToCount(save2);
|
|
}
|
|
for (int i3 = size - 1; i3 >= 0; i3--) {
|
|
RecoverAnimation recoverAnimation2 = list.get(i3);
|
|
boolean z3 = recoverAnimation2.mEnded;
|
|
if (z3 && !recoverAnimation2.mIsPendingCleanup) {
|
|
list.remove(i3);
|
|
} else if (!z3) {
|
|
z2 = true;
|
|
}
|
|
}
|
|
if (z2) {
|
|
recyclerView.invalidate();
|
|
}
|
|
}
|
|
|
|
public abstract boolean onMove(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder, @NonNull RecyclerView.ViewHolder viewHolder2);
|
|
|
|
public void onMoved(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder, int i, @NonNull RecyclerView.ViewHolder viewHolder2, int i2, int i3, int i4) {
|
|
RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
|
|
if (layoutManager instanceof ViewDropHandler) {
|
|
((ViewDropHandler) layoutManager).prepareForDrop(viewHolder.itemView, viewHolder2.itemView, i3, i4);
|
|
return;
|
|
}
|
|
if (layoutManager.canScrollHorizontally()) {
|
|
if (layoutManager.getDecoratedLeft(viewHolder2.itemView) <= recyclerView.getPaddingLeft()) {
|
|
recyclerView.scrollToPosition(i2);
|
|
}
|
|
if (layoutManager.getDecoratedRight(viewHolder2.itemView) >= recyclerView.getWidth() - recyclerView.getPaddingRight()) {
|
|
recyclerView.scrollToPosition(i2);
|
|
}
|
|
}
|
|
if (layoutManager.canScrollVertically()) {
|
|
if (layoutManager.getDecoratedTop(viewHolder2.itemView) <= recyclerView.getPaddingTop()) {
|
|
recyclerView.scrollToPosition(i2);
|
|
}
|
|
if (layoutManager.getDecoratedBottom(viewHolder2.itemView) >= recyclerView.getHeight() - recyclerView.getPaddingBottom()) {
|
|
recyclerView.scrollToPosition(i2);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void onSelectedChanged(@Nullable RecyclerView.ViewHolder viewHolder, int i) {
|
|
if (viewHolder != null) {
|
|
ItemTouchUIUtilImpl.INSTANCE.onSelected(viewHolder.itemView);
|
|
}
|
|
}
|
|
|
|
public abstract void onSwiped(@NonNull RecyclerView.ViewHolder viewHolder, int i);
|
|
}
|
|
|
|
public class ItemTouchHelperGestureListener extends GestureDetector.SimpleOnGestureListener {
|
|
private boolean mShouldReactToLongPress = true;
|
|
|
|
public ItemTouchHelperGestureListener() {
|
|
}
|
|
|
|
public void doNotReactToLongPress() {
|
|
this.mShouldReactToLongPress = false;
|
|
}
|
|
|
|
@Override // android.view.GestureDetector.SimpleOnGestureListener, android.view.GestureDetector.OnGestureListener
|
|
public boolean onDown(MotionEvent motionEvent) {
|
|
return true;
|
|
}
|
|
|
|
@Override // android.view.GestureDetector.SimpleOnGestureListener, android.view.GestureDetector.OnGestureListener
|
|
public void onLongPress(MotionEvent motionEvent) {
|
|
View findChildView;
|
|
RecyclerView.ViewHolder childViewHolder;
|
|
int i;
|
|
if (this.mShouldReactToLongPress && (findChildView = ItemTouchHelper.this.findChildView(motionEvent)) != null && (childViewHolder = ItemTouchHelper.this.mRecyclerView.getChildViewHolder(findChildView)) != null) {
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
if (itemTouchHelper.mCallback.hasDragFlag(itemTouchHelper.mRecyclerView, childViewHolder) && motionEvent.getPointerId(0) == (i = ItemTouchHelper.this.mActivePointerId)) {
|
|
int findPointerIndex = motionEvent.findPointerIndex(i);
|
|
float x2 = motionEvent.getX(findPointerIndex);
|
|
float y2 = motionEvent.getY(findPointerIndex);
|
|
ItemTouchHelper itemTouchHelper2 = ItemTouchHelper.this;
|
|
itemTouchHelper2.mInitialTouchX = x2;
|
|
itemTouchHelper2.mInitialTouchY = y2;
|
|
itemTouchHelper2.mDy = 0.0f;
|
|
itemTouchHelper2.mDx = 0.0f;
|
|
if (itemTouchHelper2.mCallback.isLongPressDragEnabled()) {
|
|
ItemTouchHelper.this.select(childViewHolder, 2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class RecoverAnimation implements Animator.AnimatorListener {
|
|
public final int mActionState;
|
|
public final int mAnimationType;
|
|
public boolean mEnded = false;
|
|
private float mFraction;
|
|
public boolean mIsPendingCleanup;
|
|
public boolean mOverridden = false;
|
|
public final float mStartDx;
|
|
public final float mStartDy;
|
|
public final float mTargetX;
|
|
public final float mTargetY;
|
|
private final ValueAnimator mValueAnimator;
|
|
public final RecyclerView.ViewHolder mViewHolder;
|
|
public float mX;
|
|
public float mY;
|
|
|
|
/* renamed from: androidx.recyclerview.widget.ItemTouchHelper$RecoverAnimation$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements ValueAnimator.AnimatorUpdateListener {
|
|
public AnonymousClass1() {
|
|
}
|
|
|
|
@Override // android.animation.ValueAnimator.AnimatorUpdateListener
|
|
public void onAnimationUpdate(ValueAnimator valueAnimator) {
|
|
RecoverAnimation.this.setFraction(valueAnimator.getAnimatedFraction());
|
|
}
|
|
}
|
|
|
|
public RecoverAnimation(RecyclerView.ViewHolder viewHolder, int i, int i2, float f, float f2, float f3, float f4) {
|
|
this.mActionState = i2;
|
|
this.mAnimationType = i;
|
|
this.mViewHolder = viewHolder;
|
|
this.mStartDx = f;
|
|
this.mStartDy = f2;
|
|
this.mTargetX = f3;
|
|
this.mTargetY = f4;
|
|
ValueAnimator ofFloat = ValueAnimator.ofFloat(0.0f, 1.0f);
|
|
this.mValueAnimator = ofFloat;
|
|
ofFloat.addUpdateListener(new AnonymousClass1());
|
|
ofFloat.setTarget(viewHolder.itemView);
|
|
ofFloat.addListener(this);
|
|
setFraction(0.0f);
|
|
}
|
|
|
|
public void cancel() {
|
|
this.mValueAnimator.cancel();
|
|
}
|
|
|
|
@Override // android.animation.Animator.AnimatorListener
|
|
public void onAnimationCancel(Animator animator) {
|
|
setFraction(1.0f);
|
|
}
|
|
|
|
@Override // android.animation.Animator.AnimatorListener
|
|
public void onAnimationEnd(Animator animator) {
|
|
if (!this.mEnded) {
|
|
this.mViewHolder.setIsRecyclable(true);
|
|
}
|
|
this.mEnded = true;
|
|
}
|
|
|
|
@Override // android.animation.Animator.AnimatorListener
|
|
public void onAnimationRepeat(Animator animator) {
|
|
}
|
|
|
|
@Override // android.animation.Animator.AnimatorListener
|
|
public void onAnimationStart(Animator animator) {
|
|
}
|
|
|
|
public void setDuration(long j) {
|
|
this.mValueAnimator.setDuration(j);
|
|
}
|
|
|
|
public void setFraction(float f) {
|
|
this.mFraction = f;
|
|
}
|
|
|
|
public void start() {
|
|
this.mViewHolder.setIsRecyclable(false);
|
|
this.mValueAnimator.start();
|
|
}
|
|
|
|
public void update() {
|
|
float f = this.mStartDx;
|
|
float f2 = this.mTargetX;
|
|
if (f == f2) {
|
|
this.mX = this.mViewHolder.itemView.getTranslationX();
|
|
} else {
|
|
this.mX = a.a(f2, f, this.mFraction, f);
|
|
}
|
|
float f3 = this.mStartDy;
|
|
float f4 = this.mTargetY;
|
|
if (f3 == f4) {
|
|
this.mY = this.mViewHolder.itemView.getTranslationY();
|
|
} else {
|
|
this.mY = a.a(f4, f3, this.mFraction, f3);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static abstract class SimpleCallback extends Callback {
|
|
private int mDefaultDragDirs;
|
|
private int mDefaultSwipeDirs;
|
|
|
|
public SimpleCallback(int i, int i2) {
|
|
this.mDefaultSwipeDirs = i2;
|
|
this.mDefaultDragDirs = i;
|
|
}
|
|
|
|
public int getDragDirs(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder) {
|
|
return this.mDefaultDragDirs;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.ItemTouchHelper.Callback
|
|
public int getMovementFlags(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder) {
|
|
return Callback.makeMovementFlags(getDragDirs(recyclerView, viewHolder), getSwipeDirs(recyclerView, viewHolder));
|
|
}
|
|
|
|
public int getSwipeDirs(@NonNull RecyclerView recyclerView, @NonNull RecyclerView.ViewHolder viewHolder) {
|
|
return this.mDefaultSwipeDirs;
|
|
}
|
|
|
|
public void setDefaultDragDirs(int i) {
|
|
this.mDefaultDragDirs = i;
|
|
}
|
|
|
|
public void setDefaultSwipeDirs(int i) {
|
|
this.mDefaultSwipeDirs = i;
|
|
}
|
|
}
|
|
|
|
public interface ViewDropHandler {
|
|
void prepareForDrop(@NonNull View view, @NonNull View view2, int i, int i2);
|
|
}
|
|
|
|
public ItemTouchHelper(@NonNull Callback callback) {
|
|
this.mCallback = callback;
|
|
}
|
|
|
|
private void addChildDrawingOrderCallback() {
|
|
}
|
|
|
|
private int checkHorizontalSwipe(RecyclerView.ViewHolder viewHolder, int i) {
|
|
if ((i & 12) == 0) {
|
|
return 0;
|
|
}
|
|
int i2 = 8;
|
|
int i3 = this.mDx > 0.0f ? 8 : 4;
|
|
VelocityTracker velocityTracker = this.mVelocityTracker;
|
|
if (velocityTracker != null && this.mActivePointerId > -1) {
|
|
velocityTracker.computeCurrentVelocity(1000, this.mCallback.getSwipeVelocityThreshold(this.mMaxSwipeVelocity));
|
|
float xVelocity = this.mVelocityTracker.getXVelocity(this.mActivePointerId);
|
|
float yVelocity = this.mVelocityTracker.getYVelocity(this.mActivePointerId);
|
|
if (xVelocity <= 0.0f) {
|
|
i2 = 4;
|
|
}
|
|
float abs = Math.abs(xVelocity);
|
|
if ((i2 & i) != 0 && i3 == i2 && abs >= this.mCallback.getSwipeEscapeVelocity(this.mSwipeEscapeVelocity) && abs > Math.abs(yVelocity)) {
|
|
return i2;
|
|
}
|
|
}
|
|
float swipeThreshold = this.mCallback.getSwipeThreshold(viewHolder) * ((float) this.mRecyclerView.getWidth());
|
|
if ((i & i3) == 0 || Math.abs(this.mDx) <= swipeThreshold) {
|
|
return 0;
|
|
}
|
|
return i3;
|
|
}
|
|
|
|
private int checkVerticalSwipe(RecyclerView.ViewHolder viewHolder, int i) {
|
|
if ((i & 3) == 0) {
|
|
return 0;
|
|
}
|
|
int i2 = 2;
|
|
int i3 = this.mDy > 0.0f ? 2 : 1;
|
|
VelocityTracker velocityTracker = this.mVelocityTracker;
|
|
if (velocityTracker != null && this.mActivePointerId > -1) {
|
|
velocityTracker.computeCurrentVelocity(1000, this.mCallback.getSwipeVelocityThreshold(this.mMaxSwipeVelocity));
|
|
float xVelocity = this.mVelocityTracker.getXVelocity(this.mActivePointerId);
|
|
float yVelocity = this.mVelocityTracker.getYVelocity(this.mActivePointerId);
|
|
if (yVelocity <= 0.0f) {
|
|
i2 = 1;
|
|
}
|
|
float abs = Math.abs(yVelocity);
|
|
if ((i2 & i) != 0 && i2 == i3 && abs >= this.mCallback.getSwipeEscapeVelocity(this.mSwipeEscapeVelocity) && abs > Math.abs(xVelocity)) {
|
|
return i2;
|
|
}
|
|
}
|
|
float swipeThreshold = this.mCallback.getSwipeThreshold(viewHolder) * ((float) this.mRecyclerView.getHeight());
|
|
if ((i & i3) == 0 || Math.abs(this.mDy) <= swipeThreshold) {
|
|
return 0;
|
|
}
|
|
return i3;
|
|
}
|
|
|
|
private void destroyCallbacks() {
|
|
this.mRecyclerView.removeItemDecoration(this);
|
|
this.mRecyclerView.removeOnItemTouchListener(this.mOnItemTouchListener);
|
|
this.mRecyclerView.removeOnChildAttachStateChangeListener(this);
|
|
for (int size = this.mRecoverAnimations.size() - 1; size >= 0; size--) {
|
|
this.mCallback.clearView(this.mRecyclerView, this.mRecoverAnimations.get(0).mViewHolder);
|
|
}
|
|
this.mRecoverAnimations.clear();
|
|
this.mOverdrawChild = null;
|
|
this.mOverdrawChildPosition = -1;
|
|
releaseVelocityTracker();
|
|
stopGestureDetection();
|
|
}
|
|
|
|
private List<RecyclerView.ViewHolder> findSwapTargets(RecyclerView.ViewHolder viewHolder) {
|
|
RecyclerView.ViewHolder viewHolder2 = viewHolder;
|
|
List<RecyclerView.ViewHolder> list = this.mSwapTargets;
|
|
if (list == null) {
|
|
this.mSwapTargets = new ArrayList();
|
|
this.mDistances = new ArrayList();
|
|
} else {
|
|
list.clear();
|
|
this.mDistances.clear();
|
|
}
|
|
int boundingBoxMargin = this.mCallback.getBoundingBoxMargin();
|
|
int round = Math.round(this.mSelectedStartX + this.mDx) - boundingBoxMargin;
|
|
int round2 = Math.round(this.mSelectedStartY + this.mDy) - boundingBoxMargin;
|
|
int i = boundingBoxMargin * 2;
|
|
int width = viewHolder2.itemView.getWidth() + round + i;
|
|
int height = viewHolder2.itemView.getHeight() + round2 + i;
|
|
int i2 = (round + width) / 2;
|
|
int i3 = (round2 + height) / 2;
|
|
RecyclerView.LayoutManager layoutManager = this.mRecyclerView.getLayoutManager();
|
|
int childCount = layoutManager.getChildCount();
|
|
int i4 = 0;
|
|
while (i4 < childCount) {
|
|
View childAt = layoutManager.getChildAt(i4);
|
|
if (childAt != viewHolder2.itemView && childAt.getBottom() >= round2 && childAt.getTop() <= height && childAt.getRight() >= round && childAt.getLeft() <= width) {
|
|
RecyclerView.ViewHolder childViewHolder = this.mRecyclerView.getChildViewHolder(childAt);
|
|
if (this.mCallback.canDropOver(this.mRecyclerView, this.mSelected, childViewHolder)) {
|
|
int abs = Math.abs(i2 - ((childAt.getRight() + childAt.getLeft()) / 2));
|
|
int abs2 = Math.abs(i3 - ((childAt.getBottom() + childAt.getTop()) / 2));
|
|
int i5 = (abs2 * abs2) + (abs * abs);
|
|
int size = this.mSwapTargets.size();
|
|
int i6 = 0;
|
|
int i7 = 0;
|
|
while (i6 < size && i5 > this.mDistances.get(i6).intValue()) {
|
|
i7++;
|
|
i6++;
|
|
}
|
|
this.mSwapTargets.add(i7, childViewHolder);
|
|
this.mDistances.add(i7, Integer.valueOf(i5));
|
|
}
|
|
}
|
|
i4++;
|
|
viewHolder2 = viewHolder;
|
|
}
|
|
return this.mSwapTargets;
|
|
}
|
|
|
|
private RecyclerView.ViewHolder findSwipedView(MotionEvent motionEvent) {
|
|
View findChildView;
|
|
RecyclerView.LayoutManager layoutManager = this.mRecyclerView.getLayoutManager();
|
|
int i = this.mActivePointerId;
|
|
if (i == -1) {
|
|
return null;
|
|
}
|
|
int findPointerIndex = motionEvent.findPointerIndex(i);
|
|
float abs = Math.abs(motionEvent.getX(findPointerIndex) - this.mInitialTouchX);
|
|
float abs2 = Math.abs(motionEvent.getY(findPointerIndex) - this.mInitialTouchY);
|
|
int i2 = this.mSlop;
|
|
if (abs < ((float) i2) && abs2 < ((float) i2)) {
|
|
return null;
|
|
}
|
|
if (abs > abs2 && layoutManager.canScrollHorizontally()) {
|
|
return null;
|
|
}
|
|
if ((abs2 <= abs || !layoutManager.canScrollVertically()) && (findChildView = findChildView(motionEvent)) != null) {
|
|
return this.mRecyclerView.getChildViewHolder(findChildView);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void getSelectedDxDy(float[] fArr) {
|
|
if ((this.mSelectedFlags & 12) != 0) {
|
|
fArr[0] = (this.mSelectedStartX + this.mDx) - ((float) this.mSelected.itemView.getLeft());
|
|
} else {
|
|
fArr[0] = this.mSelected.itemView.getTranslationX();
|
|
}
|
|
if ((this.mSelectedFlags & 3) != 0) {
|
|
fArr[1] = (this.mSelectedStartY + this.mDy) - ((float) this.mSelected.itemView.getTop());
|
|
} else {
|
|
fArr[1] = this.mSelected.itemView.getTranslationY();
|
|
}
|
|
}
|
|
|
|
private static boolean hitTest(View view, float f, float f2, float f3, float f4) {
|
|
return f >= f3 && f <= f3 + ((float) view.getWidth()) && f2 >= f4 && f2 <= f4 + ((float) view.getHeight());
|
|
}
|
|
|
|
private void releaseVelocityTracker() {
|
|
VelocityTracker velocityTracker = this.mVelocityTracker;
|
|
if (velocityTracker != null) {
|
|
velocityTracker.recycle();
|
|
this.mVelocityTracker = null;
|
|
}
|
|
}
|
|
|
|
private void setupCallbacks() {
|
|
this.mSlop = ViewConfiguration.get(this.mRecyclerView.getContext()).getScaledTouchSlop();
|
|
this.mRecyclerView.addItemDecoration(this);
|
|
this.mRecyclerView.addOnItemTouchListener(this.mOnItemTouchListener);
|
|
this.mRecyclerView.addOnChildAttachStateChangeListener(this);
|
|
startGestureDetection();
|
|
}
|
|
|
|
private void startGestureDetection() {
|
|
this.mItemTouchHelperGestureListener = new ItemTouchHelperGestureListener();
|
|
this.mGestureDetector = new GestureDetectorCompat(this.mRecyclerView.getContext(), this.mItemTouchHelperGestureListener);
|
|
}
|
|
|
|
private void stopGestureDetection() {
|
|
ItemTouchHelperGestureListener itemTouchHelperGestureListener = this.mItemTouchHelperGestureListener;
|
|
if (itemTouchHelperGestureListener != null) {
|
|
itemTouchHelperGestureListener.doNotReactToLongPress();
|
|
this.mItemTouchHelperGestureListener = null;
|
|
}
|
|
if (this.mGestureDetector != null) {
|
|
this.mGestureDetector = null;
|
|
}
|
|
}
|
|
|
|
private int swipeIfNecessary(RecyclerView.ViewHolder viewHolder) {
|
|
if (this.mActionState == 2) {
|
|
return 0;
|
|
}
|
|
int movementFlags = this.mCallback.getMovementFlags(this.mRecyclerView, viewHolder);
|
|
int convertToAbsoluteDirection = (this.mCallback.convertToAbsoluteDirection(movementFlags, ViewCompat.getLayoutDirection(this.mRecyclerView)) & 65280) >> 8;
|
|
if (convertToAbsoluteDirection == 0) {
|
|
return 0;
|
|
}
|
|
int i = (movementFlags & 65280) >> 8;
|
|
if (Math.abs(this.mDx) > Math.abs(this.mDy)) {
|
|
int checkHorizontalSwipe = checkHorizontalSwipe(viewHolder, convertToAbsoluteDirection);
|
|
if (checkHorizontalSwipe > 0) {
|
|
return (i & checkHorizontalSwipe) == 0 ? Callback.convertToRelativeDirection(checkHorizontalSwipe, ViewCompat.getLayoutDirection(this.mRecyclerView)) : checkHorizontalSwipe;
|
|
}
|
|
int checkVerticalSwipe = checkVerticalSwipe(viewHolder, convertToAbsoluteDirection);
|
|
if (checkVerticalSwipe > 0) {
|
|
return checkVerticalSwipe;
|
|
}
|
|
} else {
|
|
int checkVerticalSwipe2 = checkVerticalSwipe(viewHolder, convertToAbsoluteDirection);
|
|
if (checkVerticalSwipe2 > 0) {
|
|
return checkVerticalSwipe2;
|
|
}
|
|
int checkHorizontalSwipe2 = checkHorizontalSwipe(viewHolder, convertToAbsoluteDirection);
|
|
if (checkHorizontalSwipe2 > 0) {
|
|
return (i & checkHorizontalSwipe2) == 0 ? Callback.convertToRelativeDirection(checkHorizontalSwipe2, ViewCompat.getLayoutDirection(this.mRecyclerView)) : checkHorizontalSwipe2;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public void attachToRecyclerView(@Nullable RecyclerView recyclerView) {
|
|
RecyclerView recyclerView2 = this.mRecyclerView;
|
|
if (recyclerView2 != recyclerView) {
|
|
if (recyclerView2 != null) {
|
|
destroyCallbacks();
|
|
}
|
|
this.mRecyclerView = recyclerView;
|
|
if (recyclerView != null) {
|
|
Resources resources = recyclerView.getResources();
|
|
this.mSwipeEscapeVelocity = resources.getDimension(R.dimen.item_touch_helper_swipe_escape_velocity);
|
|
this.mMaxSwipeVelocity = resources.getDimension(R.dimen.item_touch_helper_swipe_escape_max_velocity);
|
|
setupCallbacks();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkSelectForSwipe(int i, MotionEvent motionEvent, int i2) {
|
|
RecyclerView.ViewHolder findSwipedView;
|
|
int absoluteMovementFlags;
|
|
if (this.mSelected == null && i == 2 && this.mActionState != 2 && this.mCallback.isItemViewSwipeEnabled() && this.mRecyclerView.getScrollState() != 1 && (findSwipedView = findSwipedView(motionEvent)) != null && (absoluteMovementFlags = (this.mCallback.getAbsoluteMovementFlags(this.mRecyclerView, findSwipedView) & 65280) >> 8) != 0) {
|
|
float x2 = motionEvent.getX(i2);
|
|
float y2 = motionEvent.getY(i2);
|
|
float f = x2 - this.mInitialTouchX;
|
|
float f2 = y2 - this.mInitialTouchY;
|
|
float abs = Math.abs(f);
|
|
float abs2 = Math.abs(f2);
|
|
int i3 = this.mSlop;
|
|
if (abs >= ((float) i3) || abs2 >= ((float) i3)) {
|
|
if (abs > abs2) {
|
|
if (f < 0.0f && (absoluteMovementFlags & 4) == 0) {
|
|
return;
|
|
}
|
|
if (f > 0.0f && (absoluteMovementFlags & 8) == 0) {
|
|
return;
|
|
}
|
|
} else if (f2 < 0.0f && (absoluteMovementFlags & 1) == 0) {
|
|
return;
|
|
} else {
|
|
if (f2 > 0.0f && (absoluteMovementFlags & 2) == 0) {
|
|
return;
|
|
}
|
|
}
|
|
this.mDy = 0.0f;
|
|
this.mDx = 0.0f;
|
|
this.mActivePointerId = motionEvent.getPointerId(0);
|
|
select(findSwipedView, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void endRecoverAnimation(RecyclerView.ViewHolder viewHolder, boolean z2) {
|
|
for (int size = this.mRecoverAnimations.size() - 1; size >= 0; size--) {
|
|
RecoverAnimation recoverAnimation = this.mRecoverAnimations.get(size);
|
|
if (recoverAnimation.mViewHolder == viewHolder) {
|
|
recoverAnimation.mOverridden |= z2;
|
|
if (!recoverAnimation.mEnded) {
|
|
recoverAnimation.cancel();
|
|
}
|
|
this.mRecoverAnimations.remove(size);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public RecoverAnimation findAnimation(MotionEvent motionEvent) {
|
|
if (this.mRecoverAnimations.isEmpty()) {
|
|
return null;
|
|
}
|
|
View findChildView = findChildView(motionEvent);
|
|
for (int size = this.mRecoverAnimations.size() - 1; size >= 0; size--) {
|
|
RecoverAnimation recoverAnimation = this.mRecoverAnimations.get(size);
|
|
if (recoverAnimation.mViewHolder.itemView == findChildView) {
|
|
return recoverAnimation;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public View findChildView(MotionEvent motionEvent) {
|
|
float x2 = motionEvent.getX();
|
|
float y2 = motionEvent.getY();
|
|
RecyclerView.ViewHolder viewHolder = this.mSelected;
|
|
if (viewHolder != null) {
|
|
View view = viewHolder.itemView;
|
|
if (hitTest(view, x2, y2, this.mSelectedStartX + this.mDx, this.mSelectedStartY + this.mDy)) {
|
|
return view;
|
|
}
|
|
}
|
|
for (int size = this.mRecoverAnimations.size() - 1; size >= 0; size--) {
|
|
RecoverAnimation recoverAnimation = this.mRecoverAnimations.get(size);
|
|
View view2 = recoverAnimation.mViewHolder.itemView;
|
|
if (hitTest(view2, x2, y2, recoverAnimation.mX, recoverAnimation.mY)) {
|
|
return view2;
|
|
}
|
|
}
|
|
return this.mRecyclerView.findChildViewUnder(x2, y2);
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.ItemDecoration
|
|
public void getItemOffsets(Rect rect, View view, RecyclerView recyclerView, RecyclerView.State state) {
|
|
rect.setEmpty();
|
|
}
|
|
|
|
public boolean hasRunningRecoverAnim() {
|
|
int size = this.mRecoverAnimations.size();
|
|
for (int i = 0; i < size; i++) {
|
|
if (!this.mRecoverAnimations.get(i).mEnded) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void moveIfNecessary(RecyclerView.ViewHolder viewHolder) {
|
|
if (!this.mRecyclerView.isLayoutRequested() && this.mActionState == 2) {
|
|
float moveThreshold = this.mCallback.getMoveThreshold(viewHolder);
|
|
int i = (int) (this.mSelectedStartX + this.mDx);
|
|
int i2 = (int) (this.mSelectedStartY + this.mDy);
|
|
if (((float) Math.abs(i2 - viewHolder.itemView.getTop())) >= ((float) viewHolder.itemView.getHeight()) * moveThreshold || ((float) Math.abs(i - viewHolder.itemView.getLeft())) >= ((float) viewHolder.itemView.getWidth()) * moveThreshold) {
|
|
List<RecyclerView.ViewHolder> findSwapTargets = findSwapTargets(viewHolder);
|
|
if (findSwapTargets.size() != 0) {
|
|
RecyclerView.ViewHolder chooseDropTarget = this.mCallback.chooseDropTarget(viewHolder, findSwapTargets, i, i2);
|
|
if (chooseDropTarget == null) {
|
|
this.mSwapTargets.clear();
|
|
this.mDistances.clear();
|
|
return;
|
|
}
|
|
int adapterPosition = chooseDropTarget.getAdapterPosition();
|
|
int adapterPosition2 = viewHolder.getAdapterPosition();
|
|
if (this.mCallback.onMove(this.mRecyclerView, viewHolder, chooseDropTarget)) {
|
|
this.mCallback.onMoved(this.mRecyclerView, viewHolder, adapterPosition2, chooseDropTarget, adapterPosition, i, i2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void obtainVelocityTracker() {
|
|
VelocityTracker velocityTracker = this.mVelocityTracker;
|
|
if (velocityTracker != null) {
|
|
velocityTracker.recycle();
|
|
}
|
|
this.mVelocityTracker = VelocityTracker.obtain();
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnChildAttachStateChangeListener
|
|
public void onChildViewAttachedToWindow(@NonNull View view) {
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnChildAttachStateChangeListener
|
|
public void onChildViewDetachedFromWindow(@NonNull View view) {
|
|
removeChildDrawingOrderCallbackIfNecessary(view);
|
|
RecyclerView.ViewHolder childViewHolder = this.mRecyclerView.getChildViewHolder(view);
|
|
if (childViewHolder != null) {
|
|
RecyclerView.ViewHolder viewHolder = this.mSelected;
|
|
if (viewHolder == null || childViewHolder != viewHolder) {
|
|
endRecoverAnimation(childViewHolder, false);
|
|
if (this.mPendingCleanup.remove(childViewHolder.itemView)) {
|
|
this.mCallback.clearView(this.mRecyclerView, childViewHolder);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
select(null, 0);
|
|
}
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.ItemDecoration
|
|
public void onDraw(Canvas canvas, RecyclerView recyclerView, RecyclerView.State state) {
|
|
float f;
|
|
float f2;
|
|
this.mOverdrawChildPosition = -1;
|
|
if (this.mSelected != null) {
|
|
getSelectedDxDy(this.mTmpPosition);
|
|
float[] fArr = this.mTmpPosition;
|
|
float f3 = fArr[0];
|
|
f = fArr[1];
|
|
f2 = f3;
|
|
} else {
|
|
f2 = 0.0f;
|
|
f = 0.0f;
|
|
}
|
|
this.mCallback.onDraw(canvas, recyclerView, this.mSelected, this.mRecoverAnimations, this.mActionState, f2, f);
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.ItemDecoration
|
|
public void onDrawOver(Canvas canvas, RecyclerView recyclerView, RecyclerView.State state) {
|
|
float f;
|
|
float f2;
|
|
if (this.mSelected != null) {
|
|
getSelectedDxDy(this.mTmpPosition);
|
|
float[] fArr = this.mTmpPosition;
|
|
float f3 = fArr[0];
|
|
f = fArr[1];
|
|
f2 = f3;
|
|
} else {
|
|
f2 = 0.0f;
|
|
f = 0.0f;
|
|
}
|
|
this.mCallback.onDrawOver(canvas, recyclerView, this.mSelected, this.mRecoverAnimations, this.mActionState, f2, f);
|
|
}
|
|
|
|
public void postDispatchSwipe(RecoverAnimation recoverAnimation, int i) {
|
|
this.mRecyclerView.post(new AnonymousClass4(recoverAnimation, i));
|
|
}
|
|
|
|
public void removeChildDrawingOrderCallbackIfNecessary(View view) {
|
|
if (view == this.mOverdrawChild) {
|
|
this.mOverdrawChild = null;
|
|
if (this.mChildDrawingOrderCallback != null) {
|
|
this.mRecyclerView.setChildDrawingOrderCallback(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:24:0x0083 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:34:0x00c6 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:37:0x00e0 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:38:0x00fc */
|
|
/* JADX WARNING: Removed duplicated region for block: B:40:0x00ff A[ADDED_TO_REGION] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:45:0x010b */
|
|
public boolean scrollIfNecessary() {
|
|
int i;
|
|
int i2;
|
|
int i3;
|
|
if (this.mSelected == null) {
|
|
this.mDragScrollStartTimeInMs = Long.MIN_VALUE;
|
|
return false;
|
|
}
|
|
long currentTimeMillis = System.currentTimeMillis();
|
|
long j = this.mDragScrollStartTimeInMs;
|
|
long j2 = j == Long.MIN_VALUE ? 0 : currentTimeMillis - j;
|
|
RecyclerView.LayoutManager layoutManager = this.mRecyclerView.getLayoutManager();
|
|
if (this.mTmpRect == null) {
|
|
this.mTmpRect = new Rect();
|
|
}
|
|
layoutManager.calculateItemDecorationsForChild(this.mSelected.itemView, this.mTmpRect);
|
|
if (layoutManager.canScrollHorizontally()) {
|
|
int i4 = (int) (this.mSelectedStartX + this.mDx);
|
|
int paddingLeft = (i4 - this.mTmpRect.left) - this.mRecyclerView.getPaddingLeft();
|
|
float f = this.mDx;
|
|
if ((f < 0.0f && paddingLeft < 0) || (f > 0.0f && (paddingLeft = ((this.mSelected.itemView.getWidth() + i4) + this.mTmpRect.right) - (this.mRecyclerView.getWidth() - this.mRecyclerView.getPaddingRight())) > 0)) {
|
|
i = paddingLeft;
|
|
if (layoutManager.canScrollVertically()) {
|
|
int i5 = (int) (this.mSelectedStartY + this.mDy);
|
|
int paddingTop = (i5 - this.mTmpRect.top) - this.mRecyclerView.getPaddingTop();
|
|
float f2 = this.mDy;
|
|
if ((f2 < 0.0f && paddingTop < 0) || (f2 > 0.0f && (paddingTop = ((this.mSelected.itemView.getHeight() + i5) + this.mTmpRect.bottom) - (this.mRecyclerView.getHeight() - this.mRecyclerView.getPaddingBottom())) > 0)) {
|
|
i2 = paddingTop;
|
|
if (i != 0) {
|
|
i = this.mCallback.interpolateOutOfBoundsScroll(this.mRecyclerView, this.mSelected.itemView.getWidth(), i, this.mRecyclerView.getWidth(), j2);
|
|
}
|
|
if (i2 != 0) {
|
|
i3 = i;
|
|
i2 = this.mCallback.interpolateOutOfBoundsScroll(this.mRecyclerView, this.mSelected.itemView.getHeight(), i2, this.mRecyclerView.getHeight(), j2);
|
|
} else {
|
|
i3 = i;
|
|
}
|
|
if (i3 == 0 || i2 != 0) {
|
|
if (this.mDragScrollStartTimeInMs == Long.MIN_VALUE) {
|
|
this.mDragScrollStartTimeInMs = currentTimeMillis;
|
|
}
|
|
this.mRecyclerView.scrollBy(i3, i2);
|
|
return true;
|
|
}
|
|
this.mDragScrollStartTimeInMs = Long.MIN_VALUE;
|
|
return false;
|
|
}
|
|
}
|
|
i2 = 0;
|
|
if (i != 0) {
|
|
}
|
|
if (i2 != 0) {
|
|
}
|
|
if (i3 == 0) {
|
|
}
|
|
if (this.mDragScrollStartTimeInMs == Long.MIN_VALUE) {
|
|
}
|
|
this.mRecyclerView.scrollBy(i3, i2);
|
|
return true;
|
|
}
|
|
}
|
|
i = 0;
|
|
if (layoutManager.canScrollVertically()) {
|
|
}
|
|
i2 = 0;
|
|
if (i != 0) {
|
|
}
|
|
if (i2 != 0) {
|
|
}
|
|
if (i3 == 0) {
|
|
}
|
|
if (this.mDragScrollStartTimeInMs == Long.MIN_VALUE) {
|
|
}
|
|
this.mRecyclerView.scrollBy(i3, i2);
|
|
return true;
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:47:0x012b */
|
|
/* JADX WARNING: Removed duplicated region for block: B:53:0x0137 */
|
|
public void select(@Nullable RecyclerView.ViewHolder viewHolder, int i) {
|
|
boolean z2;
|
|
ViewParent parent;
|
|
float f;
|
|
float f2;
|
|
if (viewHolder != this.mSelected || i != this.mActionState) {
|
|
this.mDragScrollStartTimeInMs = Long.MIN_VALUE;
|
|
int i2 = this.mActionState;
|
|
endRecoverAnimation(viewHolder, true);
|
|
this.mActionState = i;
|
|
if (i == 2) {
|
|
if (viewHolder != null) {
|
|
this.mOverdrawChild = viewHolder.itemView;
|
|
addChildDrawingOrderCallback();
|
|
} else {
|
|
throw new IllegalArgumentException("Must pass a ViewHolder when dragging");
|
|
}
|
|
}
|
|
int i3 = (1 << ((i * 8) + 8)) - 1;
|
|
RecyclerView.ViewHolder viewHolder2 = this.mSelected;
|
|
if (viewHolder2 != null) {
|
|
if (viewHolder2.itemView.getParent() != null) {
|
|
int swipeIfNecessary = i2 == 2 ? 0 : swipeIfNecessary(viewHolder2);
|
|
releaseVelocityTracker();
|
|
if (swipeIfNecessary == 1 || swipeIfNecessary == 2) {
|
|
f = Math.signum(this.mDy) * ((float) this.mRecyclerView.getHeight());
|
|
f2 = 0.0f;
|
|
} else {
|
|
f2 = (swipeIfNecessary == 4 || swipeIfNecessary == 8 || swipeIfNecessary == 16 || swipeIfNecessary == 32) ? Math.signum(this.mDx) * ((float) this.mRecyclerView.getWidth()) : 0.0f;
|
|
f = 0.0f;
|
|
}
|
|
int i4 = i2 == 2 ? 8 : swipeIfNecessary > 0 ? 2 : 4;
|
|
getSelectedDxDy(this.mTmpPosition);
|
|
float[] fArr = this.mTmpPosition;
|
|
float f3 = fArr[0];
|
|
float f4 = fArr[1];
|
|
AnonymousClass3 r5 = new AnonymousClass3(viewHolder2, i4, i2, f3, f4, f2, f, swipeIfNecessary, viewHolder2);
|
|
r5.setDuration(this.mCallback.getAnimationDuration(this.mRecyclerView, i4, f2 - f3, f - f4));
|
|
this.mRecoverAnimations.add(r5);
|
|
r5.start();
|
|
z2 = true;
|
|
} else {
|
|
removeChildDrawingOrderCallbackIfNecessary(viewHolder2.itemView);
|
|
this.mCallback.clearView(this.mRecyclerView, viewHolder2);
|
|
z2 = false;
|
|
}
|
|
this.mSelected = null;
|
|
} else {
|
|
z2 = false;
|
|
}
|
|
if (viewHolder != null) {
|
|
this.mSelectedFlags = (this.mCallback.getAbsoluteMovementFlags(this.mRecyclerView, viewHolder) & i3) >> (this.mActionState * 8);
|
|
this.mSelectedStartX = (float) viewHolder.itemView.getLeft();
|
|
this.mSelectedStartY = (float) viewHolder.itemView.getTop();
|
|
this.mSelected = viewHolder;
|
|
if (i == 2) {
|
|
viewHolder.itemView.performHapticFeedback(0);
|
|
parent = this.mRecyclerView.getParent();
|
|
if (parent != null) {
|
|
parent.requestDisallowInterceptTouchEvent(this.mSelected != null);
|
|
}
|
|
if (!z2) {
|
|
this.mRecyclerView.getLayoutManager().requestSimpleAnimationsInNextLayout();
|
|
}
|
|
this.mCallback.onSelectedChanged(this.mSelected, this.mActionState);
|
|
this.mRecyclerView.invalidate();
|
|
}
|
|
}
|
|
parent = this.mRecyclerView.getParent();
|
|
if (parent != null) {
|
|
}
|
|
if (!z2) {
|
|
}
|
|
this.mCallback.onSelectedChanged(this.mSelected, this.mActionState);
|
|
this.mRecyclerView.invalidate();
|
|
}
|
|
}
|
|
|
|
public void startDrag(@NonNull RecyclerView.ViewHolder viewHolder) {
|
|
if (!this.mCallback.hasDragFlag(this.mRecyclerView, viewHolder)) {
|
|
Log.e("ItemTouchHelper", "Start drag has been called but dragging is not enabled");
|
|
} else if (viewHolder.itemView.getParent() != this.mRecyclerView) {
|
|
Log.e("ItemTouchHelper", "Start drag has been called with a view holder which is not a child of the RecyclerView which is controlled by this ItemTouchHelper.");
|
|
} else {
|
|
obtainVelocityTracker();
|
|
this.mDy = 0.0f;
|
|
this.mDx = 0.0f;
|
|
select(viewHolder, 2);
|
|
}
|
|
}
|
|
|
|
public void startSwipe(@NonNull RecyclerView.ViewHolder viewHolder) {
|
|
if (!this.mCallback.hasSwipeFlag(this.mRecyclerView, viewHolder)) {
|
|
Log.e("ItemTouchHelper", "Start swipe has been called but swiping is not enabled");
|
|
} else if (viewHolder.itemView.getParent() != this.mRecyclerView) {
|
|
Log.e("ItemTouchHelper", "Start swipe has been called with a view holder which is not a child of the RecyclerView controlled by this ItemTouchHelper.");
|
|
} else {
|
|
obtainVelocityTracker();
|
|
this.mDy = 0.0f;
|
|
this.mDx = 0.0f;
|
|
select(viewHolder, 1);
|
|
}
|
|
}
|
|
|
|
public void updateDxDy(MotionEvent motionEvent, int i, int i2) {
|
|
float x2 = motionEvent.getX(i2);
|
|
float y2 = motionEvent.getY(i2);
|
|
float f = x2 - this.mInitialTouchX;
|
|
this.mDx = f;
|
|
this.mDy = y2 - this.mInitialTouchY;
|
|
if ((i & 4) == 0) {
|
|
this.mDx = Math.max(0.0f, f);
|
|
}
|
|
if ((i & 8) == 0) {
|
|
this.mDx = Math.min(0.0f, this.mDx);
|
|
}
|
|
if ((i & 1) == 0) {
|
|
this.mDy = Math.max(0.0f, this.mDy);
|
|
}
|
|
if ((i & 2) == 0) {
|
|
this.mDy = Math.min(0.0f, this.mDy);
|
|
}
|
|
}
|
|
}
|