SwipeRefreshLayout源码分析

发表于

SwipeRefreshLayout已经推出许久了，很多App都在使用，这里对其实现方式做个分析。下拉刷新控件其实是很好的学习Android的Touch事件传递的用例，尤其是其中onInterceptTouchEvent()和onTouchEvent()方法的实现，对于自定义ViewGroup的事件处理部分有借鉴意义。

这篇文章分析传统的基于Touch事件传递流程的下拉刷新逻辑。（还有一个逻辑分支是NestedScroll，先留个坑。）

总览

下拉刷新的实现思路并不难，如果了解过Touch事件传递的流程，就不难想到：

  1. 自定义ViewGroup包裹在需要刷新的内容View外层。
  2. 在onInterceptTouchEvent()方法中判断是否应当触发下拉刷新，一般判断条件都是内容View已经滚动到顶部。
  3. 拦截事件并交给自身的onTouchEvent()方法处理。
  4. 在onTouchEvent()方法中处理Touch事件，包括根据刷新的状态更新UI，触发刷新监听器等。

这就是最核心的下拉刷新的逻辑，下面看一下SwipeRefreshLayout是怎么实现的，又有什么值得学习的地方。

Support包版本为25.1.0

onInterceptTouchEvent(MotionEvent ev)

onInterceptTouchEvent()可以看做是下拉刷新流程的其实位置，Touch事件传递到SwipeRefreshLayout中，会先执行onInterceptTouchEvent()方法，通过其返回值决定继续向下传递还是让SwipeRefreshLayout作为后续事件的消费者。

这个方法中包含如下逻辑：

  1. 如果还没有确定需要刷新的View，找到刷新的View。

  2. 排除5种不应该刷新的状态。（不可用、正在复位、子View还可以下拉、正在刷新、处于NestedScroll状态）

    如果当前正在复位，并且收到了DOWN事件，则忽略复位状态。

  3. 如果是DOWN事件，记录初始位置和事件的pointerId（手指）。

  4. 如果是MOVE事件，如果滑动距离超过阈值，标记进入下拉刷新状态，将使这个方法返回true，后续事件由onTouchEvent()处理。

  5. 如果是POINTER_UP事件（非主要手指抬起），重新记录pointerId。

  6. 如果是UP事件，退出刷新状态，清除pointerId记录。

源码

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
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
	// 确定刷新的View，这个View会赋值给mTarget属性，后续判断是否可以下拉会使用到。
    ensureTarget();

    final int action = MotionEventCompat.getActionMasked(ev);
    int pointerIndex;

  	// DOWN事件时忽略复位状态
    if (mReturningToStart && action == MotionEvent.ACTION_DOWN) {
        mReturningToStart = false;
    }

  	// 5个条件满足一个，就不处理事件，让事件向下传递。
    if (!isEnabled() || mReturningToStart || canChildScrollUp()
            || mRefreshing || mNestedScrollInProgress) {
        // Fail fast if we're not in a state where a swipe is possible
        return false;
    }

    switch (action) {
        case MotionEvent.ACTION_DOWN:
        	// 移动CircleView到初始值(方法名用了Target这个单词，我认为不妥。)
            setTargetOffsetTopAndBottom(mOriginalOffsetTop - mCircleView.getTop(), true);
            mActivePointerId = ev.getPointerId(0);
            mIsBeingDragged = false;

            pointerIndex = ev.findPointerIndex(mActivePointerId);
            if (pointerIndex < 0) {
                return false;
            }
        	// 记录初始按下位置
            mInitialDownY = ev.getY(pointerIndex);
            break;

        case MotionEvent.ACTION_MOVE:
            if (mActivePointerId == INVALID_POINTER) {
                Log.e(LOG_TAG, "Got ACTION_MOVE event but don't have an active pointer id.");
                return false;
            }

            pointerIndex = ev.findPointerIndex(mActivePointerId);
            if (pointerIndex < 0) {
                return false;
            }
        	// 当前事件的Y值。
            final float y = ev.getY(pointerIndex);
        	// 虽然方法名字叫做startDragging，但其实里面进行了判断，是否应该拦截事件。(方法名不妥)
            startDragging(y);
            break;

        case MotionEventCompat.ACTION_POINTER_UP:
        	// 重新标记激活的pointerId
            onSecondaryPointerUp(ev);
            break;

        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL:
        	// 停止拦截事件
            mIsBeingDragged = false;
            mActivePointerId = INVALID_POINTER;
            break;
    }

    return mIsBeingDragged;
}

需要注意onSecondaryPointerUp()方法：

