IBigerBiger的成长之路

ItemTouchHelper使用与源码简析

发表于 |

ItemTouchHelper是什么？

看看官方解释

1
2
3
/**
  *  This is a utility class to add swipe to dismiss and drag & drop support to RecyclerView.
  */

通过这段解释其实可以清楚这个ItemTouchHelper到底是干什么的，它是一个可以给RecyclerView提供添加拖动排序与滑动删除等等操作的工具类。

大家应该清楚拖动排序与滑动删除其实如果代码去写会比较麻烦，所以ItemTouchHelper的出现也确实解决了这部分代码比较复杂的问题，这偏文章就简单的介绍下ItemTouchHelper的使用方法

简单实现


1.首先实现一个RecyclerView就好了

直接上代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class RecyclerAdapter extends RecyclerView.Adapter<RecyclerAdapter.ItemViewHolder>{
    private static final String[] STRINGS = new String[]{
            "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten"
    };
    private final List<String> mItems = new ArrayList<>();
    public RecyclerAdapter() {
        mItems.addAll(Arrays.asList(STRINGS));
    }
    @Override
    public ItemViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_main, parent, false);
        ItemViewHolder itemViewHolder = new ItemViewHolder(view);
        return itemViewHolder;
    }
    @Override
    public void onBindViewHolder(ItemViewHolder holder, int position) {
        holder.textView.setText(mItems.get(position));
    }
    @Override
    public int getItemCount() {
        return mItems.size();
    }
    public static class ItemViewHolder extends RecyclerView.ViewHolder{
        public final TextView textView;
        public ItemViewHolder(View itemView) {
            super(itemView);
            textView = (TextView) itemView;
        }
    }
}
1
2
mRecyclerView.setAdapter(new RecyclerAdapter());
mRecyclerView.setLayoutManager(new LinearLayoutManager(MainActivity.this));

创建好了，如下


图1 RecycleView

2.创建一个类继承ItemTouchHelper.Callback，并且与RecycleView建立链接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ItemTouchHelperCallback extends ItemTouchHelper.Callback{
    @Override
    public int getMovementFlags(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
        return 0;
    }
    @Override
    public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder target) {
        return false;
    }
    @Override
    public void onSwiped(RecyclerView.ViewHolder viewHolder, int direction) {
    }
}

创建了一个类并继承了ItemTouchHelper.Callback与他的一些方法，但是些方法根据我们的需求需要重写

需要重写getMovementFlags()方法来指定可以支持的拖放和滑动的方向使用helperItemTouchHelper.makeMovementFlags(int, int)来构造返回的flag。这里我们启用了上下左右两种方向。注：上下为拖动（drag），左右为滑动（swipe）。

如下

1
2
3
4
5
public int getMovementFlags(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
    final int dragFlags = ItemTouchHelper.UP | ItemTouchHelper.DOWN;
    final int swipeFlags = ItemTouchHelper.START | ItemTouchHelper.END;
    return makeMovementFlags(dragFlags, swipeFlags);
}

接下来建立与RecycleView的链接

1
2
ItemTouchHelper mItemTouchHelper = new ItemTouchHelper(new ItemTouchHelperCallback());
mItemTouchHelper.attachToRecyclerView(mRecyclerView);

好的接下来就是见证奇迹的时刻了


图2 RecycleView

但是显然不是我们想要的结果，但是还缺少什么呢？Adapter数据并没有发生实质性的变化，所以接下来工作就是去让Adapter内数据产生变化

3.通过接口改变Adapter数据

首先创建接口

1
2
3
4
5
6
7
public interface IItemHelper {
    void onItemMove(int fromPosition, int toPosition);
    void onItemDismiss(int position);
}

然后在callback中调用

1
2
3
4
5
6
7
8
9
10
@Override
public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder target) {
    mRecyclerAdapter.onItemMove(viewHolder.getAdapterPosition(), target.getAdapterPosition());
    return false;
}
@Override
public void onSwiped(RecyclerView.ViewHolder viewHolder, int direction) {
    mRecyclerAdapter.onItemDismiss(viewHolder.getAdapterPosition());
}

最后在Adapter中实现这个接口

1
2
3
4
5
6
7
8
9
10
11
12
@Override
public void onItemMove(int fromPosition, int toPosition) {
    String prev = mItems.remove(fromPosition);
    mItems.add(toPosition > fromPosition ? toPosition - 1 : toPosition, prev);
    notifyItemMoved(fromPosition, toPosition);
}
@Override
public void onItemDismiss(int position) {
    mItems.remove(position);
    notifyItemRemoved(position);
}

接下来就是真正的见证奇迹的时刻了


图3 RecycleView

拖动不知道为什么在模拟器上太难操作了，OMG

源码简析

ItemTouchHelper.CallBack分析


