Android--›打造无限循环的RecyclerView(已更新新方式)

最新推荐文章于 2024-08-01 21:34:34 发布
最新推荐文章于 2024-08-01 21:34:34 发布
阅读量1.6w 收藏 10
点赞数 16
分类专栏： Android Android自定义控件/自绘教程 文章标签： RecyclerView 无限循环
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/angcyo/article/details/59106665
版权

这里写图片描述

难点分析:
1:如何在有限的数据里面, 实现无限个Item呢?
2:如何让滑动的时候, 一个一个的滑动, 而不会一下子滚动多个呢?
3:如何在第一次显示的时候, 就可以左滑呢?

更新于2018-3-8
鉴于之前的时候方式, 有很多问题, 思路也不是特别好. 最近在学习的过程中, 发现了大神写了自定义的ViewPagerLayoutManager支持无限循环, 所以我就打算使用这个LayoutManager重写LoopRecyclerView.

1:继承ViewPagerLayoutManager

public static class LoopLayoutManager extends ViewPagerLayoutManager {

     private float itemWidth = -1;
     private float itemHeight = -1;

     public LoopLayoutManager(Context context) {
         this(context, ViewPagerLayoutManager.HORIZONTAL, false);
     }

     public LoopLayoutManager(Context context, int orientation, boolean reverseLayout) {
         super(context, orientation, reverseLayout);
         setEnableBringCenterToFront(true);
     }

     public void setItemWidthHeight(float itemWidth, float itemHeight) {
         this.itemWidth = itemWidth;
         this.itemHeight = itemHeight;
         requestLayout();
     }

     @Override
     public void setInfinite(boolean enable) {
         if (!enable) {
             int positionOffset = getCurrentPositionOffset();
             if (positionOffset > getItemCount() || positionOffset < 0) {
                 mOffset = 0;
             }
         }
         super.setInfinite(enable);
     }

     /**
      * Item 之间间隔的大小
      * 默认情况下, Item之间是相互叠加显示的, 需要通过此方法, 设置间隔才能显示出线性的效果
      */
     @Override
     protected float setInterval() {
         if (getOrientation() == ViewPagerLayoutManager.VERTICAL) {
             return itemHeight;
         }
         return itemWidth;
     }

     /**
      * 用来控制item属性, 比如各种属性动画, 在滑动的时候出发
      */
     @Override
     protected void setItemViewProperty(View itemView, float targetOffset) {
         //targetOffset 和 itemInterval 密切广西
         //targetOffset 取值范围 -itemInterval/2  0  itemInterval/2
         //L.e("setItemViewProperty() -> " + targetOffset);
     }
 }

上面这个类, 主要作用就是让ViewPagerLayoutManager产生出LinearLayoutManager的水平布局效果, 和支持无限循环布局.

2:继承PagerSnapHelper
让RecyclerView滚动的时候, 模拟出ViewPager的效果, 并且监听页面改变回调.

