从源码解析RecyclerView绘制流程

Recycler View的出现，无疑是令android 开发工程师兴奋了许久。不久前看ListView 源码的时候，看得晕乎乎的，滑动功能以及复用机制堆积在了同一个类里面，RecyclerView 很好的解决这种尴尬的情况。

下面先从功能上看一下各个类的功能：

RecyclerView 这个类相当于中心的管理者

LayoutManager 主要负责item 添加 ，删除，以及循环利用机制等功能

Recycler.SmoothScroller 主要是负责跟踪目标view的index 和 平滑滑动

Recycler.UpdateOp 主要负责标志view的行为，增加 删除 更新

Recycler.ViewHolder 这个类大家都很熟悉，没错他就是相当于ListView 的adapter 中的ViewHolder

Recycler.State 主要是保留RecyclerView的一些信息。

Recycler.Adapter 主要使将dataset数据与itemView 绑定在一起

Recycler.Recycler 主要是保留正在显示的View和已经废弃或者是可回收利用的view

上面是主要的类，这篇文章中，我们不涉及RecyclerView 相关的动画

入口函数是setAdapter 或者是setLayoutManager ,我们 用其中一个即可，下面是

public void setAdapter(Adapter adapter) {
        if (mAdapter != null) {
            mAdapter.unregisterAdapterDataObserver(mObserver);
        }
        // end all running animations
        if (mItemAnimator != null) {
            mItemAnimator.endAnimations();
        }
        // Since animations are ended, mLayout.children should be equal to recyclerView.children.
        // This may not be true if item animator's end does not work as expected. (e.g. not release
        // children instantly). It is safer to use mLayout's child count.
        if (mLayout != null) {
            mLayout.removeAndRecycleAllViews(mRecycler);
            mLayout.removeAndRecycleScrapInt(mRecycler, true);
        }

        final Adapter oldAdapter = mAdapter;
        mAdapter = adapter;
        if (adapter != null) {
            adapter.registerAdapterDataObserver(mObserver);
        }
        if (mLayout != null) {
            mLayout.onAdapterChanged(oldAdapter, mAdapter);
        }
        mRecycler.onAdapterChanged(oldAdapter, mAdapter);
        mState.mStructureChanged = true;
        markKnownViewsInvalid();
        requestLayout();
    }

最后requestLayout 会调用RecyclerView的onMeasure 和 onLayout() 方法

@Override
    protected void onMeasure(int widthSpec , int heightSpec) {
        if (mAdapterUpdateDuringMeasure) {
            eatRequestLayout();
            updateChildViews();
            mAdapterUpdateDuringMeasure = false;
            resumeRequestLayout(false);
        }

        if (mAdapter != null) {
            mState.mItemCount = mAdapter.getItemCount();
        }
        mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);

        final int widthSize = getMeasuredWidth();
        final int heightSize = getMeasuredHeight();

        if (mLeftGlow != null) {
            mLeftGlow.setSize(heightSize, widthSize);
        }
        if (mTopGlow != null) {
            mTopGlow.setSize(widthSize, heightSize);
        }
        if (mRightGlow != null) {
            mRightGlow.setSize(heightSize, widthSize);
        }
        if (mBottomGlow != null) {
            mBottomGlow.setSize(widthSize, heightSize);
        }
    }

mAdapterUpdateDuringMeasure 这个变量在下一篇文章中会追踪一下，我们这里就看主要的函数，下面我们来看一下，LinearLayoutManager 的 onMeasure 方法

