滚动时检测RecyclerView何时到达最底部

94

我有一个RecyclerView的代码。

    recyclerView = (RecyclerView)rootview.findViewById(R.id.fabric_recyclerView);
    recyclerView.setLayoutManager(layoutManager);
    recyclerView.addItemDecoration(new RV_Item_Spacing(5));
    FabricAdapter fabricAdapter=new FabricAdapter(ViewAdsCollection.getFabricAdsDetailsAsArray());
    recyclerView.setAdapter(fabricAdapter);

我需要知道滚动时RecyclerView何时到达最底端的位置。可能吗 ？如果是，怎么办？

android  scroll  android-recyclerview 
— 阿德里安
source
— Raghavendra
— Bhavesh Rangani
1
recyclerView.canScrollVertically（int direction）; 我们必须在此处传递的参数应该是什么？
— 阿德里安
@Adrian，以防万一您仍然对这个问题感兴趣：)））） stackoverflow.com/a/48514857/6674369
— Andriy Antonov

Answers:

178

还有一种简单的方法 

recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
    @Override
    public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
        super.onScrollStateChanged(recyclerView, newState);

        if (!recyclerView.canScrollVertically(1)) {
            Toast.makeText(YourActivity.this, "Last", Toast.LENGTH_LONG).show();

        }
    }
});

方向整数：-1表示向上，1表示向下，0始终返回false。

— Kaustubh Bhagwat
source
17
onScrolled（）可以防止两次检测。
— 伊恩·旺巴
我无法将ScrollListnerEvent添加到“我的RecyclerView”中。onScrollStateChanged中的代码不执行。
— Sandeep Yohans
1
如果您只想触发一次（显示Toast一次），则将boolean标志（类成员变量）添加到if语句，并在if语句中将其设置为true，例如： if (!recyclerView.canScrollVertically(1) && !mHasReachedBottomOnce) { mHasReachedBottomOnce = true Toast.makeText(YourActivity.this, "Last", Toast.LENGTH_LONG).show();}
— bastami82 '18
@ bastami82我按照您的建议使用该技巧来防止两次吐司，但是它不起作用
— Vishwa Pratap
4
添加newState == RecyclerView.SCROLL_STATE_IDLE到if语句中将起作用。
— 李俊和
58

使用此代码避免重复调用

    recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
        @Override
        public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
            super.onScrollStateChanged(recyclerView, newState);

            if (!recyclerView.canScrollVertically(1) && newState==RecyclerView.SCROLL_STATE_IDLE) {
                Log.d("-----","end");
                
            }
        }
    });
— 米林德·乔杜里
source
2
我尝试过可能会回答，但这对我来说是简单而完美的。感谢
— Vishwa Pratap
@Venkatesh欢迎。
— 米林德·乔杜里
唯一没有给我任何其他错误的答案
— Fluffy T Rex
@TheFluffyTRex感谢
— Milind Chaudhary
46

只需在您的recyclerview上实现addOnScrollListener（）即可。然后在滚动侦听器内部实现以下代码。

RecyclerView.OnScrollListener mScrollListener = new RecyclerView.OnScrollListener() {
        @Override
        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
            if (mIsLoading)
                return;
            int visibleItemCount = mLayoutManager.getChildCount();
            int totalItemCount = mLayoutManager.getItemCount();
            int pastVisibleItems = mLayoutManager.findFirstVisibleItemPosition();
            if (pastVisibleItems + visibleItemCount >= totalItemCount) {
                //End of list
            }
        }
    };
— 菲比·费利克斯
source
1
您能解释一下mIsLoading吗？您在哪里设置或更改值。
— MiguelHincapieC
mLoading只是一个布尔变量，指示视图是否处于活动状态。例如 如果应用正在填充recyclerview，则在列表填充后，mLoading将为true，而为false。
— Febi M Felix
1
该解决方案无法正常工作。看一看stackoverflow.com/a/48514857/6674369
— Andriy Antonov '18
3
无法解析方法'findFirstVisibleItemPosition'上android.support.v7.widget.RecyclerView
— 伊曼Marashi
2
@Iman Marashi，您需要投射：(recyclerView.layoutManager as LinearLayoutManager).findFirstVisibleItemPosition()。这项工作。
— bitvale
16