publicstatic class LoopSnapHelper extends RPagerSnapHelper {

     @Override
     public boolean onFling(int velocityX, int velocityY) {
         super.onFling(velocityX, velocityY);
         //拦截fling操作
         return true;
     }

     @Nullable
     @Override
     public View findSnapView(LayoutManager layoutManager) {
         return super.findSnapView(layoutManager);
     }

     @Override
     public int findTargetSnapPosition(LayoutManager lm, int velocityX, int velocityY) {
         //return super.findTargetSnapPosition(layoutManager, velocityX, velocityY);
         //重写fling操作
         if (lm instanceof LoopLayoutManager) {
         } else {
             return RecyclerView.NO_POSITION;
         }
         RecyclerView.Adapter adapter = mRecyclerView.getAdapter();
         if (adapter == null) {
             return RecyclerView.NO_POSITION;
         }

         final int minFlingVelocity = mRecyclerView.getMinFlingVelocity();

         LoopLayoutManager layoutManager = (LoopLayoutManager) lm;
         int orientation = layoutManager.getOrientation();

         final boolean forwardDirection;
         if (layoutManager.canScrollHorizontally()) {
             forwardDirection = velocityX > 0;
         } else {
             forwardDirection = velocityY > 0;
         }
         final int offsetPosition;
         if (forwardDirection) {
             offsetPosition = 1;
         } else {
             offsetPosition = -1;
         }

         final int currentPosition = layoutManager.getCurrentPosition();
         if ((orientation == ViewPagerLayoutManager.VERTICAL
                 && Math.abs(velocityY) > minFlingVelocity) || (orientation == ViewPagerLayoutManager.HORIZONTAL
                 && Math.abs(velocityX) > minFlingVelocity)) {

             int position = layoutManager.getReverseLayout() ?
                     currentPosition - offsetPosition : currentPosition + offsetPosition;
             mRecyclerView.smoothScrollToPosition(position);
         }

         //不需要默认的fling操作
         return RecyclerView.NO_POSITION;
     }

     @Nullable
     @Override
     public int[] calculateDistanceToFinalSnap(@NonNull RecyclerView.LayoutManager layoutManager, @NonNull View targetView) {
         RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) targetView.getLayoutParams();
         int position = params.getViewAdapterPosition();
         int left = targetView.getLeft();
         int right = targetView.getRight();
         int top = targetView.getTop();
         int bottom = targetView.getBottom();
         ViewGroup viewGroup = (ViewGroup) targetView.getParent();

         int[] out = new int[]{0, 0};
         boolean isLastItem;
         if (mOrientation == LinearLayoutManager.HORIZONTAL) {
             isLastItem = position == layoutManager.getItemCount() - 1/*最后一个*/ && right == viewGroup.getMeasuredWidth();
             out[0] = left;
             out[1] = 0;
         } else {
             isLastItem = position == layoutManager.getItemCount() - 1/*最后一个*/ && bottom == viewGroup.getMeasuredHeight();
             out[0] = 0;
             out[1] = top;
         }

         if (mOnPageListener != null && mCurrentPosition != position) {
             int currentPosition = mCurrentPosition;
             boolean listener = false;
             if (mOrientation == LinearLayoutManager.HORIZONTAL && (out[0] == 0 || isLastItem)) {
                 listener = true;
             } else if (mOrientation == LinearLayoutManager.VERTICAL && (out[1] == 0 || isLastItem)) {
                 listener = true;
             }

             if (listener) {
                 mCurrentPosition = position;
                 mOnPageListener.onPageSelector(mCurrentPosition);
                 mOnPageListener.onPageSelector(currentPosition, mCurrentPosition);
             }
         }
         return out;
     }
 }

public class RPagerSnapHelper extends PagerSnapHelper {

    protected RecyclerView mRecyclerView;
    OnPageListener mOnPageListener;
    int mCurrentPosition = -1;
    /**
     * 默认是横向Pager
     */
    int mOrientation = LinearLayoutManager.HORIZONTAL;
    private RecyclerView.OnScrollListener mScrollListener = new RecyclerView.OnScrollListener() {
        @Override
        public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
            if (newState == RecyclerView.SCROLL_STATE_DRAGGING) {
                //开始滚动
            } else if (newState == RecyclerView.SCROLL_STATE_IDLE) {
                //结束滚动
            } else if (newState == RecyclerView.SCROLL_STATE_SETTLING) {
                //滑行中
            }
        }
    };

    public RPagerSnapHelper() {
    }

    public RPagerSnapHelper(int mCurrentPosition) {
        this.mCurrentPosition = mCurrentPosition;
    }

    public int getCurrentPosition() {
        return mCurrentPosition;
    }

    public RPagerSnapHelper setCurrentPosition(int currentPosition) {
        mCurrentPosition = currentPosition;
        return this;
    }

    public OnPageListener getOnPageListener() {
        return mOnPageListener;
    }

    /**
     * 页面选择回调监听
     */
    public RPagerSnapHelper setOnPageListener(OnPageListener onPageListener) {
        mOnPageListener = onPageListener;
        return this;
    }

    @Override
    public void attachToRecyclerView(@Nullable RecyclerView recyclerView) throws IllegalStateException {
        super.attachToRecyclerView(recyclerView);
        mRecyclerView = recyclerView;

        if (recyclerView != null) {
            recyclerView.removeOnScrollListener(mScrollListener);
            recyclerView.addOnScrollListener(mScrollListener);

            RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
            if (layoutManager instanceof LinearLayoutManager) {
                mOrientation = ((LinearLayoutManager) layoutManager).getOrientation();
            }
        }
    }

    @Nullable
    @Override
    public int[] calculateDistanceToFinalSnap(@NonNull RecyclerView.LayoutManager layoutManager, @NonNull View targetView) {
        RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) targetView.getLayoutParams();
        int position = params.getViewAdapterPosition();
        int left = targetView.getLeft();
        int right = targetView.getRight();
        int top = targetView.getTop();
        int bottom = targetView.getBottom();
        ViewGroup viewGroup = (ViewGroup) targetView.getParent();

        int[] out = new int[]{0, 0};
        boolean isLastItem;
        if (mOrientation == LinearLayoutManager.HORIZONTAL) {
            isLastItem = position == layoutManager.getItemCount() - 1/*最后一个*/ && right == viewGroup.getMeasuredWidth();
            out[0] = left;
            out[1] = 0;
        } else {
            isLastItem = position == layoutManager.getItemCount() - 1/*最后一个*/ && bottom == viewGroup.getMeasuredHeight();
            out[0] = 0;
            out[1] = top;
        }

        if (mOnPageListener != null && mCurrentPosition != position) {
            int currentPosition = mCurrentPosition;
            boolean listener = false;
            if (mOrientation == LinearLayoutManager.HORIZONTAL && (out[0] == 0 || isLastItem)) {
                listener = true;
            } else if (mOrientation == LinearLayoutManager.VERTICAL && (out[1] == 0 || isLastItem)) {
                listener = true;
            }

            if (listener) {
                mCurrentPosition = position;
                mOnPageListener.onPageSelector(mCurrentPosition);
                mOnPageListener.onPageSelector(currentPosition, mCurrentPosition);
            }
        }
        return out;
    }

    public RPagerSnapHelper setOrientation(int orientation) {
        mOrientation = orientation;
        return this;
    }

    public static abstract class OnPageListener {

        @Deprecated
        public void onPageSelector(int position) {

        }

        public void onPageSelector(int fromPosition, int toPosition) {

        }
    }
}

