Java 使用StaggedGridLayoutManager和recyclerView进行分页

您好，我需要使用StaggedGridLayoutManager使用RecycleView进行无限滚动（分页）。分页正在工作，但问题是在滚动时调用了很多次

onLoadMore（）

函数，这导致了问题，下面是我的代码：

 newSearchAdapter = new NewSearchAdapter(getActivity(), gridData);
            StaggeredGridLayoutManager mLayoutManager;
            mLayoutManager = new StaggeredGridLayoutManager(2, StaggeredGridLayoutManager.VERTICAL);
            mLayoutManager.setGapStrategy(StaggeredGridLayoutManager.GAP_HANDLING_NONE);
            rv_NewProfilesGrid.setLayoutManager(mLayoutManager);
            rv_NewProfilesGrid.setAdapter(newSearchAdapter);
            rv_NewProfilesGrid.addOnScrollListener(new EndlessRecyclerOnScrollListenerStaggeredLayoutmanager(mLayoutManager) {
                @Override
                public void onLoadMore(int current_page) {

                  //calling the api

                }
            });

这是我的滚动列表

我认为这里的问题在于

getFirstVisibleItems（）

函数，因为使用GridLayoutManger或LinearLayoutManager它返回一个整数，而使用StaggeredLayout它返回一个整数数组，因此我执行了以下操作：

public abstract class EndlessRecyclerOnScrollListenerStaggeredLayoutmanager extends RecyclerView.OnScrollListener {
    public static String TAG = EndlessRecyclerOnScrollListenerStaggeredLayoutmanager.class.getSimpleName();
    private int scrolledDistance = 0;
    private boolean controlsVisible = false;

    private boolean loading = true; // True if we are still waiting for the last set of data to load.
    private int visibleThreshold = 5; // The minimum amount of items to have below your current scroll position before loading more.
    public static boolean  loadOneTime = false;
    private int pastVisibleItems, visibleItemCount, totalItemCount,previousTotal;

    private int current_page = 1;

    private StaggeredGridLayoutManager mStaggeredGridLayoutManager;

    public EndlessRecyclerOnScrollListenerStaggeredLayoutmanager(StaggeredGridLayoutManager staggeredGridLayoutManager) {
        this.mStaggeredGridLayoutManager = staggeredGridLayoutManager;

    }


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

        visibleItemCount = recyclerView.getChildCount();
        totalItemCount = mStaggeredGridLayoutManager.getItemCount();

        int[] firstVisibleItems = null;
        firstVisibleItems = mStaggeredGridLayoutManager.findFirstVisibleItemPositions(firstVisibleItems);
        if (firstVisibleItems != null && firstVisibleItems.length > 0) {
            pastVisibleItems = firstVisibleItems[0];
        }


        if (loading) {
            if ((visibleItemCount + pastVisibleItems) >= totalItemCount) {
                loading = false;

                previousTotal = totalItemCount;
            }
        }
        if (!loading && (totalItemCount - visibleItemCount)
                <= (pastVisibleItems + visibleThreshold)) {
            // End has been reached

            // Do something
            current_page++;
            loadOneTime=false;
            onLoadMore(current_page);

            loading = true;
        }

        if (scrolledDistance > 1 && controlsVisible) {
            controlsVisible = false;
            scrolledDistance = 0;
        } else if (scrolledDistance < -1 && !controlsVisible) {
            controlsVisible = true;
            scrolledDistance = 0;
        }

        if ((controlsVisible && dy > 0) || (!controlsVisible && dy < 0)) {
            scrolledDistance += dy;
        }
    }

    public abstract void onLoadMore(int current_page);


}

