死磕到底RecyclerView | RecyclerView 的滚动是怎么实现的？

RecyclerView 是一个展示列表的控件，其中的子控件可以被滚动。这是怎么实现的？以走查源码的方式一探究竟。

切入点：滚动事件

阅读源码时，如何在浩瀚的源码中选择合适的切入点很重要，选好了能少走弯路。

对于滚动这个场景，最显而易见的切入点是触摸事件，即手指在 RecyclerView 上滑动，列表跟手滚动。

就以RecyclerView.OnTouchEvent()为切入点。手指滑动，列表随之而动的逻辑应该在ACTION_MOVE中，其源码如下（略长可跳过）：

public class RecyclerView {
    @Override
    public boolean onTouchEvent(MotionEvent e) {
        switch (action) {
            case MotionEvent.ACTION_MOVE: {
                final int index = e.findPointerIndex(mScrollPointerId);
                if (index < 0) {
                    Log.e(TAG, "Error processing scroll; pointer index for id "
                            + mScrollPointerId + " not found. Did any MotionEvents get skipped?");
                    return false;
                }

                final int x = (int) (e.getX(index) + 0.5f);
                final int y = (int) (e.getY(index) + 0.5f);
                int dx = mLastTouchX - x;
                int dy = mLastTouchY - y;

                if (mScrollState != SCROLL_STATE_DRAGGING) {
                    boolean startScroll = false;
                    if (canScrollHorizontally) {
                        if (dx > 0) {
                            dx = Math.max(0, dx - mTouchSlop);
                        } else {
                            dx = Math.min(0, dx + mTouchSlop);
                        }
                        if (dx != 0) {
                            startScroll = true;
                        }
                    }
                    if (canScrollVertically) {
                        if (dy > 0) {
                            dy = Math.max(0, dy - mTouchSlop);
                        } else {
                            dy = Math.min(0, dy + mTouchSlop);
                        }
                        if (dy != 0) {
                            startScroll = true;
                        }
                    }
                    if (startScroll) {
                        setScrollState(SCROLL_STATE_DRAGGING);
                    }
                }

                if (mScrollState == SCROLL_STATE_DRAGGING) {
                    mReusableIntPair[0] = 0;
                    mReusableIntPair[1] = 0;
                    if (dispatchNestedPreScroll(
                            canScrollHorizontally ? dx : 0,
                            canScrollVertically ? dy : 0,
                            mReusableIntPair, mScrollOffset, TYPE_TOUCH
                    )) {
                        dx -= mReusableIntPair[0];
                        dy -= mReusableIntPair[1];
                        // Updated the nested offsets
                        mNestedOffsets[0] += mScrollOffset[0];
                        mNestedOffsets[1] += mScrollOffset[1];
                        // Scroll has initiated, prevent parents from intercepting
                        getParent().requestDisallowInterceptTouchEvent(true);
                    }

                    mLastTouchX = x - mScrollOffset[0];
                    mLastTouchY = y - mScrollOffset[1];

                    if (scrollByInternal(
                            canScrollHorizontally ? dx : 0,
                            canScrollVertically ? dy : 0,
                            e)) {
                        getParent().requestDisallowInterceptTouchEvent(true);
                    }
                    if (mGapWorker != null && (dx != 0 || dy != 0)) {
                        mGapWorker.postFromTraversal(this, dx, dy);
                    }
                }
            } break;
        }
    }
}

读源码新方法：Profiler法

虽然已经精准定位到滑动相关逻辑，但ACTION_MOVE这个分支中的源码还是太长，头痛！

如何快速地在庞杂的源码中定位到关键逻辑？

RecyclerView 动画原理 | 换个姿势看源码（pre-layout）中介绍过一种方法：“断点调试法”。即写一个最简单的 demo 来模拟场景，然后通过断点调试确定源码调用链上的关键路径。

今天再介绍一种更加快捷的方法：“Profiler法”。

还是写一个 demo 加载一个列表，打开 AndroidStudio 自带的性能调试工具 Profiler，选中 CPU 栏，用手指触发列表滚动，然后点击 Record 按钮，开始记录列表滚动过程中完整的函数调用链，待列表滚动完毕后，点击 Stop 停止记录。就能得到这样的画面：

