对于使用ReccyclerView的我们来说，LayoutManager早已非常熟悉。可是，有没有想过我们所说的熟悉是哪种熟悉？对的，就是会使用而已，这其中包括谷歌爸爸帮我们实现的几种LayoutManager,例如：LinearLayoutManager，GridLayoutManager等等。
  仔细想一想，我们使用LayoutManager就像我们当初初学Android时使用各种基础控件，我们处于只会使用的阶段，如果后续有一些特殊的要求，系统的实现已经不能满足我们自身的需求，此时自定义LayoutManager就必须出手了。同时，如果想要自定义LayoutManager，我们就必须了解它相关的原理。所以，学习LayoutManager的源码是至关重要的。
  本文参考资料：

1. RecyclerView系列（7）—自定义LayoutManager（上），视觉上定义一个具备上下边界的RecyclerView.layoutMnager
2. RecyclerView系列（8）—自定义LayoutManager（下） ，回收复用及优化
3. LayoutManagerGroup

  介于LayoutManger的特殊性，我们不可能将LayoutManager及其所有子类的代码都分析一遍，所以本文的源码分析重点是，从源码角度来解释为什么这样自定义LayoutManager。自定义LayoutManager要求的门槛相对较高，它不是简单的照着模板来写，而是需要了解它内部的原理，这其中包括回收机制(这个我们在分析RecyclerView的三大流程时已经从LinearLayoutManager内部看到了)，滑动机制等等。所以，在自定义LayoutManager时，我默认大家都懂得这些原理，如果还有同学不懂的话，可以参考我的文章：

1. RecyclerView 源码分析(一) - RecyclerView的三大流程
2. RecyclerView 源码分析(二) - RecyclerView的滑动机制
3. RecyclerView 源码分析(三) - RecyclerView的缓存机制

  本文打算从如下几个角度来分析LayoutManager:

1. 知识储备--相关方法的解释，这里的相关方法主要是自定义涉及到的方法
2. 自定义一个LayoutManager
3. SnapHelper基本使用、源码分析和自定义SnapHelper

1. 概述

  在正式分析LayoutManager之前，我们先来对LayoutManager及其它的相关组件做一个简单的概述。
  我们都知道LayoutManager就是一个布局管理器，主要负责RecyclerView的ItemView测量和布局，所以自定义LayoutManager的过程跟自定义View的过程非常的相似。本文打算从一个Demo开始来介绍怎么自定义一个LayoutManager,效果如下：

2. LayoutManager的相关方法

  我们在自定义LayoutManager之前，先来看一下LayoutManager的几个方法。

3. 自定义LayoutManager

  简单的了解了自定义LayoutManager的几个方法，现在我将带领来实现一个Demo，具体的效果就是上面的gif动图，我们来看看怎么自己实现一个LayoutMananger。

(1). 重写generateDefaultLayoutParams方法

  首先，自定义LayoutManager的第一步就是重写generateDefaultLayoutParams方法，这个方法的作用在上面我已经介绍了，在这里就不介绍了。通常来说，我们这样来实现generateDefaultLayoutParams方法就行了：

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

  我们这里没有特殊的要求，所以让每个ItemView的自适应就行了。

(2). onLayoutChildren方法

  然后，第二步就是重写onLayoutChildren方法，也是最复杂的一步。在这一步，我们主要完成两步：