分析ItemTouchHelper之前，我们先看下CallBack的定义了那些方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
//声明不同状态下可以移动的方向（idle, swiping, dragging）
@Override
public int getMovementFlags(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
    final int dragFlags = ItemTouchHelper.UP | ItemTouchHelper.DOWN;
    final int swipeFlags = ItemTouchHelper.START | ItemTouchHelper.END;
    return makeMovementFlags(dragFlags, swipeFlags);
}
//拖动的项目从旧位置移动到新位置时调用
@Override
public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder target) {
    return false;
}
//滑动到消失后的调用
@Override
public void onSwiped(RecyclerView.ViewHolder viewHolder, int direction) {
}
//是否可以把拖动的ViewHolder拖动到目标ViewHolder之上
@Override
public boolean canDropOver(RecyclerView recyclerView, RecyclerView.ViewHolder current, RecyclerView.ViewHolder target) {
    return true;
}
//获取拖动
@Override
public RecyclerView.ViewHolder chooseDropTarget(RecyclerView.ViewHolder selected, List<RecyclerView.ViewHolder> dropTargets, int curX, int curY) {
    return dropTargets.get(0);
}
//调用时与元素的用户交互已经结束，也就是它也完成了它的动画时候
@Override
public void clearView(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
    super.clearView(recyclerView, viewHolder);
}
@Override
public int convertToAbsoluteDirection(int flags, int layoutDirection) {
    return super.convertToAbsoluteDirection(flags, layoutDirection);
}
//设置手指离开后ViewHolder的动画时间
@Override
public long getAnimationDuration(RecyclerView recyclerView, int animationType, float animateDx, float animateDy) {
    return super.getAnimationDuration(recyclerView, animationType, animateDx, animateDy);
}
@Override
public int getBoundingBoxMargin() {
    return super.getBoundingBoxMargin();
}
//返回值作为用户视为拖动的距离
@Override
public float getMoveThreshold(RecyclerView.ViewHolder viewHolder) {
    return super.getMoveThreshold(viewHolder);
}
//返回值滑动消失的距离，滑动小于这个值不消失，大于消失
@Override
public float getSwipeEscapeVelocity(float defaultValue) {
    return super.getSwipeEscapeVelocity(defaultValue);
}
//返回值滑动消失的距离, 这里是相对于RecycleView的宽度，0.5f表示为RecycleView的宽度的一半，取值为0~1f之间
@Override
public float getSwipeThreshold(RecyclerView.ViewHolder viewHolder) {
    return super.getSwipeThreshold(viewHolder);
}
//返回值作为滑动的流程程度，越小越难滑动，越大越好滑动
@Override
public float getSwipeVelocityThreshold(float defaultValue) {
    return 1f;
}
//当用户拖动一个视图出界的ItemTouchHelper调用
@Override
public int interpolateOutOfBoundsScroll(RecyclerView recyclerView, int viewSize, int viewSizeOutOfBounds, int totalSize, long msSinceStartScroll) {
    return super.interpolateOutOfBoundsScroll(recyclerView, viewSize, viewSizeOutOfBounds, totalSize, msSinceStartScroll);
}
//返回值决定是否有滑动操作
@Override
public boolean isItemViewSwipeEnabled() {
    return super.isItemViewSwipeEnabled();
}
//返回值决定是否有拖动操作
@Override
public boolean isLongPressDragEnabled() {
    return super.isLongPressDragEnabled();
}
//自定义拖动与滑动交互
@Override
public void onChildDraw(Canvas c, RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, float dX, float dY, int actionState, boolean isCurrentlyActive) {
    super.onChildDraw(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive);
}
//自定义拖动与滑动交互
@Override
public void onChildDrawOver(Canvas c, RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, float dX, float dY, int actionState, boolean isCurrentlyActive) {
    super.onChildDrawOver(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive);
}
//当onMove return ture的时候调用
@Override
public void onMoved(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, int fromPos, RecyclerView.ViewHolder target, int toPos, int x, int y) {
    super.onMoved(recyclerView, viewHolder, fromPos, target, toPos, x, y);
}
//当拖动或者滑动的ViewHolder改变时调用
@Override
public void onSelectedChanged(RecyclerView.ViewHolder viewHolder, int actionState) {
    super.onSelectedChanged(viewHolder, actionState);
}

结合这些分析注释就明白了上面一篇文章里面CallBack为什么写那些方法了，还有部分的方法还是没有理解到底是干嘛的所有就没有注释了。

ItemTouchHelper相关分析


上一篇文章中把ItemTouchHelper与RecycleView以及CallBack建立连接的方法如下

1
2
ItemTouchHelper mItemTouchHelper = new ItemTouchHelper(new ItemTouchHelperCallback());
mItemTouchHelper.attachToRecyclerView(mRecyclerView);

那么从这个将ItemTouchHelper与RecycleView建立的方法进行分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void attachToRecyclerView(@Nullable RecyclerView recyclerView) {
    if (mRecyclerView == recyclerView) {
        return; // nothing to do
    }
    if (mRecyclerView != null) {
        destroyCallbacks();
    }
    mRecyclerView = recyclerView;
    if (mRecyclerView != null) {
        final Resources resources = recyclerView.getResources();
        mSwipeEscapeVelocity = resources
                .getDimension(R.dimen.item_touch_helper_swipe_escape_velocity);
        mMaxSwipeVelocity = resources
                .getDimension(R.dimen.item_touch_helper_swipe_escape_max_velocity);
        setupCallbacks();
    }
}

这部分的代码其实没有做太多的事情，无非是获取一些默认值，setupCallbacks()与destroyCallbacks()两个方法，这两个方法从名称看就是相对立的，所以分析一个就好了

destroyCallbacks()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private void destroyCallbacks() {
    mRecyclerView.removeItemDecoration(this);
    mRecyclerView.removeOnItemTouchListener(mOnItemTouchListener);
    mRecyclerView.removeOnChildAttachStateChangeListener(this);
    // clean all attached
    final int recoverAnimSize = mRecoverAnimations.size();
    for (int i = recoverAnimSize - 1; i >= 0; i--) {
        final RecoverAnimation recoverAnimation = mRecoverAnimations.get(0);
        mCallback.clearView(mRecyclerView, recoverAnimation.mViewHolder);
    }
    mRecoverAnimations.clear();
    mOverdrawChild = null;
    mOverdrawChildPosition = -1;
    releaseVelocityTracker();
}

