RecyclerView之自定义LayoutManager和SnapHelper

时间  2019-11-07
标签 recyclerview 自定义 layoutmanager snaphelper 繁體版
原文   原文链接

主要是实现相似于抖音翻页的效果，可是有有点不一样，须要在底部漏出后面的view，这样说可能很差理解，看下Demo，按页滑动，后面的View有放大缩放的动画，滑动速度太小时会有回到原位的效果，下滑也是按页滑动的效果。css


有的小伙伴可能说这个用 SnapHelper就能够了，没错，翻页是要结合这个，可是也不是纯粹靠这个，由于底部须要漏出来后面的view，因此LayoutManager就不能简单的使用LinearLayoutManager,须要去自定义LayoutManager,而后再自定义SnapHelper。java

先看下自定义LayoutManager。缓存

1.自定义LayoutManager

Android系统给咱们提供了经常使用的几个LayoutManager，好比LinearLayoutManager:用于水平或者竖直滑动
GridLayoutManager:用于表格布局，一行能够有多列
StaggeredGridLayoutManager：瀑布流布局ide

可是在咱们上面那个界面就用不了，由于在第一页界面底部须要漏出后面的Item，因此咱们就须要自定义。函数

通常自定义LayoutManager须要实现三个方法：布局

第一个方法是generateDefaultLayoutParams，这个用来定义布局参数的，通常宽高都WRAP_CONTENT就行。post

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

第二个方法根据须要水平或者竖直滑动区分，咱们这里是竖直滑动，重写canScrollVertically学习

@Override
    public boolean canScrollVertically() {
        return true;
    }
复制代码

聪明的你确定已经知道若是水平滑动，就是重写canScrollHorizontally.动画

前面两个方法都很简单，最麻烦的就是第三个方法，重写LayoutManager就是须要本身去布局，因此须要重写ui

@Override
    public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
        if (state.getItemCount() == 0 || state.isPreLayout()) {
            return;
        }

        if (!hasChild) {
            hasChild = true;
        }

        mItemCount = getItemCount();
        // 滑动过的距离
        mScrollOffset = Math.min(Math.max(0, mScrollOffset), (mItemCount - 1) * itemHeight);

        layoutChild(recycler);
    }
复制代码

首先若是没有item或者第一次layout进来就直接返回，mScrollOffset是滑动过的距离，初始值为0，滑动到最后一个就不能进行滑动，这里其实能够加个下拉刷新，之后有机会再加，不是今天的主题。

接下来大头就是layoutChild.

