RecycleView源码分析(四)LayoutManager源码分析

上篇测绘流程的核心逻辑传递到LayoutManager中,本篇我们会详细分析LinearLayoutManager的源码,分析完成这个测绘流程,并且为以后自己实现LayoutManager作准备。

几个比较重要的方法。

1. generateDefaultLayoutParams()

LinearLayoutManager继承了RecyclerView.LayoutManager,RecyclerView.LayoutManager是一个抽象类。只有一个抽象方法generateDefaultLayoutParams是必须实现的。

   public abstract LayoutParams generateDefaultLayoutParams();

这个方法是设置每个item默认的LayoutParams的,我们必须指定这个方法的实现。
LinearLayoutManager的实现比较简单。横竖向都是自适应的。

    @Override
    public RecyclerView.LayoutParams generateDefaultLayoutParams() {
        return new RecyclerView.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
                ViewGroup.LayoutParams.WRAP_CONTENT);
    }

2. onLayoutChildren

在分析RecycleView的测绘流程的时候,控件的测绘主要是调用了LayoutManager的onLayoutChildren方法,这是一个入口,内部完成了各个item的measure和layout,实现第一次item的填充。里面有两个参数,第一个就是RecycleView的复用item的重头戏控件Recycler,用于内部回收复用的方式获取view。第二个是保存各种测绘信息的集中单元。

    public void onLayoutChildren(Recycler recycler, State state) {
            Log.e(TAG, "You must override onLayoutChildren(Recycler recycler, State state) ");
        }

3. onMeasure()和isAutoMeasureEnabled()

onMeasure()和isAutoMeasureEnabled()上一篇也说过了,不要同时实现它们的逻辑,两个方法重写是互斥的。isAutoMeasureEnabled()是系统提供的自动测绘,onMeasure()如果重写我们自己的测量流程。如果重写isAutoMeasureEnabled()返回true就不应该重写onMeasure()。如果没有重写isAutoMeasureEnabled(),默认是返回false,这时应该重写onMeasure()。

4. canScrollHorizontally()、canScrollVertically()、scrollHorizontallyBy()、scrollVerticallyBy()

滑动系列方法,前两个是是否可以水平竖直方向进行滑动。后两个是滑动过程中进行处理的方法。只有在前两个方法中放开,也就是返回true,RecycleView才会把touchEvent下放到LayoutManager里面。后两个方法随着滑动不但要实现view的回收和复用,还要进行新view的填充,和滚动出屏幕的回收。

如果要自己实现一个LayoutManager(后面的章节我们会自己实现一个LayoutManager),我们重写上面的几个方法就可以完成了。所以在分析系统的LinearLayoutManager时,我们着重分析上面的几个方法,即可了解大部分功能。

LayoutManager运行的整体思路

  1. 通过isAutoMeasureEnabled()判断是否使用自动测量,没有开启那么就靠LayoutManager#onMeasure()进行测量,这时我们就要自己去实现了。如果开启了,就走系统的dispatchLayoutStep系列方法,这时我们不需要自定义onMeasure()。
  2. 通过onLayoutChildren完成第一次的填充和后面的notify刷新,内部会通过计算可用面积,只填充显示区域下的各个item。这时第一屏的效果已经完成了。
  3. 我们滑动RecycleView,通过canScrollHorizontally()、canScrollVertically()、scrollHorizontallyBy()、scrollVerticallyBy()一些列方法,配置滑动下的反应。完成动态的填充,和不可见item的回收,新item的复用。
    LayoutManager内分工比较明确,onLayoutChildren负责整屏的填充,scrollHorizontallyBy()、scrollVerticallyBy()处理滑动过程中的填充。两种填充方式都有了。

LayoutManager集成了RV的滑动处理和测量布局处理。实际上底层就是测量布局的处理,因为滑动过程中也需要重新进行测量和布局。

本篇只分析onLayoutChildren整屏填充部分,下一篇分析滑动部分。

onLayoutChildren整屏填充

前置条件:state.isPreLayout()为false,上文讲了和是否完成第一次测量和是否有动画相关。所以这个条件判断为true下的代码会在动画篇章讲解。

onLayoutChildren的代码比较多,但是从整体看,只有两个步骤

  1. 确认锚点信息
  2. 根据锚点信息进行测量布局