1
2
3
4
5
6
7
8
9
10
private void onSecondaryPointerUp(MotionEvent ev) {
    final int pointerIndex = MotionEventCompat.getActionIndex(ev);
    final int pointerId = ev.getPointerId(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 = ev.getPointerId(newPointerIndex);
    }
}

这个方法的实现只支持最多两个手指的切换，如果有第三个触摸点，就会出现bug。相似的逻辑在NestedScrollView中也出现了，并且其代码里面包含TODO：

TODO: Make this decision more intelligent.

onTouchEvent(MotionEvent ev)

这个方法的核心逻辑就是调用moveSpinner方法和finishSpinner方法。这两个方法中分别对应【手指移动时拖拽CircleView移动并且更新CircleView上面箭头的样式】以及【Touch事件结束时判断复位或者进入刷新状态】。

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
@Override
public boolean onTouchEvent(MotionEvent ev) {
    // 省略了一些代码……
    switch (action) {
        case MotionEvent.ACTION_DOWN:
            // 省略了一些代码……

        case MotionEvent.ACTION_MOVE: {
            // 省略了一些代码……
            
            if (mIsBeingDragged) {
              	// mInitialMotionY等于(DOWN事件的坐标 + mTouchSlop)，DRAG_RATE等于0.5f
                final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
             	// 是否需要移动CircleView
                if (overscrollTop > 0) {
                  	// 移动CircleView
                    moveSpinner(overscrollTop);
                } else {
                    return false;
                }
            }
            break;
        }
        case MotionEventCompat.ACTION_POINTER_DOWN: {
          	// 有新手指按下，标记新手指。
            pointerIndex = MotionEventCompat.getActionIndex(ev);
            if (pointerIndex < 0) {
                Log.e(LOG_TAG,
                        "Got ACTION_POINTER_DOWN event but have an invalid action index.");
                return false;
            }
            mActivePointerId = ev.getPointerId(pointerIndex);
            break;
        }

        case MotionEventCompat.ACTION_POINTER_UP:
            onSecondaryPointerUp(ev);
            break;

        case MotionEvent.ACTION_UP: {
            // 省略了一些代码……

            if (mIsBeingDragged) {
                final float y = ev.getY(pointerIndex);
                final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
                mIsBeingDragged = false;
              	// 复位CircleView或者移动到刷新状态的位置(getTop() == 64dp)
                finishSpinner(overscrollTop);
            }
            mActivePointerId = INVALID_POINTER;
            return false;
        }
        case MotionEvent.ACTION_CANCEL:
            return false;
    }

    return true;
}

moveSpinner()方法实现了CircleView位置的计算以及箭头属性的计算，可以跳过。

finishSpinner()方法判断滑动距离是否超过了阈值，超过的话调用setRefresh(boolean, boolean)方法触发刷新回调：

1
2
3
4
5
6
7
8
9
10
private void finishSpinner(float overscrollTop) {
    if (overscrollTop > mTotalDragDistance) {
      	// 触发刷新
        setRefreshing(true, true /* notify */);
    } else {
        // cancel refresh
        mRefreshing = false;
        // 省略一些代码……
    }
}

setRefresh()方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private void setRefreshing(boolean refreshing, final boolean notify) {
    if (mRefreshing != refreshing) {
        mNotify = notify;
        ensureTarget();
        mRefreshing = refreshing;
        if (mRefreshing) {
          	// 移动到刷新位置。
            animateOffsetToCorrectPosition(mCurrentTargetOffsetTop, mRefreshListener);
        } else {
          	// 停止刷新时的处理，执行CircleView的缩小动画。
            startScaleDownAnimation(mRefreshListener);
        }
    }
}

注意animateOffsetToCorrectPosition(mCurrentTargetOffsetTop, mRefreshListener);这一行，回调的逻辑在mRefreshLinstener里面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private Animation.AnimationListener mRefreshListener = new Animation.AnimationListener() {
    // 省略一些代码
    @SuppressLint("NewApi")
    @Override
    public void onAnimationEnd(Animation animation) {
        if (mRefreshing) {
            // Make sure the progress view is fully visible
            mProgress.setAlpha(MAX_ALPHA);
            mProgress.start();
            if (mNotify) {
              	// 通知回调
                if (mListener != null) {
                    mListener.onRefresh();
                }
            }
            mCurrentTargetOffsetTop = mCircleView.getTop();
        } else {
            reset();
        }
    }
};

当执行mListener.onRefresh()方法时，就是执行我们熟悉的回调方法了。

刷新结束之后，调用setRefreshing(false);方法时，也会执行到上面两个参数的setRefreshing(false, false)方法，执行缩小动画。