1. 定位每个ItemView的位置，然后布局。
2. 适配滑动和缩放的效果。

  我们先来结合图片来分析一下这个效果。

    @Override
    public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
        if (state.getItemCount() == 0 || state.isPreLayout()) return;
        removeAndRecycleAllViews(recycler);
        if (!mHasChild) {
            mItemViewHeight = getVerticalSpace();
            mItemViewWidth = (int) (mItemViewHeight / mItemHeightWidthRatio);
            mHasChild = true;
        }
        mItemCount = getItemCount();
        mScrollOffset = makeScrollOffsetWithinRange(mScrollOffset);
        fill(recycler);
    }

  在onLayoutChildren方法里面，我们初始化了几个变量，其中mItemViewHeight和mItemViewWidth两个变量分别表示ItemView的高和宽。其次就是mScrollOffset的初始化：

    private int makeScrollOffsetWithinRange(int scrollOffset) {
        return Math.min(Math.max(mItemViewWidth, scrollOffset), mItemCount * mItemViewWidth);
    }

  第一次调用onLayoutChildren方法来初始化mScrollOffset时，mScrollOfffet的值被设置为mItemCount * mItemViewWidth。这有什么意义呢？我待会会解释。
  在onLayoutChidlren方法的最后，调用fill方法。fill方法才是真正计算每个ItemView的位置，我们来看看：

    private void fill(RecyclerView.Recycler recycler) {
        // 1.初始化基本变量
        int bottomVisiblePosition = mScrollOffset / mItemViewWidth;
        final int bottomItemVisibleSize = mScrollOffset % mItemViewWidth;
        final float offsetPercent = bottomItemVisibleSize * 1.0f / mItemViewWidth;
        final int space = getHorizontalSpace();
        int remainSpace = space;
        final int defaultOffset = mItemViewWidth / 2;
        final List<ItemViewInfo> itemViewInfos = new ArrayList<>();
        // 2.计算每个ItemView的位置信息(left和scale)
        for (int i = bottomVisiblePosition - 1, j = 1; i >= 0; i--, j++) {
            double maxOffset = defaultOffset * Math.pow(mScale, j - 1);
            int start = (int) (remainSpace - offsetPercent * maxOffset - mItemViewWidth);
            ItemViewInfo info = new ItemViewInfo(start, (float) (Math.pow(mScale, j - 1) * (1 - offsetPercent * (1 - mScale))));
            itemViewInfos.add(0, info);
            remainSpace -= maxOffset;
            if (remainSpace < 0) {
                info.setLeft((int) (remainSpace + maxOffset - mItemViewWidth));
                info.setScale((float) Math.pow(mScale, j - 1));
                break;
            }
        }
        // 3.添加最右边ItemView的相关信息
        if (bottomVisiblePosition < mItemCount) {
            final int left = space - bottomItemVisibleSize;
            itemViewInfos.add(new ItemViewInfo(left, 1.0f));
        } else {
            bottomVisiblePosition -= 1;
        }
        // 4.回收其他位置的View
        final int layoutCount = itemViewInfos.size();
        final int startPosition = bottomVisiblePosition - (layoutCount - 1);
        final int endPosition = bottomVisiblePosition;
        final int childCount = getChildCount();
        for (int i = childCount - 1; i >= 0; i--) {
            final View childView = getChildAt(i);
            final int position = convert2LayoutPosition(i);
            if (position > endPosition || position < startPosition) {
                detachAndScrapView(childView, recycler);
            }
        }
        // 5.先回收再布局
        detachAndScrapAttachedViews(recycler);
        for (int i = 0; i < layoutCount; i++) {
            fillChild(recycler.getViewForPosition(convert2AdapterPosition(startPosition + i)), itemViewInfos.get(i));
        }
    }

  在分析上面的代码之前，我先来对几个变量做一个统一的解释。

  然后就是计算每个ItemView的位置了。这里需要注意一个问题，就是bottomVisiblePosition == mItemCount的情况。
  当bottomVisiblePosition == mItemCount时，也是最初的状态，这种情况下，第二步就是直接将最右边的ItemView的位置信息计算出来。
  当bottomVisiblePosition < mItemCoun时(没有大于的情况)时，也是在滑动的时，是在第三步时将最右边的ItemView的位置信息计算出来。
  关于位置信息的计算，这里就不讨论了，都是一些常规的计算逻辑。
  最后就是布局，调用的是fillChild方法：

    private void fillChild(View view, ItemViewInfo itemViewInfo) {
        addView(view);
        measureChildWithExactlySize(view);
        final int top = getPaddingTop();

        layoutDecoratedWithMargins(view, itemViewInfo.getLeft(), top, itemViewInfo.getLeft() + mItemViewWidth, top + mItemViewHeight);
        view.setScaleX(itemViewInfo.getScale());
        view.setScaleY(itemViewInfo.getScale());
    }

  fillChild方法没有解释的必要，熟悉自定义View的同学应该都懂。
  到这里onLayoutChildren方法算是重新完毕了，这个过程中，比较难以理解的是位置信息的计算，这个我也不知道怎么解释，大家就自己发挥想象力吧。