确认锚点信息步骤

    //处理SavedState数据
    if (mPendingSavedState != null || mPendingScrollPosition != RecyclerView.NO_POSITION) {
            if (state.getItemCount() == 0) {
                removeAndRecycleAllViews(recycler);
                return;
            }
        }
        if (mPendingSavedState != null && mPendingSavedState.hasValidAnchor()) {
            mPendingScrollPosition = mPendingSavedState.mAnchorPosition;
        }

        ensureLayoutState();
        mLayoutState.mRecycle = false;
        resolveShouldLayoutReverse();

        final View focused = getFocusedChild();
        if (!mAnchorInfo.mValid || mPendingScrollPosition != RecyclerView.NO_POSITION
                || mPendingSavedState != null) {
            mAnchorInfo.reset();
            mAnchorInfo.mLayoutFromEnd = mShouldReverseLayout ^ mStackFromEnd;
            // 初始化锚点信息
            updateAnchorInfoForLayout(recycler, state, mAnchorInfo);
            mAnchorInfo.mValid = true;
        } else if (focused != null && (mOrientationHelper.getDecoratedStart(focused)
                        >= mOrientationHelper.getEndAfterPadding()
                || mOrientationHelper.getDecoratedEnd(focused)
                <= mOrientationHelper.getStartAfterPadding())) {
            mAnchorInfo.assignFromViewAndKeepVisibleRect(focused, getPosition(focused));
        }