横轴表示时间，纵轴表示该时间点发生的函数调用，调用链的方向是从上到下的，即上面的是调用者，下面的是被调用者。

图片上方有一条红色的线段，表示这段时间内发生用户交互，demo 场景中的交互就是手指滑动列表。触发列表滚动的逻辑应该就包含在红色线段对应的时间内，按 w 键把这段调用链放大查看：

调用链实在是很长，若看不清可以点击大图。

调用链的最顶端是Looper.loop()方法，因为所有主线程的逻辑都在其中执行。

沿着调用链往下看，Looper 调用了 MessageQueue.next()，表示取出消息队列中的下一条消息，并紧接着执行了Hanlder.dispatchMessage()和Hander.handleCallback()，表示分发并处理这条消息。

因为这条消息是触摸事件的处理，所以Choreographer又委托ViewRootImpl分发触摸事件，经过一条很长的分发链，终于看到一个熟悉的方法Activity.dispatchTouchEvent()，表示触摸事件已经传递到 Activity。然后根据界面的层级结构，一层层地分发到RecyclerView.onTouchEvent()，走到这里，我们关心的列表滑动逻辑就一下子全部展现在面前，将这个布局再放大看一下：

一条清晰的调用链搜地一下扑面而来：

RecyclerView.onTouchEvent()
RecyclerView.scrollByInternal()
RecyclerView.scrollStep()
LinearLayoutManager.scrollVerticallyBy()
LinearLayoutManager.scrollBy()
OrientationHelper.offsetChildren()
LayoutManager.offsetChildrenVertical()
RecyclerView.offsetChildrenVertical()
View.offsetTopAndBottom()

已经不需要和RecyclerView.onTouchEvent()中庞杂的逻辑纠缠了，沿着这个调用走查，所有的关键信息一个都不会漏掉。

沿着关键调用链走查

有了上面的关键调用链，就节省了很多时间。现在可以对RecyclerView.onTouchEvent()中的逻辑披沙拣金：

public class RecyclerView {
    @Override
    public boolean onTouchEvent(MotionEvent e) {
        switch (action) {
            case MotionEvent.ACTION_MOVE: {
                ...
                if (mScrollState == SCROLL_STATE_DRAGGING) {
                    mReusableIntPair[0] = 0;
                    mReusableIntPair[1] = 0;
                    // 1\. 触发嵌套滚动，让嵌套滚动中的父控件优先消费滚动距离
                    if (dispatchNestedPreScroll(
                            canScrollHorizontally ? dx : 0,
                            canScrollVertically ? dy : 0,
                            mReusableIntPair, mScrollOffset, TYPE_TOUCH
                    )) {
                        dx -= mReusableIntPair[0];
                        dy -= mReusableIntPair[1];
                        mNestedOffsets[0] += mScrollOffset[0];
                        mNestedOffsets[1] += mScrollOffset[1];
                        getParent().requestDisallowInterceptTouchEvent(true);
                    }
                    ...

                    // 2\. 触发列表自身的滚动
                    if (scrollByInternal(
                            canScrollHorizontally ? dx : 0,
                            canScrollVertically ? dy : 0,
                            e)) {
                        getParent().requestDisallowInterceptTouchEvent(true);
                    }
                    ...
                }
            } break;
        }
    }
}

在关键调用链scrollByInternal()的上面，意外地发现了处理嵌套滚动的逻辑，这是为了在列表消费滚动距离之前优先让其父控件消费。

public class RecyclerView {
    boolean scrollByInternal(int x, int y, MotionEvent ev) {
        int unconsumedX = 0;
        int unconsumedY = 0;
        int consumedX = 0;
        int consumedY = 0;

        consumePendingUpdateOperations();
        if (mAdapter != null) {
            mReusableIntPair[0] = 0;
            mReusableIntPair[1] = 0;
            // 触发列表滚动(手指滑动距离被传入)
            scrollStep(x, y, mReusableIntPair);
            // 记录列表滚动消耗的像素值和剩余未消耗的像素值
            consumedX = mReusableIntPair[0];
            consumedY = mReusableIntPair[1];
            unconsumedX = x - consumedX;
            unconsumedY = y - consumedY;
        }
        ...
        mReusableIntPair[0] = 0;
        mReusableIntPair[1] = 0;
        // 将列表未消耗的滚动距离继续留给其父控件消耗
        dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, mScrollOffset,
                TYPE_TOUCH, mReusableIntPair);
        unconsumedX -= mReusableIntPair[0];
        unconsumedY -= mReusableIntPair[1];
        ...
    }
}