public void onMeasure(Recycler recycler , State state , int widthSpec , int heightSpec) {
            final int widthMode = MeasureSpec.getMode(widthSpec);
            final int heightMode = MeasureSpec.getMode(heightSpec);
            final int widthSize = MeasureSpec.getSize(widthSpec);
            final int heightSize = MeasureSpec.getSize(heightSpec);

            int width = 0;
            int height = 0;

            switch (widthMode) {
                case MeasureSpec.EXACTLY:
                case MeasureSpec.AT_MOST:
                    width = widthSize;
                    break;
                case MeasureSpec.UNSPECIFIED:
                default:
                    width = getMinimumWidth();
                    break;
            }

            switch (heightMode) {
                case MeasureSpec.EXACTLY:
                case MeasureSpec.AT_MOST:
                    height = heightSize;
                    break;
                case MeasureSpec.UNSPECIFIED:
                default:
                    height = getMinimumHeight();
                    break;
            }

            setMeasuredDimension(width, height);
        }

可以看出，主要就是来设置RecyclerView的Size，那么下面来看一下RecyclerView的 Onlayout方法

@Override
    protected void onLayout(boolean changed , int l , int t , int r , int b) {
        eatRequestLayout();
        dispatchLayout();
        resumeRequestLayout(false);
        mFirstLayoutComplete = true;
    }

看一下dispatchLayout（）方法