我们依次看下需要分析的点

  1. mPendingSavedState和mPendingScrollPosition
    mPendingSavedStates是缓存恢复的数据,通过它可以恢复到之前的状态。通常发生在销毁重建的过程。mPendingScrollPosition是通过scrollToPosition设置的。也就是外部要求滚动到的位置。没有设置默认值就是RecyclerView.NO_POSITION。

  2. resolveShouldLayoutReverse()
    这个方法处理了布局处理的方向,从正方向或者反方向开始填充。如果是水平方向并且是从右往左的阅读方向(比如阿拉伯风格)默认就是开启了反转方向。mShouldReverseLayout为true则是反方向绘制,从底部或者右侧开始绘制。false则相反。

    private void resolveShouldLayoutReverse() {
        // A == B is the same result, but we rather keep it readable
        if (mOrientation == VERTICAL || !isLayoutRTL()) {
            mShouldReverseLayout = mReverseLayout;
        } else {
            //水平并且从右到左的方向,默认开启反转布局
            mShouldReverseLayout = !mReverseLayout;
        }
    }
    
  3. mLayoutFromEnd

    首先是 mAnchorInfo.mLayoutFromEnd的设置。只有mShouldReverseLayout和 mStackFromEnd不同时,才为true。
    mStackFromEnd是通过setStackFromEnd设置的,表示是否初始定位是否在数据末端开始,如果为true那么就从最后一条数据开始显示。 mAnchorInfo.mLayoutFromEnd为true,形象的表示就是是在反方向开始进行布局。必入垂直方向,就是屏幕下端开始布局。

  1. updateAnchorInfoForLayout锚点配置
    锚点配置在updateAnchorInfoForLayout(recycler, state, mAnchorInfo)方法中。
    首先看下AnchorInfo,这个类就是存储锚点的信息,看下内部的具体细节。

    class AnchorInfo {
        OrientationHelper mOrientationHelper;
        int mPosition;
        int mCoordinate;
        boolean mLayoutFromEnd;
        boolean mValid;
       }
    
    属性 意义
    mOrientationHelper 是一个帮助类,里面有很多测量布局帮助方法。
    mPosition 就是锚点的锚,具体就是屏幕上第一个position
    mCoordinate 表示绘制起点,初始化就是顶部底部的padding
    mLayoutFromEnd 表示是否从定位到屏幕底部
    mValid 锚点是否可用

    updateAnchorInfoForLayout方法内部具体设置实现了锚点的配置。

    private void updateAnchorInfoForLayout(RecyclerView.Recycler recycler, RecyclerView.State state,
            AnchorInfo anchorInfo) {
        if (updateAnchorFromPendingData(state, anchorInfo)) {
            return;
        }
    
        if (updateAnchorFromChildren(recycler, state, anchorInfo)) {
            return;
        }
        //设置默认的起点,也就是上下边距
        anchorInfo.assignCoordinateFromPadding();
        //默认的锚点位置如果是从顶部布局就是第一个数据,从底部就是最后一个数据。
        anchorInfo.mPosition = mStackFromEnd ? state.getItemCount() - 1 : 0;
    }
    
    void assignCoordinateFromPadding() {
            mCoordinate = mLayoutFromEnd
                    ? mOrientationHelper.getEndAfterPadding()
                    : mOrientationHelper.getStartAfterPadding();
    }
    

    大体结构:可以看出先通过peding的数据设置锚点,内部处理了mPendingScrollPosition的数据给锚点。再通过各个children设置锚点。最后都没有成功配置,设置默认的锚点。

    1. 通过mPending数据设置锚点
    private boolean updateAnchorFromPendingData(RecyclerView.State state, AnchorInfo anchorInfo) {
        if (state.isPreLayout() || mPendingScrollPosition == RecyclerView.NO_POSITION) {
            return false;
        }
       
        if (mPendingScrollPosition < 0 || mPendingScrollPosition >= state.getItemCount()) {
             // mPendingScrollPosition判断是否合法
            mPendingScrollPosition = RecyclerView.NO_POSITION;
            mPendingScrollPositionOffset = INVALID_OFFSET;
            return false;
        }
        anchorInfo.mPosition = mPendingScrollPosition;
        if (mPendingSavedState != null && mPendingSavedState.hasValidAnchor()) {
            //处理 mPendingSavedState的数据
            anchorInfo.mLayoutFromEnd = mPendingSavedState.mAnchorLayoutFromEnd;
            if (anchorInfo.mLayoutFromEnd) {
                anchorInfo.mCoordinate = mOrientationHelper.getEndAfterPadding()
                        - mPendingSavedState.mAnchorOffset;
            } else {
                anchorInfo.mCoordinate = mOrientationHelper.getStartAfterPadding()
                        + mPendingSavedState.mAnchorOffset;
            }
            return true;
        }
    
        if (mPendingScrollPositionOffset == INVALID_OFFSET) {
            //处理没有设置offset的情况
            View child = findViewByPosition(mPendingScrollPosition);
            if (child != null) {
                final int childSize = mOrientationHelper.getDecoratedMeasurement(child);
                if (childSize > mOrientationHelper.getTotalSpace()) {
                    // item does not fit. fix depending on layout direction
                    anchorInfo.assignCoordinateFromPadding();
                    return true;
                }
                final int startGap = mOrientationHelper.getDecoratedStart(child)
                        - mOrientationHelper.getStartAfterPadding();
                if (startGap < 0) {
                    anchorInfo.mCoordinate = mOrientationHelper.getStartAfterPadding();
                    anchorInfo.mLayoutFromEnd = false;
                    return true;
                }
                final int endGap = mOrientationHelper.getEndAfterPadding()
                        - mOrientationHelper.getDecoratedEnd(child);
                if (endGap < 0) {
                    anchorInfo.mCoordinate = mOrientationHelper.getEndAfterPadding();
                    anchorInfo.mLayoutFromEnd = true;
                    return true;
                }
                anchorInfo.mCoordinate = anchorInfo.mLayoutFromEnd
                        ? (mOrientationHelper.getDecoratedEnd(child) + mOrientationHelper
                        .getTotalSpaceChange())
                        : mOrientationHelper.getDecoratedStart(child);
            } else { // item is not visible.
                if (getChildCount() > 0) {
                    // get position of any child, does not matter
                    int pos = getPosition(getChildAt(0));
                    anchorInfo.mLayoutFromEnd = mPendingScrollPosition < pos
                            == mShouldReverseLayout;
                }
                anchorInfo.assignCoordinateFromPadding();
            }
            return true;
        }
        // override layout from end values for consistency
        anchorInfo.mLayoutFromEnd = mShouldReverseLayout;
        // if this changes, we should update prepareForDrop as well
        if (mShouldReverseLayout) {
            anchorInfo.mCoordinate = mOrientationHelper.getEndAfterPadding()
                    - mPendingScrollPositionOffset;
        } else {
            anchorInfo.mCoordinate = mOrientationHelper.getStartAfterPadding()
                    + mPendingScrollPositionOffset;
        }
        return true;
    }
    

    这个方法主要处理通过scrollToPositionWithOffset(int position, int offset)方法传入的数据的处理。也就是指定滚动位置和offset的处理点。具体逻辑比较清晰,这里就不细讲了。

    1. 通过children数据设置锚点
      这里主要通过已有的childer,根据绘制从底部还是顶部,找到一个最接近的锚点。应用于notify系列方法进行刷新数据。因为当前已经有children了,所以直接找屏幕上显示的第一个view作为锚,以保存当前滑动的位置。我们自己定义的LayoutManager,当弹起软键盘时,如果没有通过children数据设置锚点。因为RecyclerView重新绘制,会回到初始进行刷新,而不是当前已经滑动到的位置。

    2. 默认锚点
      上面两个步骤都没有确认锚点,那么就会使用默认的锚点。

       anchorInfo.assignCoordinateFromPadding();
       anchorInfo.mPosition = mStackFromEnd ? state.getItemCount() - 1 : 0;
    

    短短的两行代码,第一行从方法名可以看出是设置绘制起点为padding的部分,这里也说明了RecycleView的padding属性怎么生效的。第二行设置了锚点的位置,如果setStackFromEnd设置了数据显示方向,如果是屏幕底部(true)第一屏显示的就是最后一条数据。如果屏幕顶部(false 默认)显示的就是第一条数据。