(3). 水平滑动

  接下来就是让RecyclerView支持水平滑动。要想支持水平滑动，我们必须重写canScrollHorizontally方法和scrollHorizontallyBy方法，我们来看看：

    @Override
    public boolean canScrollHorizontally() {
        return true;
    }

    public int scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler, RecyclerView.State state) {
        int pendingScrollOffset = mScrollOffset + dx;
        mScrollOffset = makeScrollOffsetWithinRange(pendingScrollOffset);
        fill(recycler);
        return mScrollOffset - pendingScrollOffset + dx;
    }

  这个过程中，需要特别注意的是scrollHorizontallyBy方法，我们不能直接让mScrollOffset加上dx，因为mScrollOffset的范围在[mItemViewWidth,mItemCount * mItemViewWidth],所以在每次滑动之后需要调整，得再一次调用makeScrollOffsetWithinRange方法。

(3). 滑动之后最右边的ItemView都能完整显示

  这个需求就非常的简单，自我实现一个SnaHelper，然后这样使用就OK了：

    private final SnapHelper mSnapHelper = new CustomSnapHelper();
    @Override
    public void onAttachedToWindow(RecyclerView view) {
        super.onAttachedToWindow(view);
        mSnapHelper.attachToRecyclerView(view);
    }

  这里面具体的含义这里先不解释，待会在分析SnaHelper时会详细的解释。

(5). 源码

  整个LayoutManager的自定义过程就OK了，具体的效果就是上面的动图效果。
  还有不懂的同学可以我的github去下载源码:LayoutManagerDemo。特别感谢：LayoutManagerGroup，本文自定义的LayoutManager大部分思路和源码都来至于它。

4. SnapHelper

  SnaHelper的存在对于RecyclerView来说，可谓是如虎添翼。SnaHelper可见帮助我们实现一些特殊的效果，比如说，我们可以使用RecyclerView和SnapHelper去实现ViewPager的效果。
  通常来说，我们在日常开发中，使用RecyclerView很少遇到的SnapHelper，不过，如果你想要自定义LayoutManager来实现一些特殊效果，很大的可能性会遇到SnapHelper。那么SnapHelper到底是什么呢？是怎么使用的呢？它的实现原理又是什么呢？这是本文需要解答的三个问题。
  简单来说，SnapHelper就是一个Helper类，只是它的内部有两个监听接口：OnFlingListener和OnScrollListener，分别用来监听RecyclerView的scroll事件和fling事件。
  而SnapHelper的使用也是非常的简单，就是在LayoutManager的onAttachedToWindow方法调用SnapHelper的attachToRecyclerView方法即可。我们就从attachToRecyclerView方法为入口来分析SnapHelper的源码。

(1). SnapHelper的源码分析

  SnapHelper的原理实际上是非常的简单，大家不要害怕。我们在分析SnapHelper源码之前，先来了解SnapHelper几个比较重要的方法：

  在这里，我们必须区分一下findTargetSnapPosition方法和calculateDistanceToFinalSnap、findSnapView方法的区别。

1. findTargetSnapPosition:此方法表示fling滑动能滑到的位置。
2. calculateDistanceToFinalSnap和findSnapView:这两个方法表示正常滑动的能到达位置，其中calculateDistanceToFinalSnap表示距离，这个过程涉及到因为对齐操作而进行的距离重新调整；findSnapView方法表示正常滑动能到达的位置对应的ItemView。

  所以，我们在自定义SnapHelper时，为了简单起见，不可以处理fling操作，也就是findTargetSnapPosition返回为RecyclerView.NO_POSITION,然后让RecyclerView自己进行fling ，等待滑动结束之后，会回调我们的calculateDistanceToFinalSnap和findSnapView来进行位置对齐。这样做的好处就是，我们不用既考虑fling又考虑普通滑动。