scrollByInternal()是触发列表滚动调用链的起点，它先调用了scrollStep()以触发列表自身的滚动，紧接着还调用了dispatchNestedScroll()将自身消费后剩下的滚动余量继续交给其父控件消费。

沿着关键调用链继续往下走查：

public class RecyclerView {
    LayoutManager mLayout;
    void scrollStep(int dx, int dy, @Nullable int[] consumed) {
        // 在滚动之前禁止重新布局
        startInterceptRequestLayout();
        onEnterLayoutOrScroll();

        int consumedX = 0;
        int consumedY = 0;
        // 横向滚动 dx
        if (dx != 0) {
            consumedX = mLayout.scrollHorizontallyBy(dx, mRecycler, mState);
        }
        // 纵向滚动 dy
        if (dy != 0) {
            consumedY = mLayout.scrollVerticallyBy(dy, mRecycler, mState);
        }
        ...
        // 将滚动消耗通过数组传递出去
        if (consumed != null) {
            consumed[0] = consumedX;
            consumed[1] = consumedY;
        }
    }
}

scrollStep()把触发滚动的任务委托给了LayoutManager，调用了它的scrollVerticallyBy()：

public class RecyclerView {
    public abstract static class LayoutManager {
        // 空实现
        public int scrollVerticallyBy(int dy, Recycler recycler, State state) {
            return 0;
        }
    }
}

public class LinearLayoutManager extends RecyclerView.LayoutManager {
    @Override
    public int scrollVerticallyBy(int dy, RecyclerView.Recycler recycler, RecyclerView.State state) {
        // 若是横向布局则不会发生纵向滚动
        if (mOrientation == HORIZONTAL) {
            return 0;
        }
        // 触发纵向滚动
        return scrollBy(dy, recycler, state);
    }

    int scrollBy(int delta, RecyclerView.Recycler recycler, RecyclerView.State state) {
        ...
        final int layoutDirection = delta > 0 ? LayoutState.LAYOUT_END : LayoutState.LAYOUT_START;
        final int absDelta = Math.abs(delta);
        // 计算和滚动相关的各种数据并将其保存在 mLayoutState 中
        updateLayoutState(layoutDirection, absDelta, true, state);
        // 填充额外的表项，并计算实际消耗的滚动值
        final int consumed = mLayoutState.mScrollingOffset + fill(recycler, mLayoutState, state, false);
        ...
        final int scrolled = absDelta > consumed ? layoutDirection * consumed : delta;
        // 将列表所有孩子都想滚动的反方向平移对应像素
        mOrientationHelper.offsetChildren(-scrolled);
        ...
        mLayoutState.mLastScrollDelta = scrolled;
        return scrolled;
    }
}

若阅读过RecyclerView 动画原理 | 换个姿势看源码（pre-layout），对LinearLayoutManager.fill()方法一定不陌生。它用来向列表中填充额外的表项，填充个数由额外空间mLayoutState.mAvailable说了算，它在updateLayoutState()方法里被absDelta赋值，即滚动距离。

fill()的源码如下：

public class LinearLayoutManager {
    // 根据剩余空间填充表项
    int fill(RecyclerView.Recycler recycler, LayoutState layoutState,RecyclerView.State state, boolean stopOnFocusable) {
        ...
        // 计算剩余空间 = 可用空间 + 额外空间
        int remainingSpace = layoutState.mAvailable + layoutState.mExtraFillSpace;
        // 当剩余空间 > 0 时，继续填充更多表项
        while ((layoutState.mInfinite || remainingSpace > 0) && layoutState.hasMore(state)) {
            ...
            layoutChunk()
            ...
        }
    }

    void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,LayoutState layoutState, LayoutChunkResult result) {
        // 获取下一个该被填充的表项视图
        View view = layoutState.next(recycler);
        ...
        addView(view);
        ...
    }

}