private void layoutChild(RecyclerView.Recycler recycler) {
        if (getItemCount() == 0) {
            return;
        }
        int firstItemPosition = (int) Math.floor(mScrollOffset / itemHeight);
        if (firstItemPosition > commonAdapter.getItemCount() - 1) {
            return;
        }

        int firstItemScrolledHeight = mScrollOffset % itemHeight;
        final float firstItemScrolledHeightPercent = firstItemScrolledHeight * 1.0f / itemHeight;
        ArrayList<PageItemViewInfo> layoutInfos = new ArrayList<>();

        // 计算view位置
        int tmpCount = Math.min(VISIBLE_EMOTICON_COUNT, commonAdapter.getItemCount() - firstItemPosition - 1);
        for (int i = 0; i <= tmpCount; i++) {
            // 用于计算偏移量
            int tmp = i + 1;
            double maxOffset = (getVerticalSpace()
                    - itemHeight - firstItemScrolledHeightPercent) / 2 * Math.pow(0.65, tmp);
            if (maxOffset <= 0) {
                break;
            }
            int start;
            if (i == 0) {
                start = getPaddingTop() - firstItemScrolledHeight;
            } else {
                start = (int) (getPaddingTop() + i * maxOffset + i * ITEM_OFFSET);
            }
            float mScale = 0.95f;
            float scaleXY = (float) (Math.pow(mScale, i) * (1 - firstItemScrolledHeightPercent * (1 - mScale)));
            PageItemViewInfo info = new PageItemViewInfo(start, scaleXY);
            layoutInfos.add(0, info);
        }

        // 回收View
        int layoutCount = layoutInfos.size();
        final int endPos = firstItemPosition + VISIBLE_EMOTICON_COUNT;
        final int childCount = getChildCount();
        for (int i = childCount - 1; i >= 0; i--) {
            View childView = getChildAt(i);
            if (childView == null) {
                continue;
            }
            int pos;
            try {
                pos = getPosition(childView);
            } catch (NullPointerException e) {
                e.printStackTrace();
                continue;
            }

            if (pos > endPos + 1 || pos < firstItemPosition - 1) {
                removeAndRecycleView(childView, recycler);
            }
        }

        detachAndScrapAttachedViews(recycler);

        // 添加Item
        for (int i = layoutCount - 1; i >= 0; i--) {
            int pos = firstItemPosition + i;
            if (pos > commonAdapter.getItemCount() - 1) {
                break;
            }
            // If a ViewHolder must be constructed and not enough time remains, null is returned, 不进行layout
            View view;
            try {
                view = recycler.getViewForPosition(pos);
            } catch (IndexOutOfBoundsException e) {
                e.printStackTrace();
                return;
            }

            PageItemViewInfo layoutInfo = layoutInfos.get(layoutCount - 1 - i);
            view.setTag(pos);
            addView(view);
            measureChildWithExactlySize(view);
            int left = (getHorizontalSpace() - itemWidth) / 2;
            layoutDecoratedWithMargins(view, left,
                    layoutInfo.getTop(),
                    left + itemWidth,
                    layoutInfo.getTop() + itemHeight);
            view.setPivotX(view.getWidth() / 2);
            view.setPivotY(view.getHeight() / 2);
            view.setScaleX(layoutInfo.getScaleXY());
            view.setScaleY(layoutInfo.getScaleXY());
        }
    }
复制代码

主要分红三部分，

计算Item位置
回收Item
添加Item
下面分别看下。

计算Item位置

就是根据当前滑动过的距离来计算当前可见的几个Item(这里我设置为3)的位置，这里因为宽高都定死的，因此须要的其实就是top位置。根据根据注释看代码应该比较简单了。

// 第一个可见Item位置
        int firstItemPosition = (int) Math.floor(mScrollOffset / itemHeight);
        // 若是第一个可见Item位置是最后一个Item，返回
        if (firstItemPosition > commonAdapter.getItemCount() - 1) {
            return;
        }

        // 第一个可见Item划过的距离，也就是不可见
        int firstItemScrolledHeight = mScrollOffset % itemHeight;

        // 第一个可见Item划过的距离占自身高度的百分比
        final float firstItemScrolledHeightPercent = firstItemScrolledHeight * 1.0f / itemHeight;
        ArrayList<PageItemViewInfo> layoutInfos = new ArrayList<>();

        // 计算view位置
        int tmpCount = Math.min(VISIBLE_EMOTICON_COUNT, commonAdapter.getItemCount() - firstItemPosition - 1);
        for (int i = 0; i <= tmpCount; i++) {
            // 用于计算偏移量
            int tmp = i + 1;
            double maxOffset = (getVerticalSpace()
                    - itemHeight - firstItemScrolledHeightPercent) / 2 * Math.pow(0.65, tmp);
            if (maxOffset <= 0) {
                break;
            }
            int start;
            if (i == 0) {
                start = getPaddingTop() - firstItemScrolledHeight;
            } else {
                start = (int) (getPaddingTop() + i * maxOffset + i * ITEM_OFFSET);
            }
            float mScale = 0.95f;
            float scaleXY = (float) (Math.pow(mScale, i) * (1 - firstItemScrolledHeightPercent * (1 - mScale)));
            PageItemViewInfo info = new PageItemViewInfo(start, scaleXY);
            layoutInfos.add(0, info);
        }
复制代码

回收Item

RecyclerView提供了三级缓存，简单看下Recycler

public final class Recycler {
        final ArrayList<ViewHolder> mAttachedScrap = new ArrayList<>();

        final ArrayList<ViewHolder> mCachedViews = new ArrayList<ViewHolder>();

        RecycledViewPool mRecyclerPool;
     ...
 }
复制代码

其中

mAttachedScrap缓存当前屏幕上可见的ViewHolder,