void dispatchLayout() {
        if (mAdapter == null) {
            Log.e(TAG, "No adapter attached; skipping layout");
            return;
        }

        eatRequestLayout();

        // simple animations are a subset of advanced animations (which will cause a
        // prelayout step)
        boolean animateChangesSimple = mItemAnimator != null && mItemsAddedOrRemoved && !mItemsChanged;
        final boolean animateChangesAdvanced = ENABLE_PREDICTIVE_ANIMATIONS && animateChangesSimple && predictiveItemAnimationsEnabled();
        mItemsAddedOrRemoved = mItemsChanged = false;
        ArrayMap<View, Rect> appearingViewInitialBounds = null;
        mState.mInPreLayout = animateChangesAdvanced;
        mState.mItemCount = mAdapter.getItemCount();

        if (animateChangesSimple) {
            // Step 0: Find out where all non-removed items are, pre-layout
            mState.mPreLayoutHolderMap.clear();
            mState.mPostLayoutHolderMap.clear();
            final int count = getChildCount();
            for (int i = 0; i < count; ++i) {
                final ViewHolder holder = getChildViewHolderInt(getChildAt(i));
                final View view = holder.itemView;
                mState.mPreLayoutHolderMap.put(holder, new ItemHolderInfo(holder, view.getLeft(), view.getTop(), view.getRight(), view.getBottom(), holder.mPosition));
            }
        }
        if (animateChangesAdvanced) {

            // Step 1: run prelayout: This will use the old positions of items. The layout manager
            // is expected to layout everything, even removed items (though not to add removed
            // items back to the container). This gives the pre-layout position of APPEARING views
            // which come into existence as part of the real layout.
            mInPreLayout = true;
            final boolean didStructureChange = mState.mStructureChanged;
            mState.mStructureChanged = false;
            // temporarily disable flag because we are asking for previous layout
            mLayout.onLayoutChildren(mRecycler, mState);
            mState.mStructureChanged = didStructureChange;
            mInPreLayout = false;

            appearingViewInitialBounds = new ArrayMap<View, Rect>();
            for (int i = 0; i < getChildCount(); ++i) {
                boolean found = false;
                final View child = getChildAt(i);
                for (int j = 0; j < mState.mPreLayoutHolderMap.size(); ++j) {
                    final ViewHolder holder = mState.mPreLayoutHolderMap.keyAt(j);
                    if (holder.itemView == child) {
                        found = true;
                        continue;
                    }
                }
                if (!found) {
                    appearingViewInitialBounds.put(child, new Rect(child.getLeft(), child.getTop(), child.getRight(), child.getBottom()));
                }
            }
        }
        clearOldPositions();
        dispatchLayoutUpdates();
        mState.mItemCount = mAdapter.getItemCount();

        // Step 2: Run layout
        mState.mInPreLayout = false;
        mLayout.onLayoutChildren(mRecycler, mState);

        mState.mStructureChanged = false;
        mPendingSavedState = null;

        // onLayoutChildren may have caused client code to disable item animations; re-check
        animateChangesSimple = animateChangesSimple && mItemAnimator != null;

        if (animateChangesSimple) {
            // Step 3: Find out where things are now, post-layout
            int count = getChildCount();
            for (int i = 0; i < count; ++i) {
                final ViewHolder holder = getChildViewHolderInt(getChildAt(i));
                final View view = holder.itemView;
                mState.mPostLayoutHolderMap.put(holder, new ItemHolderInfo(holder, view.getLeft(), view.getTop(), view.getRight(), view.getBottom(), holder.mPosition));
            }

            // Step 4: Animate DISAPPEARING and REMOVED items
            final int preLayoutCount = mState.mPreLayoutHolderMap.size();
            for (int i = preLayoutCount - 1; i >= 0; i--) {
                final ViewHolder itemHolder = mState.mPreLayoutHolderMap.keyAt(i);
                if (!mState.mPostLayoutHolderMap.containsKey(itemHolder)) {
                    final ItemHolderInfo disappearingItem = mState.mPreLayoutHolderMap.valueAt(i);
                    mState.mPreLayoutHolderMap.removeAt(i);

                    final View disappearingItemView = disappearingItem.holder.itemView;
                    removeDetachedView(disappearingItemView, false);
                    mRecycler.unscrapView(disappearingItem.holder);

                    animateDisappearance(disappearingItem);
                }
            }
            // Step 5: Animate APPEARING and ADDED items
            final int postLayoutCount = mState.mPostLayoutHolderMap.size();
            if (postLayoutCount > 0) {
                for (int i = postLayoutCount - 1; i >= 0; i--) {
                    final ViewHolder itemHolder = mState.mPostLayoutHolderMap.keyAt(i);
                    final ItemHolderInfo info = mState.mPostLayoutHolderMap.valueAt(i);
                    if ((mState.mPreLayoutHolderMap.isEmpty() || !mState.mPreLayoutHolderMap.containsKey(itemHolder))) {
                        mState.mPostLayoutHolderMap.removeAt(i);
                        final Rect initialBounds = (appearingViewInitialBounds != null) ? appearingViewInitialBounds.get(itemHolder.itemView) : null;
                        animateAppearance(itemHolder, initialBounds, info.left, info.top);
                    }
                }
            }
            // Step 6: Animate PERSISTENT items
            count = mState.mPostLayoutHolderMap.size();
            for (int i = 0; i < count; ++i) {
                final ViewHolder postHolder = mState.mPostLayoutHolderMap.keyAt(i);
                final ItemHolderInfo postInfo = mState.mPostLayoutHolderMap.valueAt(i);
                final ItemHolderInfo preInfo = mState.mPreLayoutHolderMap.get(postHolder);
                if (preInfo != null && postInfo != null) {
                    if (preInfo.left != postInfo.left || preInfo.top != postInfo.top) {
                        postHolder.setIsRecyclable(false);
                        if (DEBUG) {
                            Log.d(TAG, "PERSISTENT: " + postHolder + " with view " + postHolder.itemView);
                        }
                        if (mItemAnimator.animateMove(postHolder, preInfo.left, preInfo.top, postInfo.left, postInfo.top)) {
                            postAnimationRunner();
                        }
                    }
                }
            }
        }
        resumeRequestLayout(false);
        mLayout.removeAndRecycleScrapInt(mRecycler, !animateChangesAdvanced);
        mState.mPreviousLayoutItemCount = mState.mItemCount;
        mState.mDeletedInvisibleItemCountSincePreviousLayout = 0;
    }

这段代码看起来很多，很多都是有关动画，今天我们的重点不是动画，所以找出其中的关键代码，

// Step 2: Run layout

mState.mInPreLayout = false;

mLayout.onLayoutChildren(mRecycler, mState);

主要的layout 部分，我们来看一下LayoutManager的onLayoutChildren 方法，