setupCallbacks()

1
2
3
4
5
6
7
8
private void setupCallbacks() {
    ViewConfiguration vc = ViewConfiguration.get(mRecyclerView.getContext());
    mSlop = vc.getScaledTouchSlop();
    mRecyclerView.addItemDecoration(this);
    mRecyclerView.addOnItemTouchListener(mOnItemTouchListener);
    mRecyclerView.addOnChildAttachStateChangeListener(this);
    initGestureDetector();
}

这里的步骤有点多了

分布来说明

1.addItemDecoration(this)

这个方法其实是调用了ItemDecoration的接口.从ItemTouchHelper方法声明部分也可以看到

1
2
public class ItemTouchHelper extends RecyclerView.ItemDecoration
        implements RecyclerView.OnChildAttachStateChangeListener {}

在ItemTouchHelper中重写了ItemDecoration接口的两个方法如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Override
public void onDrawOver(Canvas c, RecyclerView parent, RecyclerView.State state) {
    float dx = 0, dy = 0;
    if (mSelected != null) {
        getSelectedDxDy(mTmpPosition);
        dx = mTmpPosition[0];
        dy = mTmpPosition[1];
    }
    mCallback.onDrawOver(c, parent, mSelected,
            mRecoverAnimations, mActionState, dx, dy);
}
@Override
public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
    // we don't know if RV changed something so we should invalidate this index.
    mOverdrawChildPosition = -1;
    float dx = 0, dy = 0;
    if (mSelected != null) {
        getSelectedDxDy(mTmpPosition);
        dx = mTmpPosition[0];
        dy = mTmpPosition[1];
    }
    mCallback.onDraw(c, parent, mSelected,
            mRecoverAnimations, mActionState, dx, dy);
}

从方法可以看到这里其实没有做什么特别的工作，只是回调了Callback的两个回调方法onDrawOver()与onDraw()而这两个方法是Callback的private方法如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
private void onDraw(Canvas c, RecyclerView parent, ViewHolder selected,
        List<ItemTouchHelper.RecoverAnimation> recoverAnimationList,
        int actionState, float dX, float dY) {
    final int recoverAnimSize = recoverAnimationList.size();
    for (int i = 0; i < recoverAnimSize; i++) {
        final ItemTouchHelper.RecoverAnimation anim = recoverAnimationList.get(i);
        anim.update();
        final int count = c.save();
        onChildDraw(c, parent, anim.mViewHolder, anim.mX, anim.mY, anim.mActionState,
                false);
        c.restoreToCount(count);
    }
    if (selected != null) {
        final int count = c.save();
        onChildDraw(c, parent, selected, dX, dY, actionState, true);
        c.restoreToCount(count);
    }
}
private void onDrawOver(Canvas c, RecyclerView parent, ViewHolder selected,
        List<ItemTouchHelper.RecoverAnimation> recoverAnimationList,
        int actionState, float dX, float dY) {
    final int recoverAnimSize = recoverAnimationList.size();
    for (int i = 0; i < recoverAnimSize; i++) {
        final ItemTouchHelper.RecoverAnimation anim = recoverAnimationList.get(i);
        final int count = c.save();
        onChildDrawOver(c, parent, anim.mViewHolder, anim.mX, anim.mY, anim.mActionState,
                false);
        c.restoreToCount(count);
    }
    if (selected != null) {
        final int count = c.save();
        onChildDrawOver(c, parent, selected, dX, dY, actionState, true);
        c.restoreToCount(count);
    }
    boolean hasRunningAnimation = false;
    for (int i = recoverAnimSize - 1; i >= 0; i--) {
        final RecoverAnimation anim = recoverAnimationList.get(i);
        if (anim.mEnded && !anim.mIsPendingCleanup) {
            recoverAnimationList.remove(i);
        } else if (!anim.mEnded) {
            hasRunningAnimation = true;
        }
    }
    if (hasRunningAnimation) {
        parent.invalidate();
    }
}

这里牵扯的东西比较多，暂时不分析，我们可以看到有两个方法分别为onChildDrawOver()与onChildDraw()

调用了这两个方法，接下来看下这两个方法里面有什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
public void onChildDraw(Canvas c, RecyclerView recyclerView,
        ViewHolder viewHolder,
        float dX, float dY, int actionState, boolean isCurrentlyActive) {
    sUICallback.onDraw(c, recyclerView, viewHolder.itemView, dX, dY, actionState,
            isCurrentlyActive);
}
public void onChildDrawOver(Canvas c, RecyclerView recyclerView,
        ViewHolder viewHolder,
        float dX, float dY, int actionState, boolean isCurrentlyActive) {
    sUICallback.onDrawOver(c, recyclerView, viewHolder.itemView, dX, dY, actionState,
            isCurrentlyActive);
}

这里面其实是sUICallback的回调方法

这里的sUICallback是一个接口，根据不同的版本执行不同的onDraw与onDrawOver方法

1
2
3
4
5
6
7
8
9
static {
    if (Build.VERSION.SDK_INT >= 21) {
        sUICallback = new ItemTouchUIUtilImpl.Lollipop();
    } else if (Build.VERSION.SDK_INT >= 11) {
        sUICallback = new ItemTouchUIUtilImpl.Honeycomb();
    } else {
        sUICallback = new ItemTouchUIUtilImpl.Gingerbread();
    }
}