mCachedViews缓存复用即将入屏的 item ，

RecycledViewPool能够缓存多个RecyclerView须要共用的ViewHolder，内部维护了一个SparseArray, key为ViewHolder的ViewType，也就是每一套ViewHolder都有本身的缓存数据，value为ScrapData类型

public static class RecycledViewPool {
        private static final int DEFAULT_MAX_SCRAP = 5;
        static class ScrapData {
            ArrayList<ViewHolder> mScrapHeap = new ArrayList<>();
            int mMaxScrap = DEFAULT_MAX_SCRAP;
            long mCreateRunningAverageNs = 0;
            long mBindRunningAverageNs = 0;
        }
        SparseArray<ScrapData> mScrap = new SparseArray<>();
}
复制代码

ArrayList 的默认大小被限制为 5，可是这个值是能够经过 RecycledViewPool#setMaxRecycledViews(viewType, max) 来替换

多个RecycledView复用能够经过public void putRecycledView(ViewHolder scrap)向内主动填充数据。

关于缓存能够参考手摸手第二弹，可视化 RecyclerView 缓存机制
上面简单看了下RecyclerView的缓存机制，在这里咱们须要都不在屏幕可见范围内的Item进行回收，放到mCachedViews中，而后把屏幕可见范围内的Item放到mAttachedScrap中，后面进行从新add。最后看下回收的代码：

int layoutCount = layoutInfos.size();
        final int endPos = firstItemPosition + VISIBLE_EMOTICON_COUNT;
        final int childCount = getChildCount();
        for (int i = childCount - 1; i >= 0; i--) {
            View childView = getChildAt(i);
            if (childView == null) {
                continue;
            }
            int pos;
            try {
                pos = getPosition(childView);
            } catch (NullPointerException e) {
                e.printStackTrace();
                continue;
            }

            if (pos > endPos + 1 || pos < firstItemPosition - 1) {
                removeAndRecycleView(childView, recycler);
            }
        }

        detachAndScrapAttachedViews(recycler);
复制代码

最后就是根据计算的位置从新addView就行，View从view = recycler.getViewForPosition(pos);中取出，RecyclerView会从缓存中拿。

// 添加Item
        for (int i = layoutCount - 1; i >= 0; i--) {
            int pos = firstItemPosition + i;
            if (pos > commonAdapter.getItemCount() - 1) {
                break;
            }
            // If a ViewHolder must be constructed and not enough time remains, null is returned, 不进行layout
            View view;
            try {
                view = recycler.getViewForPosition(pos);
            } catch (IndexOutOfBoundsException e) {
                e.printStackTrace();
                return;
            }

            PageItemViewInfo layoutInfo = layoutInfos.get(layoutCount - 1 - i);
            view.setTag(pos);
            addView(view);
            measureChildWithExactlySize(view);
            int left = (getHorizontalSpace() - itemWidth) / 2;
            layoutDecoratedWithMargins(view, left,
                    layoutInfo.getTop(),
                    left + itemWidth,
                    layoutInfo.getTop() + itemHeight);
            view.setPivotX(view.getWidth() / 2);
            view.setPivotY(view.getHeight() / 2);
            view.setScaleX(layoutInfo.getScaleXY());
            view.setScaleY(layoutInfo.getScaleXY());
        }
复制代码

以上就是自定义LayoutManager的过程，如今的实现是Item会随着手指移动，没有按页滑动的效果，要实现按页滑动的效果就须要SnapHelper出场了。

2.自定义SnapHelper

SnapHelper有三个抽象方法须要实现：

@SuppressWarnings("WeakerAccess")
    @Nullable
    public abstract int[] calculateDistanceToFinalSnap(@NonNull LayoutManager layoutManager,
            @NonNull View targetView);

    @SuppressWarnings("WeakerAccess")
    @Nullable
    public abstract View findSnapView(LayoutManager layoutManager);

    public abstract int findTargetSnapPosition(LayoutManager layoutManager, int velocityX, int velocityY);
复制代码

三个方法的做用：