答案在Kotlin中，它将在Java中工作。如果您复制和粘贴，IntelliJ应该为您转换。

recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener(){

    override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {

        // 3 lines below are not needed.
        Log.d("TAG","Last visible item is: ${gridLayoutManager.findLastVisibleItemPosition()}")
        Log.d("TAG","Item count is: ${gridLayoutManager.itemCount}")
        Log.d("TAG","end? : ${gridLayoutManager.findLastVisibleItemPosition() == gridLayoutManager.itemCount-1}")

        if(gridLayoutManager.findLastVisibleItemPosition() == gridLayoutManager.itemCount-1){
            // We have reached the end of the recycler view.
        }

        super.onScrolled(recyclerView, dx, dy)
    }
})

这也将适用，LinearLayoutManager因为它具有与上面相同的方法。即findLastVisibleItemPosition()和getItemCount()（itemCount在Kotlin中）。

— 达卡
source
6
好approache，但一个问题是，如果循环将执行multipltimes语句
— 毗湿奴
您是否有针对相同问题的解决方案
— Vishwa Pratap
1
@Vishnu一个简单的布尔变量可以解决这个问题。
— 达卡，
8

我无法通过上述答案获得完美的解决方案，因为即使在 onScrolled

override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
            super.onScrolled(recyclerView, dx, dy)
           if( !recyclerView.canScrollVertically(RecyclerView.FOCUS_DOWN))
               context?.toast("Scroll end reached")
        }
— 马诺·佩鲁马拉斯（Manoj Perumarath）
source
1
但是recyclerView.canScrollVertically(direction)direction只是任意整数+ vs-，因此如果在底部，则可以为4；在顶部，则可以为-12。
— Xenolion
5

试试这个

我已经在上面的答案中使用了它，它总是在您进入回收站视图的末尾时运行，

如果只想检查一次是否在底部？ 例如：-如果我每次有10个项目的清单，当我在底部浏览时，它将显示我；如果我从上到下滚动，它将不再显示；如果添加更多列表，则将再次显示。

