Detect when RecyclerView reaches the bottom most position while scrolling

Question

I have this code for a RecyclerView.

    recyclerView = (RecyclerView)rootview.findViewById(R.id.fabric_recyclerView);
    recyclerView.setLayoutManager(layo         


        

Answer 1

I was also searching for this question but I didn't find the answer that satisfied me, so I create own realization of recyclerView.

other solutions is less precise then mine. for example: if the last item is pretty big (lot of text) then callback of other solutions will come much earlier then recyclerView realy reached bottom.

my sollution fix this issue.

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)
}

then in your activity/fragment:

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

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

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

hope it will hepl someone ;-)

Answer 2

Try This

I have used above answers it runs always when you will go at the end of recycler view,

If you want to check only one time whether it is on a bottom or not? Example:- If I have the list of 10 items whenever I go on the bottom it will display me and again if I scroll top to bottom it will not print again, and if you add more lists and you go there it will again display.

Note:- Use this method when you deal with offset in hitting API

1. Create a class named as 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. use this class like this

        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();
               }
           });
   

Its running perfect at my end, commnent me if you are getting any issue

Answer 3

Use this code for avoiding repeated calls

    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");
                
            }
        }
    });

Answer 4

Answer is in Kotlin, it will work in Java. IntelliJ should convert it for you if you copy and paste.

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)
    }
})

This will also work for LinearLayoutManager because it has the same methods used above. Namely findLastVisibleItemPosition() and getItemCount() (itemCount in Kotlin).

Answer 5

We can use Interface for get the position

Interface : Create an Interface for listener

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

Activity :

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

Adapter :

public void setOnSchrollPostionListener(OnTopReachListener topReachListener) {
    this.topReachListener = topReachListener;}@Override public void onBindViewHolder(MyViewHolder holder, int position) {if(position == 0) {
  topReachListener.onTopReached(position);}}

Answer 6

There is my implementation, it is very useful for StaggeredGridLayout.

Usage :

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

rvMain.addOnScrollListener(scrollListener);

Listener implementation :

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);
}  }