findTargetSnapPosition用来找到最终的目标位置，在fling操做刚触发的时候会根据速度计算一个最终目标位置，而后开始fling操做
calculateDistanceToFinalSnap 这个用来计算滑动到最终位置还须要滑动的距离，在一开始attachToRecyclerView或者targetView layout的时候会调用
findSnapView用来找到上面的targetView，就是须要对其的view，在calculateDistanceToFinalSnap 调用以前会调用该方法。

在LayoutManager中须要把SnapHelper和RecyclerView关联起来：

@Override
    public void onAttachedToWindow(RecyclerView view) {
        super.onAttachedToWindow(view);
        this.snapHelper.attachToRecyclerView(view);
    }
复制代码

在attachToRecyclerView中会调用snapToTargetExistingView方法：

void snapToTargetExistingView() {
        if (mRecyclerView == null) {
            return;
        }
        RecyclerView.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找到须要对齐的View，看下log：

I: ===========attachToRecyclerView==========
    ===========snapToTargetExistingView==========
    ===========findSnapView==========
    pos = -1
复制代码

返回-1就是没有须要对齐的。

看下findSnapView的实现：

@Nullable
    @Override
    public View findSnapView(RecyclerView.LayoutManager layoutManager) {
        if (layoutManager instanceof SlidePageLayoutManager) {
            int pos = ((SlidePageLayoutManager) layoutManager).getFixedScrollPosition(mDirection);
            mDirection = 0;
            if (pos != RecyclerView.NO_POSITION) {
                View view = layoutManager.findViewByPosition(pos);
                return view;
            }
        }
        return null;
    }
复制代码

其实就是调用layoutmanager得到位置pos, 代码实现很简单：

public int getFixedScrollPosition(int direction) {
        if (hasChild) {
            if (mScrollOffset % itemHeight == 0) {
                return RecyclerView.NO_POSITION;
            }
            float position = mScrollOffset * 1.0f / itemHeight;

            if (direction > 0) {
                position =  (int) Math.ceil(position);
            } else {
                position =  (int) Math.floor(position);
            }
            return (int) position;
        }
        return RecyclerView.NO_POSITION;
    }
复制代码

第一次进来ScrollOffset为0，因此返回-1.后面根据ScrollOffset计算位置，若是向下滑，那就向下取整，好比如今第一个滑动到一半，那么position是小于1的小数，向下取整就获得1，因此SnapView就是位置是1的ViewHolder。

而后手指按下滑动，此时scrollState状态就是SCROLL_STATE_DRAGGING,看下log:

I: ===========onScrollStateChanged==========
    newState = 1
I: ===========******onFling******==========
I: ===========findTargetSnapPosition==========
    ===========getFixedScrollPosition==========
I: ScrollOffset = 461, itemHeight = 1116, position = 1.0, direction = 578
I: ===========onTargetFound==========
    targetView = 1
    ===========calculateDistanceToFinalSnap==========
    ===========calculateDistanceToPosition==========
I: targetPos = 1, distance = 655, scrollOffset = 461
    y = 655
    ===========onScrollStateChanged==========
    newState = 2
I: ===========onScrollStateChanged==========
    newState = 0
I: ===========snapToTargetExistingView==========
    ===========findSnapView==========
    ===========getFixedScrollPosition==========
I: pos = -1

复制代码

而后就会触发onFling状态，首先会去回调另一个findTargetSnapPosition找到fling操做须要滚动到什么位置，咱们这里是按页滑动，因此须要滚动到下一个View的位置，看下该方法实现

@Override
    public int findTargetSnapPosition(RecyclerView.LayoutManager layoutManager, int velocityX, int velocityY) {
        if (layoutManager.canScrollVertically()) {
            mDirection = velocityY;
            return ((SlidePageLayoutManager) layoutManager).getFixedScrollPosition(mDirection);
        } else {
            mDirection = velocityX;
        }

        return RecyclerView.NO_POSITION;
    }
复制代码

调用的其实仍是getFixedScrollPosition计算获得位置。经过log也能够看出往下滑direction是正值，同时下一个位置就是1，由于咱们拖拽的是0位置。

在咱们须要找的位置layout出来的时候(在这里是1位置), 会回调onTargetFound方法，其中入参targetView就是上面找到的1位置对应的View，我在layout的时候给每一个View加了个其对应位置的tag，经过log也能够看出targetView.getTag = 1。

在这里咱们须要计算一个RecyclerView还须要滚动的距离给系统，这就须要实现最后一个抽象函数calculateDistanceToFinalSnap,把须要滚动的距离经过方法calculateTimeForDeceleration换算成时间，而后经过Action.update通知RecyclerView进行减速滚动到最终位置。

看下calculateDistanceToFinalSnap的实现：

@Nullable
    @Override
    public int[] calculateDistanceToFinalSnap(
            @NonNull RecyclerView.LayoutManager layoutManager,
            @NonNull View targetView) {
        if (layoutManager instanceof SlidePageLayoutManager) {
            int[] out = new int[2];
            if (layoutManager.canScrollHorizontally()) {
                out[0] = ((SlidePageLayoutManager) layoutManager).calculateDistanceToPosition(
                        layoutManager.getPosition(targetView));
                out[1] = 0;
            } else {
                out[0] = 0;
                out[1] = ((SlidePageLayoutManager) layoutManager).calculateDistanceToPosition(
                        layoutManager.getPosition(targetView));
            }
            LogUtils.LogSlide(null, new String[]{"y"}, out[1]);
            return out;
        }
        return null;
    }

    public int calculateDistanceToPosition(int targetPos) {
        int distance = itemHeight * targetPos - mScrollOffset;
        return distance;
    }
复制代码

代码炒鸡简单，就是经过下一个位置的layout位置减去当前已经滑动过的距离，就获得RecyclerView剩下还须要滑动的距离，小学的计算题了你们一看就懂。

看下上面的log也能够看出，当前已经滑动过的距离ScrollOffset是461，每一个item的高度是1116，那么1116 - 461 = 655就是RecyclerView还须要滑动的距离。

不知不觉咱们已经把三个须要实现的抽象方法都实现了，onFling操做过程当中会把scrollstate设置为2，就是SCROLL_STATE_SETTLING。滚动过上面计算获得的距离后中止，状态变为0，就是SCROLL_STATE_IDLE。

再看下下滑的log：

I: ===========onScrollStateChanged==========
I: newState = 1
I: ===========******onFling******==========
I: ===========findTargetSnapPosition==========
I: ===========getFixedScrollPosition==========
    ScrollOffset = 579, itemHeight = 1116, position = 0.0, direction = -446
I: ===========onTargetFound==========
    targetView = 0
    ===========calculateDistanceToFinalSnap==========
I: ===========calculateDistanceToPosition==========
    targetPos = 0, distance = -579, scrollOffset = 579
    y = -579
    ===========onScrollStateChanged==========
    newState = 2
I: ===========onScrollStateChanged==========
I: newState = 0
    ===========snapToTargetExistingView==========
    ===========findSnapView==========
I: ===========getFixedScrollPosition==========
    pos = -1
复制代码

scrollstate仍是差很少，先是1 = SCROLL_STATE_DRAGGING,而后进入Fling状态，scrollstate变为2 = SCROLL_STATE_SETTLING, 最后停下来状态变为0 = SCROLL_STATE_IDLE。
在Fling状态开始的时候会经过findTargetSnapPosition，调用getFixedScrollPosition方法计算， direction = -446 < 0,因此向下取整获得0，目标位置就是0位置了。
而后会回调onTargetFound,经过方法calculateDistanceToFinalSnap获得滑动到0目标位置还须要滑动的距离。

自定义SnapHelper就是这样，理清三个接口的做用就简单了。

3.总结

由于要实现PM的需求因此有了这一次的自定义LayoutManager和SnapHelper之旅。自定义LayoutManager也是实现三个方法，最主要的是要实现onLayoutChildren,而后根据具体需求去layout每一个item。自定义SnapHelper也是主要实现三个方法，主要是告诉须要最终滑动到的位置，须要对齐的View，而后在最终位置对应的View在layout出来后RecyclerView还须要滑动的距离。

坚持写博客不容易，从网上博客学到不少东西，因此也一再告诉本身要坚持下去。


+qq群457848807：。获取以上高清技术思惟图，以及相关技术的免费视频学习资料

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程