所以在我们自定义的CallBack中可以取重写onChildDraw()与onChildDrawOver()方法来实现自定义的拖动与滑动交互

2.addOnChildAttachStateChangeListener(this)

这里调用了OnChildAttachStateChangeListener这个接口，这个接口里有两个方法，分别是在RecycleView添加一个View与删除一个View的时候回调

那看看我们在ItemTouchHelper中重写的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Override
public void onChildViewAttachedToWindow(View view) {
}
@Override
public void onChildViewDetachedFromWindow(View view) {
    removeChildDrawingOrderCallbackIfNecessary(view);
    final ViewHolder holder = mRecyclerView.getChildViewHolder(view);
    if (holder == null) {
        return;
    }
    if (mSelected != null && holder == mSelected) {
        select(null, ACTION_STATE_IDLE);
    } else {
        endRecoverAnimation(holder, false); // this may push it into pending cleanup list.
        if (mPendingCleanup.remove(holder.itemView)) {
            mCallback.clearView(mRecyclerView, holder);
        }
    }
}

因为ItemTouchHelper中只用考虑移除的情况，

这里面的方法暂时不介绍，可以看到回调了clearView()的方法，所以在元素的用户交互已经结束的时候，可以通过这个方法监听到

3.initGestureDetector()

这里主要是初始化GestureDetector

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
private class ItemTouchHelperGestureListener extends GestureDetector.SimpleOnGestureListener {
    @Override
    public boolean onDown(MotionEvent e) {
        return true;
    }
    @Override
    public void onLongPress(MotionEvent e) {
        View child = findChildView(e);
        if (child != null) {
            ViewHolder vh = mRecyclerView.getChildViewHolder(child);
            if (vh != null) {
                if (!mCallback.hasDragFlag(mRecyclerView, vh)) {
                    return;
                }
                int pointerId = MotionEventCompat.getPointerId(e, 0);
                // Long press is deferred.
                // Check w/ active pointer id to avoid selecting after motion
                // event is canceled.
                if (pointerId == mActivePointerId) {
                    final int index = MotionEventCompat
                            .findPointerIndex(e, mActivePointerId);
                    final float x = MotionEventCompat.getX(e, index);
                    final float y = MotionEventCompat.getY(e, index);
                    mInitialTouchX = x;
                    mInitialTouchY = y;
                    mDx = mDy = 0f;
                    if (DEBUG) {
                        Log.d(TAG,
                                "onlong press: x:" + mInitialTouchX + ",y:" + mInitialTouchY);
                    }
                    if (mCallback.isLongPressDragEnabled()) {
                        select(vh, ACTION_STATE_DRAG);
                    }
                }
            }
        }
    }
}

首先看下Callback调用了hasDragFlag这个方法，那我们看下这个方法

1
2
3
4
5
6
7
8
9
10
private boolean hasDragFlag(RecyclerView recyclerView, ViewHolder viewHolder) {
    final int flags = getAbsoluteMovementFlags(recyclerView, viewHolder);
    return (flags & ACTION_MODE_DRAG_MASK) != 0;
}
final int getAbsoluteMovementFlags(RecyclerView recyclerView,
        ViewHolder viewHolder) {
    final int flags = getMovementFlags(recyclerView, viewHolder);
    return convertToAbsoluteDirection(flags, ViewCompat.getLayoutDirection(recyclerView));
}

经过调用发现最后调用了getMovementFlags这个方法，所以我们重写方法如果是没有声明的在onLongPress中就直接return了，不会触发下面的方法了

再往下看，会调用Callback的isLongPressDragEnabled()方法，当return为true的时候会执行select()方法

4. addOnItemTouchListener

这里则是调用了RecycleView的addOnItemTouchListener方法，ItemTouchHelper重写了OnItemTouchListener接口的方法，OnItemTouchListener有三个方法，我们一个个来进行分析

(1).onInterceptTouchEvent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public boolean onInterceptTouchEvent(RecyclerView recyclerView, MotionEvent event) {
    //给前面注册的GestureDetector添加监听
    mGestureDetector.onTouchEvent(event);
    if (DEBUG) {
        Log.d(TAG, "intercept: x:" + event.getX() + ",y:" + event.getY() + ", " + event);
    }
    final int action = MotionEventCompat.getActionMasked(event);
    if (action == MotionEvent.ACTION_DOWN) {
        //获取这个事件对应的pointerId,ViewDragerHelper中也有说明
        mActivePointerId = MotionEventCompat.getPointerId(event, 0);
        mInitialTouchX = event.getX();
        mInitialTouchY = event.getY();
        //初始化跟踪触摸屏类VelocityTracker
        obtainVelocityTracker();
        if (mSelected == null) {
            //根据当前的MotionEvent查找RecoverAnimation对象
            final RecoverAnimation animation = findAnimation(event);
            //如果animation存在则更新animation
            if (animation != null) {
                mInitialTouchX -= animation.mX;
                mInitialTouchY -= animation.mY;
                //删除RecoverAnimation
                endRecoverAnimation(animation.mViewHolder, true);
                if (mPendingCleanup.remove(animation.mViewHolder.itemView)) {
                    mCallback.clearView(mRecyclerView, animation.mViewHolder);
                }
                //select方法
                select(animation.mViewHolder, animation.mActionState);
                //更新Dx与Dy
                updateDxDy(event, mSelectedFlags, 0);
            }
        }
    } else if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
        mActivePointerId = ACTIVE_POINTER_ID_NONE;
        //select方法
        select(null, ACTION_STATE_IDLE);
    } else if (mActivePointerId != ACTIVE_POINTER_ID_NONE) {
        // in a non scroll orientation, if distance change is above threshold, we
        // can select the item
        final int index = MotionEventCompat.findPointerIndex(event, mActivePointerId);
        if (DEBUG) {
            Log.d(TAG, "pointer index " + index);
        }
        //index >= 0 表示最少有一个触控点存在
        if (index >= 0) {
            checkSelectForSwipe(action, event, index);
        }
    }
    if (mVelocityTracker != null) {
        mVelocityTracker.addMovement(event);
    }
    return mSelected != null;
}