经过上面三个步骤,锚点就确定完了。也就是起始绘制的数据index就确认了。接下来就需要确认绘制数据和调用fill进行填充了。

确认绘制数据

确认绘制数据主要是通过updateLayoutStateToFillStart(mAnchorInfo)和updateLayoutStateToFillEnd(mAnchorInfo)两个方法进行的。

        detachAndScrapAttachedViews(recycler);
        mLayoutState.mInfinite = resolveIsInfinite();
        mLayoutState.mIsPreLayout = state.isPreLayout();
        mLayoutState.mNoRecycleSpace = 0;
        if (mAnchorInfo.mLayoutFromEnd) {
            // fill towards start
            updateLayoutStateToFillStart(mAnchorInfo);
            mLayoutState.mExtraFillSpace = extraForStart;
            fill(recycler, mLayoutState, state, false);
            startOffset = mLayoutState.mOffset;
            final int firstElement = mLayoutState.mCurrentPosition;
            if (mLayoutState.mAvailable > 0) {
                extraForEnd += mLayoutState.mAvailable;
            }
            // fill towards end
            updateLayoutStateToFillEnd(mAnchorInfo);
            mLayoutState.mExtraFillSpace = extraForEnd;
            mLayoutState.mCurrentPosition += mLayoutState.mItemDirection;
            fill(recycler, mLayoutState, state, false);
            endOffset = mLayoutState.mOffset;

            if (mLayoutState.mAvailable > 0) {
                // end could not consume all. add more items towards start
                extraForStart = mLayoutState.mAvailable;
                updateLayoutStateToFillStart(firstElement, startOffset);
                mLayoutState.mExtraFillSpace = extraForStart;
                fill(recycler, mLayoutState, state, false);
                startOffset = mLayoutState.mOffset;
            }
        } else {
            // fill towards end
            updateLayoutStateToFillEnd(mAnchorInfo);
            mLayoutState.mExtraFillSpace = extraForEnd;
            fill(recycler, mLayoutState, state, false);
            endOffset = mLayoutState.mOffset;
            final int lastElement = mLayoutState.mCurrentPosition;
            if (mLayoutState.mAvailable > 0) {
                extraForStart += mLayoutState.mAvailable;
            }
            // fill towards start
            updateLayoutStateToFillStart(mAnchorInfo);
            mLayoutState.mExtraFillSpace = extraForStart;
            mLayoutState.mCurrentPosition += mLayoutState.mItemDirection;
            fill(recycler, mLayoutState, state, false);
            startOffset = mLayoutState.mOffset;

            if (mLayoutState.mAvailable > 0) {
                extraForEnd = mLayoutState.mAvailable;
                // start could not consume all it should. add more items towards end
                updateLayoutStateToFillEnd(lastElement, endOffset);
                mLayoutState.mExtraFillSpace = extraForEnd;
                fill(recycler, mLayoutState, state, false);
                endOffset = mLayoutState.mOffset;
            }
        }

     
        if (!state.isPreLayout()) {
            mOrientationHelper.onLayoutComplete();
        } else {
            mAnchorInfo.reset();
        }
        mLastStackFromEnd = mStackFromEnd;
  1. 通过detachAndScrapAttachedViews方法detach所有的child。可以理解为detach掉所有add的字View,恢复到了一个无字View的初始状态,在后面的布局中统一逻辑进行新的布局。这部分和回收有关,后面的章节讲回收复用会详细讲这部分。包括detach和remove的区别。
  2. 通过mLayoutFromEnd判断填充的方向,上面也提到过这个变量。他是从mAnchorInfo.mLayoutFromEnd = mShouldReverseLayout ^ mStackFromEnd设置的。如果mLayoutFromEnd为true就是代表从末端开始填充,垂直布局就是从底部,水平布局就是从右侧。
    如果从末端布局,先通过updateLayoutStateToFillStart配置,调用fill方法往反方向初始段布局,再通过updateLayoutStateToFillEnd配置往末端布局,同样通过fill进行末端填充。从首段进行填充刚好相反。
    为什么会是这样的设计呢?而不是直接从底部开始
    我们通过反证法验证这个问题,如果是从末端填充,我们这里通过垂直方向,也就是从屏幕底部开始布局举例。
    1D37112C-68F4-4306-AA3B-65E7C0EC0357.png

    在这种情况,我们就需要确定距离屏幕顶部有几个可以填充的,才可以确定自己的位置,因为顶部填充不满剩余的空间,我们直接从底部绘制是错误,会开天窗。
    B7438AE2-9773-4B0D-9FBF-7C7AC7470356.png

    所以通过上面的分析我们知道为什么要这么设计了。相反,从首部开始填充的逻辑先填充下侧,因为这时第一个位置肯定是在屏幕最顶部的。填充完下侧再填充上侧的,这时没有地方填充了,但是如果我们通过scrollToPositionWithOffset方法设置offset往上侧填充就可以有空间继续了。

