1163 lines
51 KiB
Java
1163 lines
51 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.animation.Interpolator;
|
|
import androidx.core.view.GestureDetectorCompat;
|
|
import androidx.core.view.ViewCompat;
|
|
import androidx.recyclerview.R;
|
|
import androidx.recyclerview.widget.RecyclerView;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class ItemTouchHelper extends RecyclerView.ItemDecoration implements RecyclerView.OnChildAttachStateChangeListener {
|
|
static final int ACTION_MODE_DRAG_MASK = 16711680;
|
|
private static final int ACTION_MODE_IDLE_MASK = 255;
|
|
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;
|
|
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;
|
|
Callback mCallback;
|
|
private List<Integer> mDistances;
|
|
private long mDragScrollStartTimeInMs;
|
|
float mDx;
|
|
float mDy;
|
|
GestureDetectorCompat mGestureDetector;
|
|
float mInitialTouchX;
|
|
float mInitialTouchY;
|
|
private ItemTouchHelperGestureListener mItemTouchHelperGestureListener;
|
|
private float mMaxSwipeVelocity;
|
|
RecyclerView mRecyclerView;
|
|
int mSelectedFlags;
|
|
private float mSelectedStartX;
|
|
private float mSelectedStartY;
|
|
private int mSlop;
|
|
private List<RecyclerView.ViewHolder> mSwapTargets;
|
|
private float mSwipeEscapeVelocity;
|
|
private Rect mTmpRect;
|
|
VelocityTracker mVelocityTracker;
|
|
final List<View> mPendingCleanup = new ArrayList();
|
|
private final float[] mTmpPosition = new float[2];
|
|
RecyclerView.ViewHolder mSelected = null;
|
|
int mActivePointerId = -1;
|
|
private int mActionState = 0;
|
|
List<RecoverAnimation> mRecoverAnimations = new ArrayList();
|
|
final Runnable mScrollRunnable = new Runnable() { // from class: androidx.recyclerview.widget.ItemTouchHelper.1
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (ItemTouchHelper.this.mSelected == null || !ItemTouchHelper.this.scrollIfNecessary()) {
|
|
return;
|
|
}
|
|
if (ItemTouchHelper.this.mSelected != null) {
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
itemTouchHelper.moveIfNecessary(itemTouchHelper.mSelected);
|
|
}
|
|
ItemTouchHelper.this.mRecyclerView.removeCallbacks(ItemTouchHelper.this.mScrollRunnable);
|
|
ViewCompat.postOnAnimation(ItemTouchHelper.this.mRecyclerView, this);
|
|
}
|
|
};
|
|
private RecyclerView.ChildDrawingOrderCallback mChildDrawingOrderCallback = null;
|
|
View mOverdrawChild = null;
|
|
int mOverdrawChildPosition = -1;
|
|
private final RecyclerView.OnItemTouchListener mOnItemTouchListener = new RecyclerView.OnItemTouchListener() { // from class: androidx.recyclerview.widget.ItemTouchHelper.2
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnItemTouchListener
|
|
public boolean onInterceptTouchEvent(RecyclerView recyclerView, 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();
|
|
if (ItemTouchHelper.this.mSelected == null && (findAnimation = ItemTouchHelper.this.findAnimation(motionEvent)) != null) {
|
|
ItemTouchHelper.this.mInitialTouchX -= findAnimation.mX;
|
|
ItemTouchHelper.this.mInitialTouchY -= findAnimation.mY;
|
|
ItemTouchHelper.this.endRecoverAnimation(findAnimation.mViewHolder, true);
|
|
if (ItemTouchHelper.this.mPendingCleanup.remove(findAnimation.mViewHolder.itemView)) {
|
|
ItemTouchHelper.this.mCallback.clearView(ItemTouchHelper.this.mRecyclerView, findAnimation.mViewHolder);
|
|
}
|
|
ItemTouchHelper.this.select(findAnimation.mViewHolder, findAnimation.mActionState);
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
itemTouchHelper.updateDxDy(motionEvent, itemTouchHelper.mSelectedFlags, 0);
|
|
}
|
|
} else if (actionMasked == 3 || actionMasked == 1) {
|
|
ItemTouchHelper.this.mActivePointerId = -1;
|
|
ItemTouchHelper.this.select(null, 0);
|
|
} else if (ItemTouchHelper.this.mActivePointerId != -1 && (findPointerIndex = motionEvent.findPointerIndex(ItemTouchHelper.this.mActivePointerId)) >= 0) {
|
|
ItemTouchHelper.this.checkSelectForSwipe(actionMasked, motionEvent, findPointerIndex);
|
|
}
|
|
if (ItemTouchHelper.this.mVelocityTracker != null) {
|
|
ItemTouchHelper.this.mVelocityTracker.addMovement(motionEvent);
|
|
}
|
|
return ItemTouchHelper.this.mSelected != null;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnItemTouchListener
|
|
public void onTouchEvent(RecyclerView recyclerView, MotionEvent motionEvent) {
|
|
ItemTouchHelper.this.mGestureDetector.onTouchEvent(motionEvent);
|
|
if (ItemTouchHelper.this.mVelocityTracker != null) {
|
|
ItemTouchHelper.this.mVelocityTracker.addMovement(motionEvent);
|
|
}
|
|
if (ItemTouchHelper.this.mActivePointerId == -1) {
|
|
return;
|
|
}
|
|
int actionMasked = motionEvent.getActionMasked();
|
|
int findPointerIndex = motionEvent.findPointerIndex(ItemTouchHelper.this.mActivePointerId);
|
|
if (findPointerIndex >= 0) {
|
|
ItemTouchHelper.this.checkSelectForSwipe(actionMasked, motionEvent, findPointerIndex);
|
|
}
|
|
RecyclerView.ViewHolder viewHolder = ItemTouchHelper.this.mSelected;
|
|
if (viewHolder == null) {
|
|
return;
|
|
}
|
|
if (actionMasked != 1) {
|
|
if (actionMasked == 2) {
|
|
if (findPointerIndex >= 0) {
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
itemTouchHelper.updateDxDy(motionEvent, itemTouchHelper.mSelectedFlags, findPointerIndex);
|
|
ItemTouchHelper.this.moveIfNecessary(viewHolder);
|
|
ItemTouchHelper.this.mRecyclerView.removeCallbacks(ItemTouchHelper.this.mScrollRunnable);
|
|
ItemTouchHelper.this.mScrollRunnable.run();
|
|
ItemTouchHelper.this.mRecyclerView.invalidate();
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (actionMasked != 3) {
|
|
if (actionMasked != 6) {
|
|
return;
|
|
}
|
|
int actionIndex = motionEvent.getActionIndex();
|
|
if (motionEvent.getPointerId(actionIndex) == ItemTouchHelper.this.mActivePointerId) {
|
|
ItemTouchHelper.this.mActivePointerId = motionEvent.getPointerId(actionIndex == 0 ? 1 : 0);
|
|
ItemTouchHelper itemTouchHelper2 = ItemTouchHelper.this;
|
|
itemTouchHelper2.updateDxDy(motionEvent, itemTouchHelper2.mSelectedFlags, actionIndex);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (ItemTouchHelper.this.mVelocityTracker != null) {
|
|
ItemTouchHelper.this.mVelocityTracker.clear();
|
|
}
|
|
}
|
|
ItemTouchHelper.this.select(null, 0);
|
|
ItemTouchHelper.this.mActivePointerId = -1;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnItemTouchListener
|
|
public void onRequestDisallowInterceptTouchEvent(boolean z) {
|
|
if (z) {
|
|
ItemTouchHelper.this.select(null, 0);
|
|
}
|
|
}
|
|
};
|
|
|
|
public interface ViewDropHandler {
|
|
void prepareForDrop(View view, View view2, int i, int i2);
|
|
}
|
|
|
|
private void addChildDrawingOrderCallback() {
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnChildAttachStateChangeListener
|
|
public void onChildViewAttachedToWindow(View view) {
|
|
}
|
|
|
|
public ItemTouchHelper(Callback callback) {
|
|
this.mCallback = callback;
|
|
}
|
|
|
|
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());
|
|
}
|
|
|
|
public void attachToRecyclerView(RecyclerView recyclerView) {
|
|
RecyclerView recyclerView2 = this.mRecyclerView;
|
|
if (recyclerView2 == recyclerView) {
|
|
return;
|
|
}
|
|
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();
|
|
}
|
|
}
|
|
|
|
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 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 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 void getSelectedDxDy(float[] fArr) {
|
|
if ((this.mSelectedFlags & 12) != 0) {
|
|
fArr[0] = (this.mSelectedStartX + this.mDx) - this.mSelected.itemView.getLeft();
|
|
} else {
|
|
fArr[0] = this.mSelected.itemView.getTranslationX();
|
|
}
|
|
if ((this.mSelectedFlags & 3) != 0) {
|
|
fArr[1] = (this.mSelectedStartY + this.mDy) - this.mSelected.itemView.getTop();
|
|
} else {
|
|
fArr[1] = this.mSelected.itemView.getTranslationY();
|
|
}
|
|
}
|
|
|
|
@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];
|
|
f2 = fArr[1];
|
|
f = f3;
|
|
} else {
|
|
f = 0.0f;
|
|
f2 = 0.0f;
|
|
}
|
|
this.mCallback.onDrawOver(canvas, recyclerView, this.mSelected, this.mRecoverAnimations, this.mActionState, f, f2);
|
|
}
|
|
|
|
@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];
|
|
f2 = fArr[1];
|
|
f = f3;
|
|
} else {
|
|
f = 0.0f;
|
|
f2 = 0.0f;
|
|
}
|
|
this.mCallback.onDraw(canvas, recyclerView, this.mSelected, this.mRecoverAnimations, this.mActionState, f, f2);
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:40:0x012b */
|
|
/* JADX WARN: Removed duplicated region for block: B:46:0x0137 */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
void select(androidx.recyclerview.widget.RecyclerView.ViewHolder r24, int r25) {
|
|
/*
|
|
Method dump skipped, instructions count: 335
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.recyclerview.widget.ItemTouchHelper.select(androidx.recyclerview.widget.RecyclerView$ViewHolder, int):void");
|
|
}
|
|
|
|
void postDispatchSwipe(final RecoverAnimation recoverAnimation, final int i) {
|
|
this.mRecyclerView.post(new Runnable() { // from class: androidx.recyclerview.widget.ItemTouchHelper.4
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (ItemTouchHelper.this.mRecyclerView == null || !ItemTouchHelper.this.mRecyclerView.isAttachedToWindow() || recoverAnimation.mOverridden || recoverAnimation.mViewHolder.getAdapterPosition() == -1) {
|
|
return;
|
|
}
|
|
RecyclerView.ItemAnimator itemAnimator = ItemTouchHelper.this.mRecyclerView.getItemAnimator();
|
|
if ((itemAnimator == null || !itemAnimator.isRunning(null)) && !ItemTouchHelper.this.hasRunningRecoverAnim()) {
|
|
ItemTouchHelper.this.mCallback.onSwiped(recoverAnimation.mViewHolder, i);
|
|
} else {
|
|
ItemTouchHelper.this.mRecyclerView.post(this);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
boolean hasRunningRecoverAnim() {
|
|
int size = this.mRecoverAnimations.size();
|
|
for (int i = 0; i < size; i++) {
|
|
if (!this.mRecoverAnimations.get(i).mEnded) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:42:0x00c1, code lost:
|
|
|
|
if (r1 > 0) goto L37;
|
|
*/
|
|
/* JADX WARN: Removed duplicated region for block: B:20:0x0084 */
|
|
/* JADX WARN: Removed duplicated region for block: B:25:0x00c7 */
|
|
/* JADX WARN: Removed duplicated region for block: B:28:0x00e1 */
|
|
/* JADX WARN: Removed duplicated region for block: B:30:0x0100 A[ADDED_TO_REGION] */
|
|
/* JADX WARN: Removed duplicated region for block: B:35:0x010c */
|
|
/* JADX WARN: Removed duplicated region for block: B:38:0x00fd */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
boolean scrollIfNecessary() {
|
|
/*
|
|
Method dump skipped, instructions count: 277
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.recyclerview.widget.ItemTouchHelper.scrollIfNecessary():boolean");
|
|
}
|
|
|
|
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.getLeft() + childAt.getRight()) / 2));
|
|
int abs2 = Math.abs(i3 - ((childAt.getTop() + childAt.getBottom()) / 2));
|
|
int i5 = (abs * abs) + (abs2 * abs2);
|
|
int size = this.mSwapTargets.size();
|
|
int i6 = 0;
|
|
for (int i7 = 0; i7 < size && i5 > this.mDistances.get(i7).intValue(); i7++) {
|
|
i6++;
|
|
}
|
|
this.mSwapTargets.add(i6, childViewHolder);
|
|
this.mDistances.add(i6, Integer.valueOf(i5));
|
|
}
|
|
}
|
|
i4++;
|
|
viewHolder2 = viewHolder;
|
|
}
|
|
return this.mSwapTargets;
|
|
}
|
|
|
|
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 (Math.abs(i2 - viewHolder.itemView.getTop()) >= viewHolder.itemView.getHeight() * moveThreshold || Math.abs(i - viewHolder.itemView.getLeft()) >= viewHolder.itemView.getWidth() * moveThreshold) {
|
|
List<RecyclerView.ViewHolder> findSwapTargets = findSwapTargets(viewHolder);
|
|
if (findSwapTargets.size() == 0) {
|
|
return;
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.OnChildAttachStateChangeListener
|
|
public void onChildViewDetachedFromWindow(View view) {
|
|
removeChildDrawingOrderCallbackIfNecessary(view);
|
|
RecyclerView.ViewHolder childViewHolder = this.mRecyclerView.getChildViewHolder(view);
|
|
if (childViewHolder == null) {
|
|
return;
|
|
}
|
|
RecyclerView.ViewHolder viewHolder = this.mSelected;
|
|
if (viewHolder != null && childViewHolder == viewHolder) {
|
|
select(null, 0);
|
|
return;
|
|
}
|
|
endRecoverAnimation(childViewHolder, false);
|
|
if (this.mPendingCleanup.remove(childViewHolder.itemView)) {
|
|
this.mCallback.clearView(this.mRecyclerView, childViewHolder);
|
|
}
|
|
}
|
|
|
|
void endRecoverAnimation(RecyclerView.ViewHolder viewHolder, boolean z) {
|
|
for (int size = this.mRecoverAnimations.size() - 1; size >= 0; size--) {
|
|
RecoverAnimation recoverAnimation = this.mRecoverAnimations.get(size);
|
|
if (recoverAnimation.mViewHolder == viewHolder) {
|
|
recoverAnimation.mOverridden |= z;
|
|
if (!recoverAnimation.mEnded) {
|
|
recoverAnimation.cancel();
|
|
}
|
|
this.mRecoverAnimations.remove(size);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.ItemDecoration
|
|
public void getItemOffsets(Rect rect, View view, RecyclerView recyclerView, RecyclerView.State state) {
|
|
rect.setEmpty();
|
|
}
|
|
|
|
void obtainVelocityTracker() {
|
|
VelocityTracker velocityTracker = this.mVelocityTracker;
|
|
if (velocityTracker != null) {
|
|
velocityTracker.recycle();
|
|
}
|
|
this.mVelocityTracker = VelocityTracker.obtain();
|
|
}
|
|
|
|
private void releaseVelocityTracker() {
|
|
VelocityTracker velocityTracker = this.mVelocityTracker;
|
|
if (velocityTracker != null) {
|
|
velocityTracker.recycle();
|
|
this.mVelocityTracker = null;
|
|
}
|
|
}
|
|
|
|
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 x = motionEvent.getX(findPointerIndex) - this.mInitialTouchX;
|
|
float y = motionEvent.getY(findPointerIndex) - this.mInitialTouchY;
|
|
float abs = Math.abs(x);
|
|
float abs2 = Math.abs(y);
|
|
int i2 = this.mSlop;
|
|
if (abs < i2 && abs2 < 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;
|
|
}
|
|
|
|
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) {
|
|
return;
|
|
}
|
|
float x = motionEvent.getX(i2);
|
|
float y = motionEvent.getY(i2);
|
|
float f = x - this.mInitialTouchX;
|
|
float f2 = y - this.mInitialTouchY;
|
|
float abs = Math.abs(f);
|
|
float abs2 = Math.abs(f2);
|
|
int i3 = this.mSlop;
|
|
if (abs >= i3 || abs2 >= 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;
|
|
}
|
|
if (f2 > 0.0f && (absoluteMovementFlags & 2) == 0) {
|
|
return;
|
|
}
|
|
}
|
|
this.mDy = 0.0f;
|
|
this.mDx = 0.0f;
|
|
this.mActivePointerId = motionEvent.getPointerId(0);
|
|
select(findSwipedView, 1);
|
|
}
|
|
}
|
|
|
|
View findChildView(MotionEvent motionEvent) {
|
|
float x = motionEvent.getX();
|
|
float y = motionEvent.getY();
|
|
RecyclerView.ViewHolder viewHolder = this.mSelected;
|
|
if (viewHolder != null) {
|
|
View view = viewHolder.itemView;
|
|
if (hitTest(view, x, y, 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, x, y, recoverAnimation.mX, recoverAnimation.mY)) {
|
|
return view2;
|
|
}
|
|
}
|
|
return this.mRecyclerView.findChildViewUnder(x, y);
|
|
}
|
|
|
|
public void startDrag(RecyclerView.ViewHolder viewHolder) {
|
|
if (!this.mCallback.hasDragFlag(this.mRecyclerView, viewHolder)) {
|
|
Log.e(TAG, "Start drag has been called but dragging is not enabled");
|
|
return;
|
|
}
|
|
if (viewHolder.itemView.getParent() != this.mRecyclerView) {
|
|
Log.e(TAG, "Start drag has been called with a view holder which is not a child of the RecyclerView which is controlled by this ItemTouchHelper.");
|
|
return;
|
|
}
|
|
obtainVelocityTracker();
|
|
this.mDy = 0.0f;
|
|
this.mDx = 0.0f;
|
|
select(viewHolder, 2);
|
|
}
|
|
|
|
public void startSwipe(RecyclerView.ViewHolder viewHolder) {
|
|
if (!this.mCallback.hasSwipeFlag(this.mRecyclerView, viewHolder)) {
|
|
Log.e(TAG, "Start swipe has been called but swiping is not enabled");
|
|
return;
|
|
}
|
|
if (viewHolder.itemView.getParent() != this.mRecyclerView) {
|
|
Log.e(TAG, "Start swipe has been called with a view holder which is not a child of the RecyclerView controlled by this ItemTouchHelper.");
|
|
return;
|
|
}
|
|
obtainVelocityTracker();
|
|
this.mDy = 0.0f;
|
|
this.mDx = 0.0f;
|
|
select(viewHolder, 1);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
void updateDxDy(MotionEvent motionEvent, int i, int i2) {
|
|
float x = motionEvent.getX(i2);
|
|
float y = motionEvent.getY(i2);
|
|
float f = x - this.mInitialTouchX;
|
|
this.mDx = f;
|
|
this.mDy = y - 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);
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
private int checkHorizontalSwipe(RecyclerView.ViewHolder viewHolder, int i) {
|
|
if ((i & 12) == 0) {
|
|
return 0;
|
|
}
|
|
int i2 = 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);
|
|
int i3 = xVelocity <= 0.0f ? 4 : 8;
|
|
float abs = Math.abs(xVelocity);
|
|
if ((i3 & i) != 0 && i2 == i3 && abs >= this.mCallback.getSwipeEscapeVelocity(this.mSwipeEscapeVelocity) && abs > Math.abs(yVelocity)) {
|
|
return i3;
|
|
}
|
|
}
|
|
float width = this.mRecyclerView.getWidth() * this.mCallback.getSwipeThreshold(viewHolder);
|
|
if ((i & i2) == 0 || Math.abs(this.mDx) <= width) {
|
|
return 0;
|
|
}
|
|
return i2;
|
|
}
|
|
|
|
private int checkVerticalSwipe(RecyclerView.ViewHolder viewHolder, int i) {
|
|
if ((i & 3) == 0) {
|
|
return 0;
|
|
}
|
|
int i2 = 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);
|
|
int i3 = yVelocity <= 0.0f ? 1 : 2;
|
|
float abs = Math.abs(yVelocity);
|
|
if ((i3 & i) != 0 && i3 == i2 && abs >= this.mCallback.getSwipeEscapeVelocity(this.mSwipeEscapeVelocity) && abs > Math.abs(xVelocity)) {
|
|
return i3;
|
|
}
|
|
}
|
|
float height = this.mRecyclerView.getHeight() * this.mCallback.getSwipeThreshold(viewHolder);
|
|
if ((i & i2) == 0 || Math.abs(this.mDy) <= height) {
|
|
return 0;
|
|
}
|
|
return i2;
|
|
}
|
|
|
|
/* renamed from: androidx.recyclerview.widget.ItemTouchHelper$5, reason: invalid class name */
|
|
class AnonymousClass5 implements RecyclerView.ChildDrawingOrderCallback {
|
|
AnonymousClass5() {
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.ChildDrawingOrderCallback
|
|
public int onGetChildDrawingOrder(int i, int i2) {
|
|
if (ItemTouchHelper.this.mOverdrawChild == null) {
|
|
return i2;
|
|
}
|
|
int i3 = ItemTouchHelper.this.mOverdrawChildPosition;
|
|
if (i3 == -1) {
|
|
i3 = ItemTouchHelper.this.mRecyclerView.indexOfChild(ItemTouchHelper.this.mOverdrawChild);
|
|
ItemTouchHelper.this.mOverdrawChildPosition = i3;
|
|
}
|
|
return i2 == i + (-1) ? i3 : i2 < i3 ? i2 : i2 + 1;
|
|
}
|
|
}
|
|
|
|
void removeChildDrawingOrderCallbackIfNecessary(View view) {
|
|
if (view == this.mOverdrawChild) {
|
|
this.mOverdrawChild = null;
|
|
if (this.mChildDrawingOrderCallback != null) {
|
|
this.mRecyclerView.setChildDrawingOrderCallback(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
static final int RELATIVE_DIR_FLAGS = 3158064;
|
|
private static final Interpolator sDragScrollInterpolator = new Interpolator() { // from class: androidx.recyclerview.widget.ItemTouchHelper.Callback.1
|
|
@Override // android.animation.TimeInterpolator
|
|
public float getInterpolation(float f) {
|
|
return f * f * f * f * f;
|
|
}
|
|
};
|
|
private static final Interpolator sDragViewScrollCapInterpolator = new Interpolator() { // from class: androidx.recyclerview.widget.ItemTouchHelper.Callback.2
|
|
@Override // android.animation.TimeInterpolator
|
|
public float getInterpolation(float f) {
|
|
float f2 = f - 1.0f;
|
|
return (f2 * f2 * f2 * f2 * f2) + 1.0f;
|
|
}
|
|
};
|
|
private int mCachedMaxScrollSpeed = -1;
|
|
|
|
public static int convertToRelativeDirection(int i, int i2) {
|
|
int i3;
|
|
int i4 = i & ABS_HORIZONTAL_DIR_FLAGS;
|
|
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 & ABS_HORIZONTAL_DIR_FLAGS) << 2;
|
|
}
|
|
return i5 | i3;
|
|
}
|
|
|
|
public static int makeFlag(int i, int i2) {
|
|
return i2 << (i * 8);
|
|
}
|
|
|
|
public boolean canDropOver(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder viewHolder2) {
|
|
return true;
|
|
}
|
|
|
|
public int convertToAbsoluteDirection(int i, int i2) {
|
|
int i3;
|
|
int i4 = i & RELATIVE_DIR_FLAGS;
|
|
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 & RELATIVE_DIR_FLAGS) >> 2;
|
|
}
|
|
return i5 | i3;
|
|
}
|
|
|
|
public int getBoundingBoxMargin() {
|
|
return 0;
|
|
}
|
|
|
|
public float getMoveThreshold(RecyclerView.ViewHolder viewHolder) {
|
|
return 0.5f;
|
|
}
|
|
|
|
public abstract int getMovementFlags(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder);
|
|
|
|
public float getSwipeEscapeVelocity(float f) {
|
|
return f;
|
|
}
|
|
|
|
public float getSwipeThreshold(RecyclerView.ViewHolder viewHolder) {
|
|
return 0.5f;
|
|
}
|
|
|
|
public float getSwipeVelocityThreshold(float f) {
|
|
return f;
|
|
}
|
|
|
|
public boolean isItemViewSwipeEnabled() {
|
|
return true;
|
|
}
|
|
|
|
public boolean isLongPressDragEnabled() {
|
|
return true;
|
|
}
|
|
|
|
public abstract boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder viewHolder2);
|
|
|
|
public abstract void onSwiped(RecyclerView.ViewHolder viewHolder, int i);
|
|
|
|
public static ItemTouchUIUtil getDefaultUIUtil() {
|
|
return ItemTouchUIUtilImpl.INSTANCE;
|
|
}
|
|
|
|
public static int makeMovementFlags(int i, int i2) {
|
|
return makeFlag(2, i) | makeFlag(1, i2) | makeFlag(0, i2 | i);
|
|
}
|
|
|
|
final int getAbsoluteMovementFlags(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
return convertToAbsoluteDirection(getMovementFlags(recyclerView, viewHolder), ViewCompat.getLayoutDirection(recyclerView));
|
|
}
|
|
|
|
boolean hasDragFlag(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
return (getAbsoluteMovementFlags(recyclerView, viewHolder) & ItemTouchHelper.ACTION_MODE_DRAG_MASK) != 0;
|
|
}
|
|
|
|
boolean hasSwipeFlag(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
return (getAbsoluteMovementFlags(recyclerView, viewHolder) & 65280) != 0;
|
|
}
|
|
|
|
public RecyclerView.ViewHolder chooseDropTarget(RecyclerView.ViewHolder viewHolder, 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 = i + viewHolder.itemView.getWidth();
|
|
int height = i2 + viewHolder.itemView.getHeight();
|
|
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 onSelectedChanged(RecyclerView.ViewHolder viewHolder, int i) {
|
|
if (viewHolder != null) {
|
|
ItemTouchUIUtilImpl.INSTANCE.onSelected(viewHolder.itemView);
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public void onMoved(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, int i, 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
void onDrawOver(Canvas canvas, RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, List<RecoverAnimation> list, int i, float f, float f2) {
|
|
int size = list.size();
|
|
boolean z = 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);
|
|
if (recoverAnimation2.mEnded && !recoverAnimation2.mIsPendingCleanup) {
|
|
list.remove(i3);
|
|
} else if (!recoverAnimation2.mEnded) {
|
|
z = true;
|
|
}
|
|
}
|
|
if (z) {
|
|
recyclerView.invalidate();
|
|
}
|
|
}
|
|
|
|
public void clearView(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
ItemTouchUIUtilImpl.INSTANCE.clearView(viewHolder.itemView);
|
|
}
|
|
|
|
public void onChildDraw(Canvas canvas, RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, float f, float f2, int i, boolean z) {
|
|
ItemTouchUIUtilImpl.INSTANCE.onDraw(canvas, recyclerView, viewHolder.itemView, f, f2, i, z);
|
|
}
|
|
|
|
public void onChildDrawOver(Canvas canvas, RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, float f, float f2, int i, boolean z) {
|
|
ItemTouchUIUtilImpl.INSTANCE.onDrawOver(canvas, recyclerView, viewHolder.itemView, f, f2, i, z);
|
|
}
|
|
|
|
public long getAnimationDuration(RecyclerView recyclerView, int i, float f, float f2) {
|
|
RecyclerView.ItemAnimator itemAnimator = recyclerView.getItemAnimator();
|
|
if (itemAnimator == null) {
|
|
return i == 8 ? 200L : 250L;
|
|
}
|
|
if (i == 8) {
|
|
return itemAnimator.getMoveDuration();
|
|
}
|
|
return itemAnimator.getRemoveDuration();
|
|
}
|
|
|
|
public int interpolateOutOfBoundsScroll(RecyclerView recyclerView, int i, int i2, int i3, long j) {
|
|
int signum = (int) (((int) (((int) Math.signum(i2)) * getMaxDragScroll(recyclerView) * sDragViewScrollCapInterpolator.getInterpolation(Math.min(1.0f, (Math.abs(i2) * 1.0f) / i)))) * sDragScrollInterpolator.getInterpolation(j <= DRAG_SCROLL_ACCELERATION_LIMIT_TIME_MS ? j / 2000.0f : 1.0f));
|
|
return signum == 0 ? i2 > 0 ? 1 : -1 : signum;
|
|
}
|
|
}
|
|
|
|
public static abstract class SimpleCallback extends Callback {
|
|
private int mDefaultDragDirs;
|
|
private int mDefaultSwipeDirs;
|
|
|
|
public int getDragDirs(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
return this.mDefaultDragDirs;
|
|
}
|
|
|
|
public int getSwipeDirs(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
return this.mDefaultSwipeDirs;
|
|
}
|
|
|
|
public void setDefaultDragDirs(int i) {
|
|
this.mDefaultDragDirs = i;
|
|
}
|
|
|
|
public void setDefaultSwipeDirs(int i) {
|
|
this.mDefaultSwipeDirs = i;
|
|
}
|
|
|
|
public SimpleCallback(int i, int i2) {
|
|
this.mDefaultSwipeDirs = i2;
|
|
this.mDefaultDragDirs = i;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.ItemTouchHelper.Callback
|
|
public int getMovementFlags(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
|
|
return makeMovementFlags(getDragDirs(recyclerView, viewHolder), getSwipeDirs(recyclerView, viewHolder));
|
|
}
|
|
}
|
|
|
|
private class ItemTouchHelperGestureListener extends GestureDetector.SimpleOnGestureListener {
|
|
private boolean mShouldReactToLongPress = true;
|
|
|
|
void doNotReactToLongPress() {
|
|
this.mShouldReactToLongPress = false;
|
|
}
|
|
|
|
@Override // android.view.GestureDetector.SimpleOnGestureListener, android.view.GestureDetector.OnGestureListener
|
|
public boolean onDown(MotionEvent motionEvent) {
|
|
return true;
|
|
}
|
|
|
|
ItemTouchHelperGestureListener() {
|
|
}
|
|
|
|
@Override // android.view.GestureDetector.SimpleOnGestureListener, android.view.GestureDetector.OnGestureListener
|
|
public void onLongPress(MotionEvent motionEvent) {
|
|
View findChildView;
|
|
RecyclerView.ViewHolder childViewHolder;
|
|
if (this.mShouldReactToLongPress && (findChildView = ItemTouchHelper.this.findChildView(motionEvent)) != null && (childViewHolder = ItemTouchHelper.this.mRecyclerView.getChildViewHolder(findChildView)) != null && ItemTouchHelper.this.mCallback.hasDragFlag(ItemTouchHelper.this.mRecyclerView, childViewHolder) && motionEvent.getPointerId(0) == ItemTouchHelper.this.mActivePointerId) {
|
|
int findPointerIndex = motionEvent.findPointerIndex(ItemTouchHelper.this.mActivePointerId);
|
|
float x = motionEvent.getX(findPointerIndex);
|
|
float y = motionEvent.getY(findPointerIndex);
|
|
ItemTouchHelper.this.mInitialTouchX = x;
|
|
ItemTouchHelper.this.mInitialTouchY = y;
|
|
ItemTouchHelper itemTouchHelper = ItemTouchHelper.this;
|
|
itemTouchHelper.mDy = 0.0f;
|
|
itemTouchHelper.mDx = 0.0f;
|
|
if (ItemTouchHelper.this.mCallback.isLongPressDragEnabled()) {
|
|
ItemTouchHelper.this.select(childViewHolder, 2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static class RecoverAnimation implements Animator.AnimatorListener {
|
|
final int mActionState;
|
|
final int mAnimationType;
|
|
private float mFraction;
|
|
boolean mIsPendingCleanup;
|
|
final float mStartDx;
|
|
final float mStartDy;
|
|
final float mTargetX;
|
|
final float mTargetY;
|
|
private final ValueAnimator mValueAnimator;
|
|
final RecyclerView.ViewHolder mViewHolder;
|
|
float mX;
|
|
float mY;
|
|
boolean mOverridden = false;
|
|
boolean mEnded = false;
|
|
|
|
@Override // android.animation.Animator.AnimatorListener
|
|
public void onAnimationRepeat(Animator animator) {
|
|
}
|
|
|
|
@Override // android.animation.Animator.AnimatorListener
|
|
public void onAnimationStart(Animator animator) {
|
|
}
|
|
|
|
public void setFraction(float f) {
|
|
this.mFraction = f;
|
|
}
|
|
|
|
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 ValueAnimator.AnimatorUpdateListener() { // from class: androidx.recyclerview.widget.ItemTouchHelper.RecoverAnimation.1
|
|
@Override // android.animation.ValueAnimator.AnimatorUpdateListener
|
|
public void onAnimationUpdate(ValueAnimator valueAnimator) {
|
|
RecoverAnimation.this.setFraction(valueAnimator.getAnimatedFraction());
|
|
}
|
|
});
|
|
ofFloat.setTarget(viewHolder.itemView);
|
|
ofFloat.addListener(this);
|
|
setFraction(0.0f);
|
|
}
|
|
|
|
public void setDuration(long j) {
|
|
this.mValueAnimator.setDuration(j);
|
|
}
|
|
|
|
public void start() {
|
|
this.mViewHolder.setIsRecyclable(false);
|
|
this.mValueAnimator.start();
|
|
}
|
|
|
|
public void cancel() {
|
|
this.mValueAnimator.cancel();
|
|
}
|
|
|
|
public void update() {
|
|
float f = this.mStartDx;
|
|
float f2 = this.mTargetX;
|
|
if (f == f2) {
|
|
this.mX = this.mViewHolder.itemView.getTranslationX();
|
|
} else {
|
|
this.mX = f + (this.mFraction * (f2 - f));
|
|
}
|
|
float f3 = this.mStartDy;
|
|
float f4 = this.mTargetY;
|
|
if (f3 == f4) {
|
|
this.mY = this.mViewHolder.itemView.getTranslationY();
|
|
} else {
|
|
this.mY = f3 + (this.mFraction * (f4 - f3));
|
|
}
|
|
}
|
|
|
|
@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 onAnimationCancel(Animator animator) {
|
|
setFraction(1.0f);
|
|
}
|
|
}
|
|
}
|