大部分注释都已经说明了，主要把他们调用的方法来进行说明

首先来看下RecoverAnimation这个类，这个类中有ValueAnimatorCompat主要是根据起始点及ActionState等做动画的。

接下来就贴出这个类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
private class RecoverAnimation implements AnimatorListenerCompat {
    final float mStartDx;
    final float mStartDy;
    final float mTargetX;
    final float mTargetY;
    final ViewHolder mViewHolder;
    final int mActionState;
    private final ValueAnimatorCompat mValueAnimator;
    private final int mAnimationType;
    public boolean mIsPendingCleanup;
    float mX;
    float mY;
    // if user starts touching a recovering view, we put it into interaction mode again,
    // instantly.
    boolean mOverridden = false;
    private boolean mEnded = false;
    private float mFraction;
    public RecoverAnimation(ViewHolder viewHolder, int animationType,
            int actionState, float startDx, float startDy, float targetX, float targetY) {
        mActionState = actionState;
        mAnimationType = animationType;
        mViewHolder = viewHolder;
        mStartDx = startDx;
        mStartDy = startDy;
        mTargetX = targetX;
        mTargetY = targetY;
        mValueAnimator = AnimatorCompatHelper.emptyValueAnimator();
        mValueAnimator.addUpdateListener(
                new AnimatorUpdateListenerCompat() {
                    @Override
                    public void onAnimationUpdate(ValueAnimatorCompat animation) {
                        setFraction(animation.getAnimatedFraction());
                    }
                });
        mValueAnimator.setTarget(viewHolder.itemView);
        mValueAnimator.addListener(this);
        setFraction(0f);
    }
    public void setDuration(long duration) {
        mValueAnimator.setDuration(duration);
    }
    public void start() {
        mViewHolder.setIsRecyclable(false);
        mValueAnimator.start();
    }
    public void cancel() {
        mValueAnimator.cancel();
    }
    public void setFraction(float fraction) {
        mFraction = fraction;
    }
    /**
     * We run updates on onDraw method but use the fraction from animator callback.
     * This way, we can sync translate x/y values w/ the animators to avoid one-off frames.
     */
    public void update() {
        if (mStartDx == mTargetX) {
            mX = ViewCompat.getTranslationX(mViewHolder.itemView);
        } else {
            mX = mStartDx + mFraction * (mTargetX - mStartDx);
        }
        if (mStartDy == mTargetY) {
            mY = ViewCompat.getTranslationY(mViewHolder.itemView);
        } else {
            mY = mStartDy + mFraction * (mTargetY - mStartDy);
        }
    }
    @Override
    public void onAnimationStart(ValueAnimatorCompat animation) {
    }
    @Override
    public void onAnimationEnd(ValueAnimatorCompat animation) {
        if (!mEnded) {
            mViewHolder.setIsRecyclable(true);
        }
        mEnded = true;
    }
    @Override
    public void onAnimationCancel(ValueAnimatorCompat animation) {
        setFraction(1f); //make sure we recover the view's state.
    }
    @Override
    public void onAnimationRepeat(ValueAnimatorCompat animation) {
    }
}

里面的成员变量大家看名称应该大部分就可以理解了，不做更多的说明了

那么来看看findAnimation()这个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//根据查找的View从mRecoverAnimations集合中查找相同View的RecoverAnimation
private RecoverAnimation findAnimation(MotionEvent event) {
    if (mRecoverAnimations.isEmpty()) {
        return null;
    }
    View target = findChildView(event);
    for (int i = mRecoverAnimations.size() - 1; i >= 0; i--) {
        final RecoverAnimation anim = mRecoverAnimations.get(i);
        if (anim.mViewHolder.itemView == target) {
            return anim;
        }
    }
    return null;
}
//根据event查找View
private View findChildView(MotionEvent event) {
    // first check elevated views, if none, then call RV
    final float x = event.getX();
    final float y = event.getY();
    //mSelected不为空则拿mSelected.itemView
    if (mSelected != null) {
        final View selectedView = mSelected.itemView;
        if (hitTest(selectedView, x, y, mSelectedStartX + mDx, mSelectedStartY + mDy)) {
            return selectedView;
        }
    }
    //从mRecoverAnimations这个RecoverAnimation类集合中查找是否存在View
    for (int i = mRecoverAnimations.size() - 1; i >= 0; i--) {
        final RecoverAnimation anim = mRecoverAnimations.get(i);
        final View view = anim.mViewHolder.itemView;
        if (hitTest(view, x, y, anim.mX, anim.mY)) {
            return view;
        }
    }
    //通过RecyclerView的findChildViewUnder方法查找View
    return mRecyclerView.findChildViewUnder(x, y);
}
//计算是否点击在当前View的区域内
private static boolean hitTest(View child, float x, float y, float left, float top) {
    return x >= left &&
            x <= left + child.getWidth() &&
            y >= top &&
            y <= top + child.getHeight();
}