公共抽象类endlessRecycleronScrollListener交错布局管理器扩展了RecyclerView.OnScrollListener{
public static String TAG=endlessRecycleronScrollListenerStaggedLayoutManager.class.getSimpleName（）；
私有int scrolledDistance=0；
私有布尔控制visible=false；
private boolean load=true；//如果仍在等待加载最后一组数据，则为true。
private int visibleThreshold=5；//在加载更多内容之前，在当前滚动位置下方的最小项目数。
公共静态布尔loadOneTime=false；
private int pastVisibleItems、visibleItemCount、totalItemCount、previousTotal；
私有int当前页面=1；
私密的StaggeredGridLayoutManager mStaggeredGridLayoutManager；
public endlessRecycleronScrollListenerStaggedLayoutManager（StaggedGridLayoutManager StaggedGridLayoutManager）{
this.mStaggeredGridLayoutManager=staggedgridlayoutmanager；
}
@凌驾
已填空的公共空间（RecyclerView RecyclerView、int dx、int dy）{
super.onScrolled（recyclerView、dx、dy）；
visibleItemCount=recyclerView.getChildCount（）；
totalItemCount=mStaggeredGridLayoutManager.getItemCount（）；
int[]firstVisibleItems=null；
firstVisibleItems=mStaggeredGridLayoutManager.findFirstVisibleItemPositions（firstVisibleItems）；
if（firstVisibleItems！=null&&firstVisibleItems.length>0）{
pastVisibleItems=firstVisibleItems[0]；
}
如果（装载）{
如果（（visibleItemCount+pastVisibleItems）>=totalItemCount）{
加载=假；
previousTotal=totalItemCount；
}
}
如果（！loading&&（totalItemCount-visibleItemCount）
1和控制（可视）（&C）{
controlsVisible=false；
滚动距离=0；
}else if（滚动距离<-1&！控件可见）{
controlsVisible=true；
滚动距离=0；
}
如果（（controlsVisible&&dy>0）| |（！controlsVisible&&dy<0））{
滚动距离+=dy；
}
}
公共摘要void onLoadMore（在当前页面）；
}

试试这个。我从一个堆栈溢出答案中借用了它，又借用了另一个答案，并将它们结合起来，最终解决了它

import android.util.Log
import androidx.recyclerview.widget.GridLayoutManager
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.recyclerview.widget.StaggeredGridLayoutManager

abstract class PaginationScrollListener constructor() :
    RecyclerView.OnScrollListener() {

    private lateinit var mLayoutManager: RecyclerView.LayoutManager

    constructor(layoutManager: GridLayoutManager) : this() {
        this.mLayoutManager = layoutManager
    }

    constructor(layoutManager: StaggeredGridLayoutManager) : this() {
        this.mLayoutManager = layoutManager
    }

    constructor(layoutManager: LinearLayoutManager) : this() {
        this.mLayoutManager = layoutManager
    }


    /*
     Method gets callback when user scroll the search list
     */
    override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
        super.onScrolled(recyclerView, dx, dy)

        val visibleItemCount = mLayoutManager.childCount
        val totalItemCount = mLayoutManager.itemCount
        var firstVisibleItemPosition = 0

        when (mLayoutManager) {
            is StaggeredGridLayoutManager -> {
                val firstVisibleItemPositions =
                    (mLayoutManager as StaggeredGridLayoutManager).findFirstVisibleItemPositions(null)
                // get maximum element within the list
                firstVisibleItemPosition = firstVisibleItemPositions[0]
            }
            is GridLayoutManager -> {
                firstVisibleItemPosition =
                    (mLayoutManager as GridLayoutManager).findFirstVisibleItemPosition()
            }
            is LinearLayoutManager -> {
                firstVisibleItemPosition =
                    (mLayoutManager as LinearLayoutManager).findFirstVisibleItemPosition()
            }
        }
        if (!isLoading && !isLastPage) {
            if (visibleItemCount + firstVisibleItemPosition >= totalItemCount
                && firstVisibleItemPosition >= 0
            ) {
                Log.i(TAG, "Loading more items")
                loadMoreItems()
            }
        }
    }

    protected abstract fun loadMoreItems()

    abstract val isLastPage: Boolean
    abstract val isLoading: Boolean

    companion object {
        private val TAG = PaginationScrollListener::class.java.simpleName
    }
}

并以这种方式在“回收者”视图中使用它

rvCategoryProducts.addOnScrollListener(object :
            PaginationScrollListener(layoutManager) {
            override fun loadMoreItems() {
                vm.isLoading = true
                vm.currentPage++

                GlobalScope.launch {
                    vm.getCategoryProductByCatId(vm.id, vm.currentPage)
                }
            }

            override val isLastPage: Boolean
                get() = vm.isLastPage
            override val isLoading: Boolean
                get() = vm.isLoading
        })

---

我也有同样的问题，但是在使用分页库时遇到了这个github要点，我认为它会解决您的问题