调用fill进行填充

确认完锚点和绘制数据后,接下来就是重头戏了,通过fill进行填充,这是一个很重要的方法

fill(recycler, mLayoutState, state, false)

通过他的参数可以看出,recycler是RecycleView提供复用回收的统一控件。mLayoutState, state包含了绘制的各种参数,包括起始点、方向、可用空间等。所以这个方法大体的结构,通过recycler拿到待布局的view,通过参数进行填充。我们看下具体的代码。

    int fill(RecyclerView.Recycler recycler, LayoutState layoutState,
            RecyclerView.State state, boolean stopOnFocusable) {
        // max offset we should set is mFastScroll + available
        final int start = layoutState.mAvailable;
        if (layoutState.mScrollingOffset != LayoutState.SCROLLING_OFFSET_NaN) {
        //如果产生了滑动
            if (layoutState.mAvailable < 0) {
                layoutState.mScrollingOffset += layoutState.mAvailable;
            }
            // 统一进行回收
            recycleByLayoutState(recycler, layoutState);
        }
        int remainingSpace = layoutState.mAvailable + layoutState.mExtraFillSpace;
        LayoutChunkResult layoutChunkResult = mLayoutChunkResult;
        while ((layoutState.mInfinite || remainingSpace > 0) && layoutState.hasMore(state)) {
            
            layoutChunkResult.resetInternal();
            if (RecyclerView.VERBOSE_TRACING) {
                TraceCompat.beginSection("LLM LayoutChunk");
            }
            // 根据可用空间进行布局
            layoutChunk(recycler, state, layoutState, layoutChunkResult);
            if (RecyclerView.VERBOSE_TRACING) {
                TraceCompat.endSection();
            }
            if (layoutChunkResult.mFinished) {
                break;
            }
            layoutState.mOffset += layoutChunkResult.mConsumed * layoutState.mLayoutDirection;
            if (!layoutChunkResult.mIgnoreConsumed || layoutState.mScrapList != null
                    || !state.isPreLayout()) {
                 // 布局了新的view,减少可用空间
                layoutState.mAvailable -= layoutChunkResult.mConsumed;
                // we keep a separate remaining space because mAvailable is important for recycling
                remainingSpace -= layoutChunkResult.mConsumed;
            }

            if (layoutState.mScrollingOffset != LayoutState.SCROLLING_OFFSET_NaN) {
                layoutState.mScrollingOffset += layoutChunkResult.mConsumed;
                if (layoutState.mAvailable < 0) {
                    layoutState.mScrollingOffset += layoutState.mAvailable;
                }
                recycleByLayoutState(recycler, layoutState);
            }
            if (stopOnFocusable && layoutChunkResult.mFocusable) {
                break;
            }
        }
        if (DEBUG) {
            validateChildOrder();
        }
        return start - layoutState.mAvailable;
    }