往下看就可以看到endRecoverAnimation方法，这个方法主要就是从mRecoverAnimations集合中删除某个RecoverAnimation对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private int endRecoverAnimation(ViewHolder viewHolder, boolean override) {
    final int recoverAnimSize = mRecoverAnimations.size();
    for (int i = recoverAnimSize - 1; i >= 0; i--) {
        final RecoverAnimation anim = mRecoverAnimations.get(i);
        if (anim.mViewHolder == viewHolder) {
            anim.mOverridden |= override;
            if (!anim.mEnded) {
                anim.cancel();
            }
            mRecoverAnimations.remove(i);
            return anim.mAnimationType;
        }
    }
    return 0;
}

接下来看下select()方法，这个方法作用是开始拖动或者滑动指定的View

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
private void select(ViewHolder selected, int actionState) {
    //当ViewHolder一致且State状态一致时候直接返回，不做处理
    if (selected == mSelected && actionState == mActionState) {
        return;
    }
    mDragScrollStartTimeInMs = Long.MIN_VALUE;
    final int prevActionState = mActionState;
    // prevent duplicate animations
    endRecoverAnimation(selected, true);
    mActionState = actionState;
    if (actionState == ACTION_STATE_DRAG) {
        // we remove after animation is complete. this means we only elevate the last drag
        // child but that should perform good enough as it is very hard to start dragging a
        // new child before the previous one settles.
        mOverdrawChild = selected.itemView;
        addChildDrawingOrderCallback();
    }
    int actionStateMask = (1 << (DIRECTION_FLAG_COUNT + DIRECTION_FLAG_COUNT * actionState))
            - 1;
    boolean preventLayout = false;
    //当mSelected不为null的时候，新建RecoverAnimation对象，并且start这个ValueAnimator
    if (mSelected != null) {
        final ViewHolder prevSelected = mSelected;
        if (prevSelected.itemView.getParent() != null) {
            //当为DRAG状态时候swipeDir为0
            final int swipeDir = prevActionState == ACTION_STATE_DRAG ? 0
                    : swipeIfNecessary(prevSelected);
            releaseVelocityTracker();
            // find where we should animate to
            final float targetTranslateX, targetTranslateY;
            int animationType;
            switch (swipeDir) {
                case LEFT:
                case RIGHT:
                case START:
                case END:
                    targetTranslateY = 0;
                    targetTranslateX = Math.signum(mDx) * mRecyclerView.getWidth();
                    break;
                case UP:
                case DOWN:
                    targetTranslateX = 0;
                    targetTranslateY = Math.signum(mDy) * mRecyclerView.getHeight();
                    break;
                default:
                    targetTranslateX = 0;
                    targetTranslateY = 0;
            }
            if (prevActionState == ACTION_STATE_DRAG) {
                animationType = ANIMATION_TYPE_DRAG;
            } else if (swipeDir > 0) {
                animationType = ANIMATION_TYPE_SWIPE_SUCCESS;
            } else {
                animationType = ANIMATION_TYPE_SWIPE_CANCEL;
            }
            getSelectedDxDy(mTmpPosition);
            final float currentTranslateX = mTmpPosition[0];
            final float currentTranslateY = mTmpPosition[1];
            final RecoverAnimation rv = new RecoverAnimation(prevSelected, animationType,
                    prevActionState, currentTranslateX, currentTranslateY,
                    targetTranslateX, targetTranslateY) {
                @Override
                public void onAnimationEnd(ValueAnimatorCompat animation) {
                    super.onAnimationEnd(animation);
                    if (this.mOverridden) {
                        return;
                    }
                    //动画结束如果swipeDir<=0则drag与swipe失败，Callback会调用clearView方法
                    //swipeDir >0则表示成功，会调用postDispatchSwipe方法
                    //当为DRAG状态时候因为swipeDir为0，所以只走clearView方法
                    if (swipeDir <= 0) {
                        // this is a drag or failed swipe. recover immediately
                        mCallback.clearView(mRecyclerView, prevSelected);
                        // full cleanup will happen on onDrawOver
                    } else {
                        // wait until remove animation is complete.
                        mPendingCleanup.add(prevSelected.itemView);
                        mIsPendingCleanup = true;
                        if (swipeDir > 0) {
                            // Animation might be ended by other animators during a layout.
                            // We defer callback to avoid editing adapter during a layout.
                            postDispatchSwipe(this, swipeDir);
                        }
                    }
                    // removed from the list after it is drawn for the last time
                    if (mOverdrawChild == prevSelected.itemView) {
                        removeChildDrawingOrderCallbackIfNecessary(prevSelected.itemView);
                    }
                }
            };
            //获取AnimationDuration,我们可以通过重写这个方法来设定动画的时间
            final long duration = mCallback.getAnimationDuration(mRecyclerView, animationType,
                    targetTranslateX - currentTranslateX, targetTranslateY - currentTranslateY);
            rv.setDuration(duration);
            mRecoverAnimations.add(rv);
            rv.start();
            preventLayout = true;
        } else {
            removeChildDrawingOrderCallbackIfNecessary(prevSelected.itemView);
            mCallback.clearView(mRecyclerView, prevSelected);
        }
        mSelected = null;
    }
    //当传进来的selected不为空的时候将selected赋给mSelected
    if (selected != null) {
        mSelectedFlags =
                (mCallback.getAbsoluteMovementFlags(mRecyclerView, selected) & actionStateMask)
                        >> (mActionState * DIRECTION_FLAG_COUNT);
        mSelectedStartX = selected.itemView.getLeft();
        mSelectedStartY = selected.itemView.getTop();
        mSelected = selected;
        if (actionState == ACTION_STATE_DRAG) {
            mSelected.itemView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
        }
    }
    final ViewParent rvParent = mRecyclerView.getParent();
    if (rvParent != null) {
        rvParent.requestDisallowInterceptTouchEvent(mSelected != null);
    }
    if (!preventLayout) {
        mRecyclerView.getLayoutManager().requestSimpleAnimationsInNextLayout();
    }
    //每次select会带来拖动或者滑动的ViewHolder改变，所以这里会调用onSelectedChanged方法，我们可以通过回调接受到这些信息
    mCallback.onSelectedChanged(mSelected, mActionState);
    mRecyclerView.invalidate();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private void postDispatchSwipe(final RecoverAnimation anim, final int swipeDir) {
    // wait until animations are complete.
    mRecyclerView.post(new Runnable() {
        @Override
        public void run() {
            if (mRecyclerView != null && mRecyclerView.isAttachedToWindow() &&
                    !anim.mOverridden &&
                    anim.mViewHolder.getAdapterPosition() != RecyclerView.NO_POSITION) {
                final RecyclerView.ItemAnimator animator = mRecyclerView.getItemAnimator();
                // if animator is running or we have other active recover animations, we try
                // not to call onSwiped because DefaultItemAnimator is not good at merging
                // animations. Instead, we wait and batch.
                if ((animator == null || !animator.isRunning(null))
                        && !hasRunningRecoverAnim()) {
                    //当滑动结束会调用onSwiped()方法，我们可以在
                    mCallback.onSwiped(anim.mViewHolder, swipeDir);
                } else {
                    mRecyclerView.post(this);
                }
            }
        }
    });
}

通过代码这部分代码我们可以大致知道了select这个方法的作用了，它主要是处理当手指拖动或者滑动结束后的动画，要通过两次调用，第一次在我们选中的时候，作用是确定我们手指选择的View，第二次在我们手指放开的时候，作用是给这个View设置动画，并且执行。

接下来看看checkSelectForSwipe() 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
private boolean checkSelectForSwipe(int action, MotionEvent motionEvent, int pointerIndex) {
     //这里调用了Callback的isItemViewSwipeEnabled()方法，我们通过重写这个方法可以控制是否可以Swipe
    if (mSelected != null || action != MotionEvent.ACTION_MOVE
            || mActionState == ACTION_STATE_DRAG || !mCallback.isItemViewSwipeEnabled()) {
        return false;
    }
    if (mRecyclerView.getScrollState() == RecyclerView.SCROLL_STATE_DRAGGING) {
        return false;
    }
    final ViewHolder vh = findSwipedView(motionEvent);
    if (vh == null) {
        return false;
    }
    //这里的getAbsoluteMovementFlags（）前面有介绍过，
    final int movementFlags = mCallback.getAbsoluteMovementFlags(mRecyclerView, vh);
    final int swipeFlags = (movementFlags & ACTION_MODE_SWIPE_MASK)
            >> (DIRECTION_FLAG_COUNT * ACTION_STATE_SWIPE);
    if (swipeFlags == 0) {
        return false;
    }
    // mDx and mDy are only set in allowed directions. We use custom x/y here instead of
    // updateDxDy to avoid swiping if user moves more in the other direction
    final float x = MotionEventCompat.getX(motionEvent, pointerIndex);
    final float y = MotionEventCompat.getY(motionEvent, pointerIndex);
    // Calculate the distance moved
    final float dx = x - mInitialTouchX;
    final float dy = y - mInitialTouchY;
    // swipe target is chose w/o applying flags so it does not really check if swiping in that
    // direction is allowed. This why here, we use mDx mDy to check slope value again.
    final float absDx = Math.abs(dx);
    final float absDy = Math.abs(dy);
    if (absDx < mSlop && absDy < mSlop) {
        return false;
    }
    if (absDx > absDy) {
        if (dx < 0 && (swipeFlags & LEFT) == 0) {
            return false;
        }
        if (dx > 0 && (swipeFlags & RIGHT) == 0) {
            return false;
        }
    } else {
        if (dy < 0 && (swipeFlags & UP) == 0) {
            return false;
        }
        if (dy > 0 && (swipeFlags & DOWN) == 0) {
            return false;
        }
    }
    mDx = mDy = 0f;
    mActivePointerId = MotionEventCompat.getPointerId(motionEvent, 0);
    //select方法
    select(vh, ACTION_STATE_SWIPE);
    return true;
}

这个方法主要是确定当前的我们选择的View是否可以滑动，而前面说的select方法的第一次调用是在这里，这个主要是滑动的select第一个方法，拖动的第一个select方法则在GestureDetector的onLongPress中

到这里基本就介绍结束onInterceptTouchEvent里面做的东西了

(2).onTouchEvent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public void onTouchEvent(RecyclerView recyclerView, MotionEvent event) {
    mGestureDetector.onTouchEvent(event);
    if (DEBUG) {
        Log.d(TAG,
                "on touch: x:" + mInitialTouchX + ",y:" + mInitialTouchY + ", :" + event);
    }
    if (mVelocityTracker != null) {
        mVelocityTracker.addMovement(event);
    }
    if (mActivePointerId == ACTIVE_POINTER_ID_NONE) {
        return;
    }
    final int action = MotionEventCompat.getActionMasked(event);
    final int activePointerIndex = MotionEventCompat
            .findPointerIndex(event, mActivePointerId);
    if (activePointerIndex >= 0) {
        checkSelectForSwipe(action, event, activePointerIndex);
    }
    ViewHolder viewHolder = mSelected;
    if (viewHolder == null) {
        return;
    }
    switch (action) {
        case MotionEvent.ACTION_MOVE: {
            // Find the index of the active pointer and fetch its position
            if (activePointerIndex >= 0) {
                updateDxDy(event, mSelectedFlags, activePointerIndex);
                moveIfNecessary(viewHolder);
                mRecyclerView.removeCallbacks(mScrollRunnable);
                mScrollRunnable.run();
                mRecyclerView.invalidate();
            }
            break;
        }
        case MotionEvent.ACTION_CANCEL:
            if (mVelocityTracker != null) {
                mVelocityTracker.clear();
            }
            // fall through
        case MotionEvent.ACTION_UP:
            // 第二次select，触发动画
            select(null, ACTION_STATE_IDLE);
            mActivePointerId = ACTIVE_POINTER_ID_NONE;
            break;
        case MotionEvent.ACTION_POINTER_UP: {
            final int pointerIndex = MotionEventCompat.getActionIndex(event);
            final int pointerId = MotionEventCompat.getPointerId(event, pointerIndex);
            if (pointerId == mActivePointerId) {
                // This was our active pointer going up. Choose a new
                // active pointer and adjust accordingly.
                final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
                mActivePointerId = MotionEventCompat.getPointerId(event, newPointerIndex);
                updateDxDy(event, mSelectedFlags, pointerIndex);
            }
            break;
        }
    }
}

在ACTION_UP时候触发的第二次select()则会执行动画效果

而ACTION_MOVE则是处理随着手指运动的效果，那我们看下里面的实现方法

主要有两个一个是moveIfNecessary另外一个是mScrollRunnable

我们看下mScrollRunnable

1
2
3
4
5
6
7
8
9
10
11
12
private final Runnable mScrollRunnable = new Runnable() {
    @Override
    public void run() {
        if (mSelected != null && scrollIfNecessary()) {
            if (mSelected != null) { //it might be lost during scrolling
                moveIfNecessary(mSelected);
            }
            mRecyclerView.removeCallbacks(mScrollRunnable);
            ViewCompat.postOnAnimation(mRecyclerView, this);
        }
    }
};

那我们先来分析下scrollIfNecessary（）然后再分析moveIfNecessary（）方法

scrollIfNecessary其实上面的注释解释的很清楚，它的作用是检测我们滑动是否到达RecycleView的边缘区域，如果到达边缘区域则将RecycleView移动（scrollBy）,这里也调用了callback的interpolateOutOfBoundsScroll方法，所以我们可以在这里监听到我们拖出视图边界的调用

接下来看一下moveIfNecessary（）方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
private void moveIfNecessary(ViewHolder viewHolder) {
    if (mRecyclerView.isLayoutRequested()) {
        return;
    }
    if (mActionState != ACTION_STATE_DRAG) {
        return;
    }
   //获取getMoveThreshold，可以通过重写来自定义用户视为拖动的距离
    final float threshold = mCallback.getMoveThreshold(viewHolder);
    final int x = (int) (mSelectedStartX + mDx);
    final int y = (int) (mSelectedStartY + mDy);
   //当移动距离小于拖动距离，return掉
    if (Math.abs(y - viewHolder.itemView.getTop()) < viewHolder.itemView.getHeight() * threshold
            && Math.abs(x - viewHolder.itemView.getLeft())
            < viewHolder.itemView.getWidth() * threshold) {
        return;
    }
    List<ViewHolder> swapTargets = findSwapTargets(viewHolder);
    if (swapTargets.size() == 0) {
        return;
    }
    ViewHolder target = mCallback.chooseDropTarget(viewHolder, swapTargets, x, y);
    if (target == null) {
        mSwapTargets.clear();
        mDistances.clear();
        return;
    }
    final int toPosition = target.getAdapterPosition();
    final int fromPosition = viewHolder.getAdapterPosition();
    //调用onMove，可以重写来让RecycleView改变，也可以让callback的onMoved方法是否重调
    if (mCallback.onMove(mRecyclerView, viewHolder, target)) {
        // keep target visible
        mCallback.onMoved(mRecyclerView, viewHolder, fromPosition,
                target, toPosition, x, y);
    }
}

所以这里其实是用来判断是否move的带来RecycleView的变化

最后 调用了mRecyclerView.invalidate()方法，而这个方法呢则调用了前面所提到的ItemDecoration里的方法，而那里面的方法处理的是当运动带来的拖动与滑动的交互，前面有提到就不做过多的介绍了

所以总结一下，拖动时通过mRecyclerView.invalidate让onDraw不断重绘带来手指与点击ViewHolder的变化，当手指离开时候则通过select方法启动RecoverAnimation让ViewHolder执行后面的动画，基本的流程就是这样，当然中间有很多Callback方法带来不同的变化，感觉整个流程我还是讲的比较乱的，大家理解大致流程就好了。。到这里就基本分析结束了，当然还有一些方法可能没有介绍了，大家可以通过前面的Callback注释的方法去理解大致的功能就好了。