注意：-在点击API处理偏移量时，请使用此方法

  1. 创建一个名为EndlessRecyclerViewScrollListener的类

        import android.support.v7.widget.GridLayoutManager;
    import android.support.v7.widget.LinearLayoutManager;
    import android.support.v7.widget.RecyclerView;
    import android.support.v7.widget.StaggeredGridLayoutManager;

    public abstract class EndlessRecyclerViewScrollListener extends RecyclerView.OnScrollListener {
        // The minimum amount of items to have below your current scroll position
        // before loading more.
        private int visibleThreshold = 5;
        // The current offset index of data you have loaded
        private int currentPage = 0;
        // The total number of items in the dataset after the last load
        private int previousTotalItemCount = 0;
        // True if we are still waiting for the last set of data to load.
        private boolean loading = true;
        // Sets the starting page index
        private int startingPageIndex = 0;

        RecyclerView.LayoutManager mLayoutManager;

        public EndlessRecyclerViewScrollListener(LinearLayoutManager layoutManager) {
            this.mLayoutManager = layoutManager;
        }

    //    public EndlessRecyclerViewScrollListener() {
    //        this.mLayoutManager = layoutManager;
    //        visibleThreshold = visibleThreshold * layoutManager.getSpanCount();
    //    }

        public EndlessRecyclerViewScrollListener(StaggeredGridLayoutManager layoutManager) {
            this.mLayoutManager = layoutManager;
            visibleThreshold = visibleThreshold * layoutManager.getSpanCount();
        }

        public int getLastVisibleItem(int[] lastVisibleItemPositions) {
            int maxSize = 0;
            for (int i = 0; i < lastVisibleItemPositions.length; i++) {
                if (i == 0) {
                    maxSize = lastVisibleItemPositions[i];
                }
                else if (lastVisibleItemPositions[i] > maxSize) {
                    maxSize = lastVisibleItemPositions[i];
                }
            }
            return maxSize;
        }

        // This happens many times a second during a scroll, so be wary of the code you place here.
        // We are given a few useful parameters to help us work out if we need to load some more data,
        // but first we check if we are waiting for the previous load to finish.
        @Override
        public void onScrolled(RecyclerView view, int dx, int dy) {
            int lastVisibleItemPosition = 0;
            int totalItemCount = mLayoutManager.getItemCount();

            if (mLayoutManager instanceof StaggeredGridLayoutManager) {
                int[] lastVisibleItemPositions = ((StaggeredGridLayoutManager) mLayoutManager).findLastVisibleItemPositions(null);
                // get maximum element within the list
                lastVisibleItemPosition = getLastVisibleItem(lastVisibleItemPositions);
            } else if (mLayoutManager instanceof GridLayoutManager) {
                lastVisibleItemPosition = ((GridLayoutManager) mLayoutManager).findLastVisibleItemPosition();
            } else if (mLayoutManager instanceof LinearLayoutManager) {
                lastVisibleItemPosition = ((LinearLayoutManager) mLayoutManager).findLastVisibleItemPosition();
            }

            // If the total item count is zero and the previous isn't, assume the
            // list is invalidated and should be reset back to initial state
            if (totalItemCount < previousTotalItemCount) {
                this.currentPage = this.startingPageIndex;
                this.previousTotalItemCount = totalItemCount;
                if (totalItemCount == 0) {
                    this.loading = true;
                }
            }
            // If it’s still loading, we check to see if the dataset count has
            // changed, if so we conclude it has finished loading and update the current page
            // number and total item count.
            if (loading && (totalItemCount > previousTotalItemCount)) {
                loading = false;
                previousTotalItemCount = totalItemCount;
            }

            // If it isn’t currently loading, we check to see if we have breached
            // the visibleThreshold and need to reload more data.
            // If we do need to reload some more data, we execute onLoadMore to fetch the data.
            // threshold should reflect how many total columns there are too
            if (!loading && (lastVisibleItemPosition + visibleThreshold) > totalItemCount) {
                currentPage++;
                onLoadMore(currentPage, totalItemCount, view);
                loading = true;
            }
        }

        // Call this method whenever performing new searches
        public void resetState() {
            this.currentPage = this.startingPageIndex;
            this.previousTotalItemCount = 0;
            this.loading = true;
        }

        // Defines the process for actually loading more data based on page
        public abstract void onLoadMore(int page, int totalItemsCount, RecyclerView view);

    }

  2. 这样使用此类

         LinearLayoutManager linearLayoutManager = new LinearLayoutManager(getActivity());
        recyclerView.setLayoutManager(linearLayoutManager);
        recyclerView.addOnScrollListener(new EndlessRecyclerViewScrollListener( linearLayoutManager) {
            @Override
            public void onLoadMore(int page, int totalItemsCount, RecyclerView view) {
                Toast.makeText(getActivity(),"LAst",Toast.LENGTH_LONG).show();
            }
        });

它在我的末端运行完美，如果遇到任何问题，请告诉我

— 苏尼尔
source
这非常有帮助:)
— Devrath
4

这是我的实现，对于来说非常有用StaggeredGridLayout。

用法： 

private EndlessScrollListener scrollListener =
        new EndlessScrollListener(new EndlessScrollListener.RefreshList() {
            @Override public void onRefresh(int pageNumber) {
                //end of the list
            }
        });

rvMain.addOnScrollListener(scrollListener);