逻辑比较简单

  1. 首先进行回收,这部分是进行滑动后的回收工作,下一章会讲滑动的部分。
  2. 算出remainingSpace,也就是可用的布局空间,while内部的判断也是通过remainingSpace判断是否有空间可以继续填充。消耗remainingSpace是通过layoutChunkResult这个变量。layoutChunkResult使用layoutChunk方法进行赋值的,所以主要的布局逻辑在layoutChunk中,这个也是一个很重要的方法。内部完成了指定postion的view测量和布局。

我们看下具体的layoutChunk代码:

void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state,
            LayoutState layoutState, LayoutChunkResult result) {
        // 通过Recycler通过复用回收拿到下一个要填充postion的view
        View view = layoutState.next(recycler);
        if (view == null) {
            result.mFinished = true;
            return;
        }
        RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) view.getLayoutParams();
        if (layoutState.mScrapList == null) {
            if (mShouldReverseLayout == (layoutState.mLayoutDirection
                    == LayoutState.LAYOUT_START)) {
                addView(view);
            } else {
                addView(view, 0);
            }
        } else {
            if (mShouldReverseLayout == (layoutState.mLayoutDirection
                    == LayoutState.LAYOUT_START)) {
                addDisappearingView(view);
            } else {
                addDisappearingView(view, 0);
            }
        }
        // 测量
        measureChildWithMargins(view, 0, 0);
        result.mConsumed = 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 (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
                bottom = layoutState.mOffset;
                top = layoutState.mOffset - result.mConsumed;
            } else {
                top = layoutState.mOffset;
                bottom = layoutState.mOffset + result.mConsumed;
            }
        } else {
            top = getPaddingTop();
            bottom = top + mOrientationHelper.getDecoratedMeasurementInOther(view);

            if (layoutState.mLayoutDirection == LayoutState.LAYOUT_START) {
                right = layoutState.mOffset;
                left = layoutState.mOffset - result.mConsumed;
            } else {
                left = layoutState.mOffset;
                right = layoutState.mOffset + result.mConsumed;
            }
        }
        // 布局
        layoutDecoratedWithMargins(view, left, top, right, bottom);
        
        }
        // Consume the available space if the view is not removed OR changed
        if (params.isItemRemoved() || params.isItemChanged()) {
            result.mIgnoreConsumed = true;
        }
        result.mFocusable = view.hasFocusable();
    }
  1. 首先提供next获取下一个要操作的view,这里直接调用了recycler.getViewForPosition方法,内部封装了复用的逻辑,下面的章节会细致的讲解。mItemDirection这里比较巧妙,他表示布局的方向,只能是1或者-1。
    View next(RecyclerView.Recycler recycler) {
            if (mScrapList != null) {
                return nextViewFromScrapList();
            }
            final View view = recycler.getViewForPosition(mCurrentPosition);
            mCurrentPosition += mItemDirection;
            return view;
        }
  1. 拿到view后,我们终于找到了子view测量布局的地方,通过measureChildWithMargins进行测量,通过layoutDecoratedWithMargins布局。

这样一步一步,直到RecycleView的可用空间填充满了,这时RecycleView就完成了第一屏的填充。

总结

  1. LayoutManager的职责主要集中在整屏布局填充、滑动布局填充、滑动处理、item测量布局等功能,我们实现自己的LayoutManager时,也要实现这些功能
  2. 整屏填充的逻辑先确认锚点、确认布局参数,最终利用上面产生的数据进行填充。
  3. 填充填充可用区域的大小,也就是限制在RecyclerView的宽高内。

分析完LayoutManager的源码。并结合前两章的测绘流程,应该对整体的测绘,从表到里都有了很深的理解。

下一篇我们讲解RecycleView的滑动机制,分析滑动的处理和这是布局如何填充逻辑。

你可能感兴趣的:(RecycleView源码分析(四)LayoutManager源码分析)