public void onLayoutChildren(RecyclerView.Recycler recycler , RecyclerView.State state) {
        // layout algorithm:
        // 1) by checking children and other variables, find an anchor coordinate and an anchor
        // item position.
        // 2) fill towards start, stacking from bottom
        // 3) fill towards end, stacking from top
        // 4) scroll to fulfill requirements like stack from bottom.
        // create render state
        if (DEBUG) {
            Log.d(TAG, "is pre layout:" + state.isPreLayout());
        }
        if (mPendingSavedState != null) {
            setOrientation(mPendingSavedState.mOrientation);
            setReverseLayout(mPendingSavedState.mReverseLayout);
            setStackFromEnd(mPendingSavedState.mStackFromEnd);
            mPendingScrollPosition = mPendingSavedState.mAnchorPosition;
        }

        ensureRenderState();
        // resolve layout direction
        resolveShouldLayoutReverse();

        // validate scroll position if exists
        if (mPendingScrollPosition != RecyclerView.NO_POSITION) {
            // validate it
            if (mPendingScrollPosition < 0 || mPendingScrollPosition >= state.getItemCount()) {
                mPendingScrollPosition = RecyclerView.NO_POSITION;
                mPendingScrollPositionOffset = INVALID_OFFSET;
                if (DEBUG) {
                    Log.e(TAG, "ignoring invalid scroll position " + mPendingScrollPosition);
                }
            }
        }
        // this value might be updated if there is a target scroll position without an offset
        boolean layoutFromEnd = mShouldReverseLayout ^ mStackFromEnd;

        final boolean stackFromEndChanged = mLastStackFromEnd != mStackFromEnd;

        int anchorCoordinate, anchorItemPosition;
        if (mPendingScrollPosition != RecyclerView.NO_POSITION) {
            // if child is visible, try to make it a reference child and ensure it is fully visible.
            // if child is not visible, align it depending on its virtual position.
            anchorItemPosition = mPendingScrollPosition;
            if (mPendingSavedState != null) {
                // Anchor offset depends on how that child was laid out. Here, we update it
                // according to our current view bounds
                layoutFromEnd = mPendingSavedState.mAnchorLayoutFromEnd;
                if (layoutFromEnd) {
                    anchorCoordinate = mOrientationHelper.getEndAfterPadding() - mPendingSavedState.mAnchorOffset;
                }
                else {
                    anchorCoordinate = mOrientationHelper.getStartAfterPadding() + mPendingSavedState.mAnchorOffset;
                }
            }
            else if (mPendingScrollPositionOffset == INVALID_OFFSET) {
                final View child = findViewByPosition(mPendingScrollPosition);
                if (child != null) {
                    final int startGap = mOrientationHelper.getDecoratedStart(child) - mOrientationHelper.getStartAfterPadding();
                    final int endGap = mOrientationHelper.getEndAfterPadding() - mOrientationHelper.getDecoratedEnd(child);
                    final int childSize = mOrientationHelper.getDecoratedMeasurement(child);
                    if (childSize > mOrientationHelper.getTotalSpace()) {
                        // item does not fit. fix depending on layout direction
                        anchorCoordinate = layoutFromEnd ? mOrientationHelper.getEndAfterPadding() : mOrientationHelper.getStartAfterPadding();
                    }
                    else if (startGap < 0) {
                        anchorCoordinate = mOrientationHelper.getStartAfterPadding();
                        layoutFromEnd = false;
                    }
                    else if (endGap < 0) {
                        anchorCoordinate = mOrientationHelper.getEndAfterPadding();
                        layoutFromEnd = true;
                    }
                    else {
                        anchorCoordinate = layoutFromEnd ? mOrientationHelper.getDecoratedEnd(child) : mOrientationHelper.getDecoratedStart(child);
                    }
                }
                else { // item is not visible.
                    if (getChildCount() > 0) {
                        // get position of any child, does not matter
                        final int pos = getPosition(getChildAt(0));
                        if (mPendingScrollPosition < pos == mShouldReverseLayout) {
                            anchorCoordinate = mOrientationHelper.getEndAfterPadding();
                            layoutFromEnd = true;
                        }
                        else {
                            anchorCoordinate = mOrientationHelper.getStartAfterPadding();
                            layoutFromEnd = false;
                        }
                    }
                    else {
                        anchorCoordinate = layoutFromEnd ? mOrientationHelper.getEndAfterPadding() : mOrientationHelper.getStartAfterPadding();
                    }
                }
            }
            else {
                // override layout from end values for consistency
                if (mShouldReverseLayout) {
                    anchorCoordinate = mOrientationHelper.getEndAfterPadding() - mPendingScrollPositionOffset;
                    layoutFromEnd = true;
                }
                else {
                    anchorCoordinate = mOrientationHelper.getStartAfterPadding() + mPendingScrollPositionOffset;
                    layoutFromEnd = false;
                }
            }
        }
        else if (getChildCount() > 0 && !stackFromEndChanged) {
            if (layoutFromEnd) {
                final View referenceChild = getChildClosestToEnd();
                anchorCoordinate = mOrientationHelper.getDecoratedEnd(referenceChild);
                anchorItemPosition = getPosition(referenceChild);
            }
            else {
                final View referenceChild = getChildClosestToStart();
                anchorCoordinate = mOrientationHelper.getDecoratedStart(referenceChild);
                anchorItemPosition = getPosition(referenceChild);
            }
        }
        else {
            anchorCoordinate = layoutFromEnd ? mOrientationHelper.getEndAfterPadding() : mOrientationHelper.getStartAfterPadding();
            anchorItemPosition = mStackFromEnd ? state.getItemCount() - 1 : 0;
        }

        detachAndScrapAttachedViews(recycler);
        final int extraForStart;
        final int extraForEnd;
        final int extra = getExtraLayoutSpace(state);
        final boolean before = state.getTargetScrollPosition() < anchorItemPosition;
        if (before == mShouldReverseLayout) {
            extraForEnd = extra;
            extraForStart = 0;
        }
        else {
            extraForStart = extra;
            extraForEnd = 0;
        }
        // first fill towards start
        updateRenderStateToFillStart(anchorItemPosition, anchorCoordinate);
        mRenderState.mExtra = extraForStart;
        if (!layoutFromEnd) {
            mRenderState.mCurrentPosition += mRenderState.mItemDirection;
        }
        fill(recycler, mRenderState, state, false);
        int startOffset = mRenderState.mOffset;
        // fill towards end
        updateRenderStateToFillEnd(anchorItemPosition, anchorCoordinate);
        mRenderState.mExtra = extraForEnd;
        if (layoutFromEnd) {
            mRenderState.mCurrentPosition += mRenderState.mItemDirection;
        }
        fill(recycler, mRenderState, state, false);
        int endOffset = mRenderState.mOffset;
        // changes may cause gaps on the UI, try to fix them.
        if (getChildCount() > 0) {
            // because layout from end may be changed by scroll to position
            // we re-calculate it.
            // find which side we should check for gaps.
            if (mShouldReverseLayout ^ mStackFromEnd) {
                int fixOffset = fixLayoutEndGap(endOffset, recycler, state, true);
                startOffset += fixOffset;
                endOffset += fixOffset;
                fixOffset = fixLayoutStartGap(startOffset, recycler, state, false);
                startOffset += fixOffset;
                endOffset += fixOffset;
            }
            else {
                int fixOffset = fixLayoutStartGap(startOffset, recycler, state, true);
                startOffset += fixOffset;
                endOffset += fixOffset;
                fixOffset = fixLayoutEndGap(endOffset, recycler, state, false);
                startOffset += fixOffset;
                endOffset += fixOffset;
            }
        }

        // If there are scrap children that we did not layout, we need to find where they did go
        // and layout them accordingly so that animations can work as expected.
        // This case may happen if new views are added or an existing view expands and pushes
        // another view out of bounds.
        if (getChildCount() > 0 && !state.isPreLayout() && supportsPredictiveItemAnimations()) {
            // to make the logic simpler, we calculate the size of children and call fill.
            int scrapExtraStart = 0, scrapExtraEnd = 0;
            final List<RecyclerView.ViewHolder> scrapList = recycler.getScrapList();
            final int scrapSize = scrapList.size();
            final int firstChildPos = getPosition(getChildAt(0));
            for (int i = 0; i < scrapSize; i++) {
                final RecyclerView.ViewHolder scrap = scrapList.get(i);
                final int position = scrap.getPosition();
                final int direction = position < firstChildPos != mShouldReverseLayout ? RenderState.LAYOUT_START : RenderState.LAYOUT_END;
                if (direction == RenderState.LAYOUT_START) {
                    scrapExtraStart += mOrientationHelper.getDecoratedMeasurement(scrap.itemView);
                }
                else {
                    scrapExtraEnd += mOrientationHelper.getDecoratedMeasurement(scrap.itemView);
                }
            }

            if (DEBUG) {
                Log.d(TAG, "for unused scrap, decided to add " + scrapExtraStart + " towards start and " + scrapExtraEnd + " towards end");
            }
            mRenderState.mScrapList = scrapList;
            if (scrapExtraStart > 0) {
                final View anchor = getChildClosestToStart();
                updateRenderStateToFillStart(getPosition(anchor), startOffset);
                mRenderState.mExtra = scrapExtraStart;
                mRenderState.mAvailable = 0;
                mRenderState.mCurrentPosition += mShouldReverseLayout ? 1 : -1;
                fill(recycler, mRenderState, state, false);
            }

            if (scrapExtraEnd > 0) {
                final View anchor = getChildClosestToEnd();
                updateRenderStateToFillEnd(getPosition(anchor), endOffset);
                mRenderState.mExtra = scrapExtraEnd;
                mRenderState.mAvailable = 0;
                mRenderState.mCurrentPosition += mShouldReverseLayout ? -1 : 1;
                fill(recycler, mRenderState, state, false);
            }
            mRenderState.mScrapList = null;
        }

        mPendingScrollPosition = RecyclerView.NO_POSITION;
        mPendingScrollPositionOffset = INVALID_OFFSET;
        mLastStackFromEnd = mStackFromEnd;
        mPendingSavedState = null; // we don't need this anymore

        if (DEBUG) {
            validateChildOrder();
        }
    }