侦听器实现：

class EndlessScrollListener extends RecyclerView.OnScrollListener {
private boolean isLoading;
private boolean hasMorePages;
private int pageNumber = 0;
private RefreshList refreshList;
private boolean isRefreshing;
private int pastVisibleItems;

EndlessScrollListener(RefreshList refreshList) {
    this.isLoading = false;
    this.hasMorePages = true;
    this.refreshList = refreshList;
}

@Override public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
    super.onScrolled(recyclerView, dx, dy);
    StaggeredGridLayoutManager manager =
            (StaggeredGridLayoutManager) recyclerView.getLayoutManager();

    int visibleItemCount = manager.getChildCount();
    int totalItemCount = manager.getItemCount();
    int[] firstVisibleItems = manager.findFirstVisibleItemPositions(null);
    if (firstVisibleItems != null && firstVisibleItems.length > 0) {
        pastVisibleItems = firstVisibleItems[0];
    }

    if (visibleItemCount + pastVisibleItems >= totalItemCount && !isLoading) {
        isLoading = true;
        if (hasMorePages && !isRefreshing) {
            isRefreshing = true;
            new Handler().postDelayed(new Runnable() {
                @Override public void run() {
                    refreshList.onRefresh(pageNumber);
                }
            }, 200);
        }
    } else {
        isLoading = false;
    }
}

public void noMorePages() {
    this.hasMorePages = false;
}

void notifyMorePages() {
    isRefreshing = false;
    pageNumber = pageNumber + 1;
}

interface RefreshList {
    void onRefresh(int pageNumber);
}  }
— 亚历山大·蒂莫申科（Aleksey Timoshchenko）
source
为什么要增加200毫秒的延迟来回调？
— 玛尼
@Mani我现在还不记得确切的时间，但也许我只是为了获得流畅的效果而这么做了
— Aleksey Timoshchenko
3

我也在寻找这个问题，但没有找到令我满意的答案，因此我创建了自己的recyclerView实现。

其他解决方案不如我的精确。例如：如果最后一个项目很大（大量文本），则其他解决方案的回调将更早进行，然后recyclerView真正到达底部。

我的解决方案解决了这个问题。

class CustomRecyclerView: RecyclerView{

    abstract class TopAndBottomListener{
        open fun onBottomNow(onBottomNow:Boolean){}
        open fun onTopNow(onTopNow:Boolean){}
    }


    constructor(c:Context):this(c, null)
    constructor(c:Context, attr:AttributeSet?):super(c, attr, 0)
    constructor(c:Context, attr:AttributeSet?, defStyle:Int):super(c, attr, defStyle)


    private var linearLayoutManager:LinearLayoutManager? = null
    private var topAndBottomListener:TopAndBottomListener? = null
    private var onBottomNow = false
    private var onTopNow = false
    private var onBottomTopScrollListener:RecyclerView.OnScrollListener? = null


    fun setTopAndBottomListener(l:TopAndBottomListener?){
        if (l != null){
            checkLayoutManager()

            onBottomTopScrollListener = createBottomAndTopScrollListener()
            addOnScrollListener(onBottomTopScrollListener)
            topAndBottomListener = l
        } else {
            removeOnScrollListener(onBottomTopScrollListener)
            topAndBottomListener = null
        }
    }