A.attachToRecyclerView方法

  准备的差不多了，接下来我们正式分析SnapHelper的源码。我们来看看attachToRecyclerView方法：

    public void attachToRecyclerView(@Nullable RecyclerView recyclerView)
            throws IllegalStateException {
        if (mRecyclerView == recyclerView) {
            return; // nothing to do
        }
        if (mRecyclerView != null) {
            destroyCallbacks();
        }
        mRecyclerView = recyclerView;
        if (mRecyclerView != null) {
            setupCallbacks();
            mGravityScroller = new Scroller(mRecyclerView.getContext(),
                    new DecelerateInterpolator());
            snapToTargetExistingView();
        }
    }

  attachToRecyclerView非常的简单，就是设置给RecyclerView设置了两个监听接口：

    private void setupCallbacks() throws IllegalStateException {
        if (mRecyclerView.getOnFlingListener() != null) {
            throw new IllegalStateException("An instance of OnFlingListener already set.");
        }
        mRecyclerView.addOnScrollListener(mScrollListener);
        mRecyclerView.setOnFlingListener(this);
    }

  然后RecyclerView开心的滑动，就会回调到我们的两个监听事件里面来。

B.OnScrollListener

  我们先来看看OnScrollListener接口的实现，看看它做了哪些事情：

    private final RecyclerView.OnScrollListener mScrollListener =
            new RecyclerView.OnScrollListener() {
                boolean mScrolled = false;

                @Override
                public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
                    super.onScrollStateChanged(recyclerView, newState);
                    if (newState == RecyclerView.SCROLL_STATE_IDLE && mScrolled) {
                        mScrolled = false;
                        snapToTargetExistingView();
                    }
                }

                @Override
                public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
                    if (dx != 0 || dy != 0) {
                        mScrolled = true;
                    }
                }
            };

  我们发现，当RecyclerView滑动结束之后，就会调用snapToTargetExistingView方法。那snapToTargetExistingView方法是干嘛的呢？其实就是保证对齐的。我们来看看：

    void snapToTargetExistingView() {
        if (mRecyclerView == null) {
            return;
        }
        LayoutManager layoutManager = mRecyclerView.getLayoutManager();
        if (layoutManager == null) {
            return;
        }
        View snapView = findSnapView(layoutManager);
        if (snapView == null) {
            return;
        }
        int[] snapDistance = calculateDistanceToFinalSnap(layoutManager, snapView);
        if (snapDistance[0] != 0 || snapDistance[1] != 0) {
            mRecyclerView.smoothScrollBy(snapDistance[0], snapDistance[1]);
        }
    }

  我们发现，在这里先是调用了findSnapView方法找到滑动的最终ItemView,然后根据找到的SnapView,调用calculateDistanceToFinalSnap方法来计算滑动的距离，最后调用相关方法来进行对齐。整个过程就是这么的简单。