canChildScrollUp

下拉刷新逻辑中的一个关键判断就是判断子View是否已经滑动到最顶端，SwipeRefreshLayout使用canChildScrollUp()方法进行这个判断：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public boolean canChildScrollUp() {
    if (mChildScrollUpCallback != null) {
        return mChildScrollUpCallback.canChildScrollUp(this, mTarget);
    }
    if (android.os.Build.VERSION.SDK_INT < 14) {
        if (mTarget instanceof AbsListView) {
            final AbsListView absListView = (AbsListView) mTarget;
            return absListView.getChildCount() > 0
                    && (absListView.getFirstVisiblePosition() > 0 || absListView.getChildAt(0)
                            .getTop() < absListView.getPaddingTop());
        } else {
            return ViewCompat.canScrollVertically(mTarget, -1) || mTarget.getScrollY() > 0;
        }
    } else {
        return ViewCompat.canScrollVertically(mTarget, -1);
    }
}

除了SDK版本14以下对于ListView的特殊处理，都使用ViewCompat.canScrollVertically(mTarget, -1);这个方法进行判断。最终会执行下面的判断逻辑：

1
2
3
4
5
6
7
8
9
10
11
private boolean canScrollingViewScrollVertically(ScrollingView view, int direction) {
    final int offset = view.computeVerticalScrollOffset();
    final int range = view.computeVerticalScrollRange() -
            view.computeVerticalScrollExtent();
    if (range == 0) return false;
    if (direction < 0) {
        return offset > 0;
    } else {
        return offset < range - 1;
    }
}

其中的关键数值offset最终还是会从View的mScrollY属性获取，和getScrollY()获取到的是同一个值。

这里需要注意的问题是direction的认定。ViewCompat.canScrollVertically(mTarget, -1);这个方法的参数-1以及canChildScrollUp()的方法名，都包含了UP这个方向，但是我们判断是否到顶了不应该是判断【是否能向下滚动】吗，为什么是相反的呢？

原因要从mScrollY这个参数上找，mScrollY的含义其实是View相对于内容的偏移量：

上图中，mScrollY的值实际上内容坐标系中View显示区域的偏移量。图中的mScrollY的符号位正。也就是我们通常所说的“上拉”对应mScrollY的值为正值，反之负值就对应“下拉”了，也就是上文提到的UP。

-1还可以理解为使mScrollY减小的方向，自然也就是“下拉”了。

总之，这里确实有点绕。

关于Draw

SwipeRefreshLayout中，还有几个和绘制相关的点，值得关注一下。

setWillNotDraw(boolean)：这个方法关联到ViewGroup的一个flag，默认情况下为true，也就是自身不需要进行绘制，底层会根据这个flag进行优化。需要绘制的话，需要将flag置为true。

ViewCompat.setChildrenDrawingOrderEnabled(ViewGroup viewGroup, boolean enable)：通常我们自定义ViewGroup时需要将某个View在顶层绘制，都是调用View.bringToFront();方法将其移动到最顶层，但是这个方法有一个副作用，后面会提到。而ViewCompat的这个方法提供了另一种解决方案。

ViewGroup在绘制子View时，如果之前调用了setChildrenDrawingOrderEnabled()设置为true，会调用getChildDrawingOrder()重新确定每个子View的绘制顺序，也就可以实现将某个View的顺序放置到顶层了。SwipeRefreshLayout的实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Override
protected int getChildDrawingOrder(int childCount, int i) {
    if (mCircleViewIndex < 0) {
        return i;
    } else if (i == childCount - 1) {
        // Draw the selected child last
        return mCircleViewIndex;
    } else if (i >= mCircleViewIndex) {
        // Move the children after the selected child earlier one
        return i + 1;
    } else {
        // Keep the children before the selected child the same
        return i;
    }
}

解释一下，第一个参数很好理解，第二个参数是迭代位置，返回值是子View的index，这个方法的作用可以理解为：第i次应该绘制哪个子View，默认实现是return i;。也就是按照子View的顺序绘制。针对上面的实现，假设mCircleViewIndex的值为2，childCount的值为6，那么会得到如下结果。

是不是很有趣？

Measure 和 Layout：Measure的过程中，对于mTarget，忽略LayoutParams参数，直接设置为填满父控件的值。Layout过程中，只对mCircleView和mTarget两个View进行布局。这些都是常用的行之有效的处理方法。

总结

以上就是对SwipeRefreshLayout的分析，当然开头提到了，只是Touch事件的逻辑分支，NestedScroll相关的内容，就留到下次啦。