    private fun createBottomAndTopScrollListener() = object :RecyclerView.OnScrollListener(){
        override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
            checkOnTop()
            checkOnBottom()
        }
    }

    private fun checkOnTop(){
        val firstVisible = linearLayoutManager!!.findFirstCompletelyVisibleItemPosition()
        if(firstVisible == 0 || firstVisible == -1 && !canScrollToTop()){
            if (!onTopNow) {
                onTopNow = true
                topAndBottomListener?.onTopNow(true)
            }
        } else if (onTopNow){
            onTopNow = false
            topAndBottomListener?.onTopNow(false)
        }
    }

    private fun checkOnBottom(){
        var lastVisible = linearLayoutManager!!.findLastCompletelyVisibleItemPosition()
        val size = linearLayoutManager!!.itemCount - 1
        if(lastVisible == size || lastVisible == -1 && !canScrollToBottom()){
            if (!onBottomNow){
                onBottomNow = true
                topAndBottomListener?.onBottomNow(true)
            }
        } else if(onBottomNow){
            onBottomNow = false
            topAndBottomListener?.onBottomNow(false)
        }
    }


    private fun checkLayoutManager(){
        if (layoutManager is LinearLayoutManager)
            linearLayoutManager = layoutManager as LinearLayoutManager
        else
            throw Exception("for using this listener, please set LinearLayoutManager")
    }

    private fun canScrollToTop():Boolean = canScrollVertically(-1)
    private fun canScrollToBottom():Boolean = canScrollVertically(1)
}

然后在您的活动/片段中：

override fun onCreate() {
    customRecyclerView.layoutManager = LinearLayoutManager(context)
}

override fun onResume() {
    super.onResume()
    customRecyclerView.setTopAndBottomListener(this)
}

override fun onStop() {
    super.onStop()
    customRecyclerView.setTopAndBottomListener(null)
}

希望它将帮助某人;-)

— 安德里·安东诺夫（Andriy Antonov）
source
1
别人不满意的解决方案的哪一部分？您应该先解释一下，然后再提出答案
— Zam Sunk '18
@ZamSunk cos其他解决方案不如我的精确。例如，如果最后一个项目非常少（文本部分），则其他解决方案的回调将更早进行，然后recyclerView真正到达底部。我的解决方案解决了这个问题。
— 安德里·安东诺夫
2

在对该线程中的大多数其他答案都不满意之后，我发现我认为更好的东西不在这里。

recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
    @Override
    public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
        if (!recyclerView.canScrollVertically(1) && dy > 0)
        {
             //scrolled to bottom
        }else if (!recyclerView.canScrollVertically(-1) && dy < 0)
        {
            //scrolled to bottom
        }
    }
});

这很简单，当您滚动到顶部或底部时，在所有情况下都将只击中一次。

— 没有人392
source
0

这是我的解决方案：

    val onScrollListener = object : RecyclerView.OnScrollListener() {

    override fun onScrolled(recyclerView: RecyclerView?, dx: Int, dy: Int) {
        directionDown = dy > 0
    }

    override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
        if (recyclerView.canScrollVertically(1).not()
                && state != State.UPDATING
                && newState == RecyclerView.SCROLL_STATE_IDLE
                && directionDown) {
               state = State.UPDATING
            // TODO do what you want  when you reach bottom, direction
            // is down and flag for non-duplicate execution
        }
    }
}
— 亚历克斯·泽卡卡洛
source
你从哪儿得到state 的那个枚举？
— raditya gumay
State是我的一个枚举，这是检查屏幕状态的标志（我在应用程序上使用了具有数据绑定的MVVM）
— Alex Zezekalo 18/08/27
如果没有互联网连接，您将如何实施回调？
— Aks4125
0

我们可以使用Interface来获取位置

接口： 为侦听器创建接口

public interface OnTopReachListener { void onTopReached(int position);}

活动内容：

mediaRecycleAdapter = new MediaRecycleAdapter(Class.this, taskList); recycle.setAdapter(mediaRecycleAdapter); mediaRecycleAdapter.setOnSchrollPostionListener(new OnTopReachListener() {
@Override
public void onTopReached(int position) {
    Log.i("Position","onTopReached "+position);  
}
});

适配器：

public void setOnSchrollPostionListener(OnTopReachListener topReachListener) {
    this.topReachListener = topReachListener;}@Override public void onBindViewHolder(MyViewHolder holder, int position) {if(position == 0) {
  topReachListener.onTopReached(position);}}
— Amuthan S
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.