C. OnFlingListener

  SnapHelper内部本身没有一个OnFingListener接口对象，而是自身实现了OnFingListener,所以当RecyclerView在fling时，会回调此onFling方法。我们来看看:

    @Override
    public boolean onFling(int velocityX, int velocityY) {
        LayoutManager layoutManager = mRecyclerView.getLayoutManager();
        if (layoutManager == null) {
            return false;
        }
        RecyclerView.Adapter adapter = mRecyclerView.getAdapter();
        if (adapter == null) {
            return false;
        }
        int minFlingVelocity = mRecyclerView.getMinFlingVelocity();
        return (Math.abs(velocityY) > minFlingVelocity || Math.abs(velocityX) > minFlingVelocity)
                && snapFromFling(layoutManager, velocityX, velocityY);
    }

  首先，我们要明白一个东西，如果RecyclerView有一个OnFlingListener处理fling事件的话，那么RecyclerView就不会再处理fling事件。
  所以SnapHelper是否处理fling事件，还需要看它的snapFromFling方法。我们来看看：

    private boolean snapFromFling(@NonNull LayoutManager layoutManager, int velocityX,
            int velocityY) {
        if (!(layoutManager instanceof ScrollVectorProvider)) {
            return false;
        }

        SmoothScroller smoothScroller = createScroller(layoutManager);
        if (smoothScroller == null) {
            return false;
        }

        int targetPosition = findTargetSnapPosition(layoutManager, velocityX, velocityY);
        if (targetPosition == RecyclerView.NO_POSITION) {
            return false;
        }

        smoothScroller.setTargetPosition(targetPosition);
        layoutManager.startSmoothScroll(smoothScroller);
        return true;
    }

  在上面的代码中，我们发现，findTargetSnapPosition如果返回为RecyclerView.NO_POSITION，那么SnapHelper就不会处理fling事件。而如果SnapHelper要处理fling事件的话，会通过LayoutManager的startSmoothScroll方法。这里面的原理实际上还是调用到RecyclerView的ViewFlinger里面去了。
  整个SnapHelper的原理就是这样，非常的简单，接下来我们结合实际来看看怎么自定义一个SnapHelper。

(2).自定义SnapHelper

  通常来说，我们自定义SnapHelper,实现三个抽象方法就已经差不多，分别是calculateDistanceToFinalSnap方法、findTargetSnapPosition方法和findSnapView方法就已经够了。我么来看看我们自己实现的CustomSnapHelper:

public class CustomSnapHelper extends SnapHelper {

    @Override
    public int[] calculateDistanceToFinalSnap(
            @NonNull RecyclerView.LayoutManager layoutManager, @NonNull View targetView) {

        if (layoutManager instanceof CustomLayoutManger) {
            int[] out = new int[2];
            if (layoutManager.canScrollHorizontally()) {
                out[0] = ((CustomLayoutManger) layoutManager).calculateDistanceToPosition(
                        layoutManager.getPosition(targetView));
                out[1] = 0;
            } else {
                out[0] = 0;
                out[1] = ((CustomLayoutManger) layoutManager).calculateDistanceToPosition(
                        layoutManager.getPosition(targetView));
            }
            return out;
        }
        return null;
    }

    @Override
    public int findTargetSnapPosition(RecyclerView.LayoutManager layoutManager, int velocityX,
                                      int velocityY) {
        return RecyclerView.NO_POSITION;
    }

    @Override
    public View findSnapView(RecyclerView.LayoutManager layoutManager) {
        if (layoutManager instanceof CustomLayoutManger) {
            int pos = ((CustomLayoutManger) layoutManager).getFixedScrollPosition();
            if (pos != RecyclerView.NO_POSITION) {
                return layoutManager.findViewByPosition(pos);
            }
        }
        return null;
    }
}

  方法的具体含义我这里就不再解释了，大家可以我的Demo项目和上面对三个方法的解释来进行理解，总之来说，SnapHelper还是比较简单的。

5. 总结

  到这里，我们对LayoutManager相关分析就差不多，在最后，我做一个小小的总结。

1. 自定义LayoutManager需要注意四点：1.重写generateDefaultLayoutParams方法；2.重写onLayoutChildren方法，对ItemView进行布局；3. 处理滑动，例如水平滑动需要重写canScrollHorizontally和scrollHorizontallyBy；4. 如果需要处理对齐问题，可以使用SnapHelper。
2. 自定义SnapHelper我们只需要重写它的三个抽象方法即可，分别是：calculateDistanceToFinalSnap、findTargetSnapPosition和findSnapView。需要注意的是，为了简单起见，我们可以直接在findTargetSnapPosition内部返回RecyclerView.NO_POSITION,让RecyclerView来帮助我们处理fling事件。

  如果不出意外的话，接下来我将分析ItemAnimator。