fill()方法会根据剩余空间来循环地调用layoutChunk()向列表中填充表项，滚动列表的场景中，剩余空间的值由滚动距离决定。

关于列表滚动时，填充和复用表项的细节分析可以点击RecyclerView 面试题 | 滚动时表项是如何被填充或回收的？

layoutChunk()中获取下一个该被填充表项方法layoutState.next()最终会触发onCreateViewHolder()和onBindViewHolder()，所以这俩方法执行的速度，即表项加载速度，也会影响列表滑动的流畅度，关于如何提高表项加载速度可以点击RecyclerView 性能优化 | 把加载表项耗时减半 (一)

scrollBy()方法会根据滚动距离，在列表滚动方向上填充额外的表项。填充完，再调用mOrientationHelper.offsetChildren()将所有表项向滚动的反方向平移：

public abstract class OrientationHelper {
    // 抽象的平移子表项
    public abstract void offsetChildren(int amount);

    public static OrientationHelper createVerticalHelper(RecyclerView.LayoutManager layoutManager) {
        return new OrientationHelper(layoutManager) {
            @Override
            public void offsetChildren(int amount) {
                // 委托给 LayoutManager 在垂直方向上平移子表项
                mLayoutManager.offsetChildrenVertical(amount);
            }
            ...
        }
}

public class RecyclerView {
    public abstract static class LayoutManager {
        public void offsetChildrenVertical(@Px int dy) {
            if (mRecyclerView != null) {
                // 委托给 RecyclerView 在垂直方向上平移子表项
                mRecyclerView.offsetChildrenVertical(dy);
            }
        }
    }

    public void offsetChildrenVertical(@Px int dy) {
        // 遍历所有子表项
        final int childCount = mChildHelper.getChildCount();
        for (int i = 0; i < childCount; i++) {
            // 在垂直方向上平移子表项
            mChildHelper.getChildAt(i).offsetTopAndBottom(dy);
        }
    }
}

经过一系列调用链，最终执行了View.offsetTopAndBottom()：

public class View {
    public void offsetTopAndBottom(int offset) {
        if (offset != 0) {
            final boolean matrixIsIdentity = hasIdentityMatrix();
            if (matrixIsIdentity) {
                if (isHardwareAccelerated()) {
                    invalidateViewProperty(false, false);
                } else {
                    final ViewParent p = mParent;
                    if (p != null && mAttachInfo != null) {
                        final Rect r = mAttachInfo.mTmpInvalRect;
                        int minTop;
                        int maxBottom;
                        int yLoc;
                        if (offset < 0) {
                            minTop = mTop + offset;
                            maxBottom = mBottom;
                            yLoc = offset;
                        } else {
                            minTop = mTop;
                            maxBottom = mBottom + offset;
                            yLoc = 0;
                        }
                        r.set(0, yLoc, mRight - mLeft, maxBottom - minTop);
                        p.invalidateChild(this, r);
                    }
                }
            } else {
                invalidateViewProperty(false, false);
            }

            // 修改 view 的顶部和底部值
            mTop += offset;
            mBottom += offset;
            mRenderNode.offsetTopAndBottom(offset);
            if (isHardwareAccelerated()) {
                invalidateViewProperty(false, false);
                invalidateParentIfNeededAndWasQuickRejected();
            } else {
                if (!matrixIsIdentity) {
                    invalidateViewProperty(false, true);
                }
                invalidateParentIfNeeded();
            }
            notifySubtreeAccessibilityStateChangedIfNeeded();
        }
    }
}

该方法会修改 View 的 mTop 和 mBottom 值，并触发轻量级的重绘。

分析至此，已经可以回到开篇的问题了：

RecyclerView 在处理 ACTION_MOVE 事件时计算出手指滑动距离，以此作为滚动位移值。

RecyclerView 根据滚动位移长度在滚动方向上填充额外的表项，然后将所有表项向滚动的反方向平移相同的位移值，以此实现滚动。

文末

感谢大家关注我，分享Android干货，交流Android技术。

对文章有何见解，或者有何技术问题，都可以在评论区一起留言讨论，都会看的哦~

Android架构师系统进阶学习路线、58万字学习笔记、教学视频免费分享地址：我的GitHub