这段代码已经在开始的时候标注了逻辑

// layout algorithm:
        // 1) by checking children and other variables, find an anchor coordinate and an anchor
        // item position.
        // 2) fill towards start, stacking from bottom
        // 3) fill towards end, stacking from top
        // 4) scroll to fulfill requirements like stack from bottom.

而2 ，3 就是关键的地方 ，这里包含循环利用的逻辑，那我们接下来就看这段代码。

/**
     * The magic functions :). Fills the given layout, defined by the renderState. This is fairly independent from the
     * rest of the {@link android.support.v7.widget.LinearLayoutManager} and with little change, can be made publicly
     * available as a helper class.
     * 
     * @param recycler Current recycler that is attached to RecyclerView
     * @param renderState Configuration on how we should fill out the available space.
     * @param state Context passed by the RecyclerView to control scroll steps.
     * @param stopOnFocusable If true, filling stops in the first focusable new child
     * @return Number of pixels that it added. Useful for scoll functions.
     */
    private int fill(RecyclerView.Recycler recycler , RenderState renderState , RecyclerView.State state , boolean stopOnFocusable) {
        // max offset we should set is mFastScroll + available
        final int start = renderState.mAvailable;
        if (renderState.mScrollingOffset != RenderState.SCOLLING_OFFSET_NaN) {
            // TODO ugly bug fix. should not happen
            if (renderState.mAvailable < 0) {
                renderState.mScrollingOffset += renderState.mAvailable;
            }
            recycleByRenderState(recycler, renderState);
        }
        int remainingSpace = renderState.mAvailable + renderState.mExtra;
        while (remainingSpace > 0 && renderState.hasMore(state)) {
            final View view = renderState.next(recycler);
            if (view == null) {
                if (DEBUG) {
                    if (renderState.mScrapList == null) {
                        throw new RuntimeException("received null view when unexpected");
                    }
                }
                // if we are laying out views in scrap, this may return null which means there is
                // no more items to layout.
                break;
            }

            final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) view.getLayoutParams();
            if (!params.isItemRemoved() && mRenderState.mScrapList == null) {
                if (mShouldReverseLayout == (renderState.mLayoutDirection == RenderState.LAYOUT_START)) {
                    addView(view);
                }
                else {
                    addView(view, 0);
                }
            }
            measureChildWithMargins(view, 0, 0);
            final int consumed = mOrientationHelper.getDecoratedMeasurement(view);
            int left, top, right, bottom;
            if (mOrientation == VERTICAL) {
                if (isLayoutRTL()) {
                    right = getWidth() - getPaddingRight();
                    left = right - mOrientationHelper.getDecoratedMeasurementInOther(view);
                }
                else {
                    left = getPaddingLeft();
                    right = left + mOrientationHelper.getDecoratedMeasurementInOther(view);
                }
                if (renderState.mLayoutDirection == RenderState.LAYOUT_START) {
                    bottom = renderState.mOffset;
                    top = renderState.mOffset - consumed;
                }
                else {
                    top = renderState.mOffset;
                    bottom = renderState.mOffset + consumed;
                }
            }
            else {
                top = getPaddingTop();
                bottom = top + mOrientationHelper.getDecoratedMeasurementInOther(view);

                if (renderState.mLayoutDirection == RenderState.LAYOUT_START) {
                    right = renderState.mOffset;
                    left = renderState.mOffset - consumed;
                }
                else {
                    left = renderState.mOffset;
                    right = renderState.mOffset + consumed;
                }
            }
            // We calculate everything with View's bounding box (which includes decor and margins)
            // To calculate correct layout position, we subtract margins.
            layoutDecorated(view, left + params.leftMargin, top + params.topMargin, right - params.rightMargin, bottom - params.bottomMargin);
            if (DEBUG) {
                Log.d(TAG, "laid out child at position " + getPosition(view) + ", with l:" + (left + params.leftMargin) + ", t:"
                        + (top + params.topMargin) + ", r:" + (right - params.rightMargin) + ", b:" + (bottom - params.bottomMargin));
            }
            renderState.mOffset += consumed * renderState.mLayoutDirection;

            if (!params.isItemRemoved()) {
                renderState.mAvailable -= consumed;
                // we keep a separate remaining space because mAvailable is important for recycling
                remainingSpace -= consumed;
            }

            if (renderState.mScrollingOffset != RenderState.SCOLLING_OFFSET_NaN) {
                renderState.mScrollingOffset += consumed;
                if (renderState.mAvailable < 0) {
                    renderState.mScrollingOffset += renderState.mAvailable;
                }
                recycleByRenderState(recycler, renderState);
            }
            if (stopOnFocusable && view.isFocusable()) {
                break;
            }

            if (state != null && state.getTargetScrollPosition() == getPosition(view)) {
                break;
            }
        }
        if (DEBUG) {
            validateChildOrder();
        }
        return start - renderState.mAvailable;
    }

在fill 之前，先回收一下无用的数据（超出屏幕的itemView），然后使用 while (remainingSpace > 0 && renderState.hasMore(state)) 循环，添加数据直至超出屏幕。

这里主要就是循环复用机制 ，假如之前阅读过listview 循环复用机制，这里和listview是类似的。

这就是RecyclerView 的基础绘画流程