3:重写LoopRecyclerView
实现界面展示, 实现自动滚动, 封装功能

public class RExLoopRecyclerView extends RRecyclerView {

    private LoopLayoutManager mLoopLayoutManager;
    private boolean mInfinite = true;
    private RPagerSnapHelper.OnPageListener mOnPageListener;

    public RExLoopRecyclerView(Context context) {
        this(context, null);
    }

    public RExLoopRecyclerView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public RExLoopRecyclerView(Context context, @Nullable AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    protected void initView(Context context) {
        super.initView(context);

        autoScrollRunnable = new Runnable() {
            @Override
            public void run() {
                curScrollPosition = getCurrentPosition();

                scrollToNext();

                if (enableScroll) {
                    postDelayed(autoScrollRunnable, autoScrollTimeInterval);
                }
            }
        };

        mLoopLayoutManager = new LoopLayoutManager(getContext(), ViewPagerLayoutManager.HORIZONTAL, false);
        setInfinite(true);
        setLayoutManager(mLoopLayoutManager);

        new RExLoopRecyclerView.LoopSnapHelper().setOnPageListener(new RPagerSnapHelper.OnPageListener() {
            @Override
            public void onPageSelector(int fromPosition, int toPosition) {
                super.onPageSelector(fromPosition, toPosition);
                //L.e("onPageSelector() -> " + fromPosition + " to " + toPosition);
                if (mOnPageListener != null) {
                    mOnPageListener.onPageSelector(fromPosition, toPosition);
                }
            }
        }).attachToRecyclerView(this);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        if (mLoopLayoutManager != null) {
            mLoopLayoutManager.setItemWidthHeight(w, h);
        }
    }

    /**
     * 打开无限循环
     */
    public void setInfinite(boolean enable) {
        mInfinite = enable;
        if (mLoopLayoutManager != null) {
            mLoopLayoutManager.setInfinite(enable);
        }
    }

    /**
     * @see ViewPagerLayoutManager#setOrientation(int)
     */
    public void setOrientation(int orientation) {
        if (mLoopLayoutManager != null) {
            mLoopLayoutManager.setOrientation(orientation);
        }
    }

    /**
     * 滚动到下一个
     */
    public void scrollToNext() {
        scrollTo(true);
    }

    /**
     * 滚动到上一个
     */
    public void scrollToPrev() {
        scrollTo(false);
    }

    public void scrollTo(boolean forwardDirection) {
        if (getLayoutManager() instanceof LoopLayoutManager && getAdapter() != null) {
            final int offsetPosition;
            if (forwardDirection) {
                offsetPosition = 1;
            } else {
                offsetPosition = -1;
            }

            final int currentPosition = getCurrentPosition();

            int position = ((LoopLayoutManager) getLayoutManager()).getReverseLayout() ?
                    currentPosition - offsetPosition : currentPosition + offsetPosition;
            smoothScrollToPosition(position);
        }
    }

    public int getCurrentPosition() {
        if (getLayoutManager() instanceof LoopLayoutManager) {
            return ((LoopLayoutManager) getLayoutManager()).getCurrentPosition();
        } else {
            return RecyclerView.NO_POSITION;
        }
    }

    public void setOnPageListener(RPagerSnapHelper.OnPageListener onPageListener) {
        mOnPageListener = onPageListener;
    }
 }

RRecyclerView 是我自己封装的RecyclerView类, 没有特殊之处. 就是多了一个 自动滚动的触发机制.
如果RExLoopRecyclerView编译有错误, 可以自行实现对应功能, 或者删除报错代码.

以下是老的实现方式:

针对以上问题, 接下来一一解决:
问题1:
只需要在RecyclerView.Adapter的方法中:

@Override
public int getItemCount() {
    return Integer.MAX_VALUE;
}

可能距离真正无限个Item还是有差距, 但是达到效果还是可以的;

问题2:
其实谷歌已经帮我们实现了.

new PagerSnapHelper().attachToRecyclerView(this);

这样之后, 就可以一个一个的滚动Item了, 一行代码就实现了类似ViewPager的效果,
你还有什么理由使用ViewPager?

但是有一个缺点, 就是没有像ViewPager那样的OnPageChangeListener事件监听.
不过, 完全可以自己动手, 添加这个事件.

实现起来也是非常简单. 项目中有源码.

问题3:

@Override
public void setAdapter(Adapter adapter) {
    super.setAdapter(adapter);
    scrollToPosition(getAdapter().getItemRawCount() * 10000);//开始时的偏移量
}

只需要让开始的时候, 产生一定的位置偏移就行了.

其实思路很简单, 大家多动动脑, 动动手. 完全无压力的!
开源地址: https://github.com/angcyo/LoopRecyclerView

也许你还想学习更多, 来我的群吧, 我写代码的能力, 远大于写文章的能力:

联系作者

点此快速加群

请使用QQ扫码加群, 小伙伴们都在等着你哦!

关注我的公众号, 每天都能一起玩耍哦!

angcyo
关注
专栏目录
Android 无限循环RecyclerView的完美实现方案
fromVillageCoolBoy的博客
01-10 2283
第二步：填充完新的itemView后，就开始进行滑动了，这里直接调用 LayoutManager 的 offsetChildrenHorizontal() 方法滑动-travl 距离，travl 是通过fill方法计算出来的，通常情况下都为 dx，只有当滑动到最后一个itemView，并且循环滚动开关没有打开的时候才为0，也就是不滚动了。这个方案是挺简单，但并不完美。一是对我们的数据和索引做了计算操作，二是如果滑动到边界，再动态调整到中间，会有一个不明显的卡顿操作，使得滑动不是很顺畅。所以，直接看方案二。
Android无限循环RecyclerView的完美实现方案
08-25
主要介绍了Android无限循环RecyclerView的完美实现方案，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【番外篇】Android RecyclerView使用详解
最新发布
qq_73830179的博客
08-01 1382
RecyclerView是Android中非常受欢迎的控件，RecyclerView是官方在Android5.0之后新添加的控件，推出用来替代传统的ListView和GridView列表控件，所以如果你还在使用ListView的话可以替换为RecyclerView了。对于RecyclerView的使用根据实际项目进行说明，一些功能可能是你现在正在做的，对你有帮助也说不定。
RecyclerView无限循环
maoning20080808的专栏
05-26 575
RecyclerView无限循环，左右滑动
Android中使用RecyclerView + SnapHelper实现类似ViewPager效果
weixin_34050389的博客
03-30 273
1 . 前言 在一些特定的场景下，如照片的浏览，卡片列表滑动浏览，我们希望当滑动停止时可以将当前的照片或者卡片停留在屏幕中央，以吸引用户的焦点。在Android 中，我们可以使用RecyclerView ＋ Snaphelper来实现，SnapHelper旨在支持RecyclerView的对齐方式，也就是通过计算对齐RecyclerView中TargetView 的指定点或者容器中的任何像素...
RecyclerView：PagerSnapHelper让你体验视频上下无缝滑动播放
热门推荐
杨的博客
08-10 1万+
前言 RecyclerView在24.2.0版本中新增了SnapHelper这个辅助类，用于辅助RecyclerView在滚动结束时将Item对齐到某个位置。例如列表横向，纵向滑动时，很多时候不会让列表滑到任意位置，而是会有一定的规则限制，这时候就可以通过SnapHelper来定义对齐规则了。 SnapHelper是一个抽象类，官方提供了一个LinearSnapHelper的子类，可以让Rec...
实现RecyclerView无限自动循环滚动
03-04
实现RecyclerView滚动控件无限自动循环竖直滚动示例，有详细的注释
android-recyclerview-draft-01:了解 Android RecyclerView
05-31
Android RecyclerView 学习 Android RecyclerView 的示例项目。 布局 模型 适配器 添加 recyclerview 支持依赖 app/build.gradle appcompat添加到app/build.gradle下面的appcompat ： compile '...
Android RecyclerView打造自动循环效果
09-01
总结起来，实现Android RecyclerView的自动循环效果，关键在于自定义RecyclerView类，添加自动滚动逻辑，以及在Adapter中处理数据的无限循环。通过巧妙地调整数据索引和滚动位置，我们可以让RecyclerView看起来像是...
android-recyclerview-v7-28.0.0
11-17
在Android项目中使用`android-recyclerview-v7-28.0.0`，首先需要将`recyclerview-v7-28.0.0.jar`文件导入到项目的libs目录下，然后在项目构建配置中添加依赖。此外，还需将`res`目录下的资源文件拷贝到项目相应的...
android 自动循环,Android RecyclerView打造自动循环效果
weixin_39614146的博客
05-25 499
先看效果图主要处理的地方:1、recyclerview中adapter的item个人可以无限轮询.2、recyclerview自动滑动3、手指按下时滑动停止,手指抬起后继续自动滑动public class autopollrecyclerview extends recyclerview {private static final long time_auto_poll = 16;autopoll...
RecyclerView+PagerSnapHelper实现抖音首页翻页的Viewpager效果
08-25
主要为大家详细介绍了RecyclerView+PagerSnapHelper实现抖音首页翻页的Viewpager效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android自带的循环器视图RecyclerView的代码例子
09-02
Android自带的循环器视图RecyclerView的代码例子。用于演示RecyclerView在列表展示方面的用法，包括三个布局管理：线性布局管理器LinearLayoutManager、网格布局管理器GridLayoutManager、瀑布流网格布局管理器StaggeredGridLayoutManager
Android 5.X新特性之RecyclerView基本解析及无限复用
管满满
05-04 9811
说到RecyclerView，相信大家都不陌生，它是我们经典级ListView的升级版，升级后的RecyclerView展现了极大的灵活性。同时内部直接封装了ViewHolder，不用我们自己定义ViewHolder就能实现item的回收和复用功能。当然它肯定不止这些好处，比如我们可以自定义分割线，可以更加方便的实现列表的布局方式等等。
RecyclerView实现无限数据循环效果：JFPicker的迭代思路
weixin_43864176的博客
03-15 1473
RecyclerView实现无限数据循环效果：JFPicker的迭代思路
无限滚动AdapterViews and RecyclerView
waynee
07-12 1931
应用的一个共同的特点就是当用户欢动时自动加载更多的内容，这是通过用户滑动触发一定的阈值时发送数据请求实现的。 相同的是：信息实现滑动的效果需要定义在列表中最后一个可见项，和某些类型的阈值以便于开始在最后一项到达之前开始抓取数据，实现无限的滚动。 实现无限滚动的现象的重要之处就在于在用户滑动到最低端之前就行数据的获取，所以需要加上一个阈值来帮助实现获取数据的预期。 使用ListView和G
RecyclerView使用BaseProviderMultiAdapter实现无限循环
maoning20080808的专栏
06-02 722
RecyclerView使用BaseProviderMultiAdapter实现无限循环 主要使用BaseProviderMultiAdapter，BaseItemProvider实现无限循环，并且能点击button、item、左右无限循环滑动。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值