Fatal编程技术网
  • android/
  • 分页使用改型从android中滚动时的API获取下10项

分页使用改型从android中滚动时的API获取下10项

android pagination

分页使用改型从android中滚动时的API获取下10项,android,pagination,retrofit,Android,Pagination,Retrofit,在android中滚动时，使用改型从API获取下10个项目的分页在您的recycleview ScrollListener中 private static final int PAGE_START = 0; private boolean isLoading = false; private boolean isLastPage = false; private int TOTAL_PAGES = 3; //your total page private int currentPage

在android中滚动时，使用改型从API获取下10个项目的分页在您的recycleview ScrollListener中

private static final int PAGE_START = 0;
private boolean isLoading = false;  
private boolean isLastPage = false;   
private int TOTAL_PAGES = 3; //your total page
private int currentPage = PAGE_START;





rv.addOnScrollListener(new PaginationScrollListener(linearLayoutManager) {
        @Override
        protected void loadMoreItems() {
            isLoading = true;
            currentPage += 1;
            loadApi(currentPage); //pass page number as parameter in your api calls
        }

        @Override
        public int getTotalPageCount() {
            return TOTAL_PAGES;
        }

        @Override
        public boolean isLastPage() {
            return isLastPage;
        }

        @Override
        public boolean isLoading() {
            return isLoading;
        }
    });


}
更多详细信息请参阅下面的EndlessRecycleViewScrollListener类

 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(GridLayoutManager layoutManager) {
            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 (((LinearLayoutManager) mLayoutManager).findFirstCompletelyVisibleItemPosition() == 0) {
                    doPullToRefresh();
                }
            }

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

        public abstract void doPullToRefresh();

    }
相反

对于分页，如果使用带BaseAdapter的简单listview， 然后您可以按照下面的代码进行操作

使用2个arrayList进行分页。 一个是加载所有listview项（allDataList），一个是在适配器（paginationList）中设置10项

首先，使用改装加载allDataList中的所有数据

public static int itemsCount = 10; 
     //i need pagination of 10 records, so here i passed 10, you may increase this no. here as your requirement.

ArrayList<User_pojo> allDataList, paginationList;
Adapter_UserList adapter;
ListView listViewUser;
View footerView;
LayoutInflater layoutInflater;
int lastItem,preLast;
Context context;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

        context = this;
        listViewUser = (ListView) findViewById(R.id.listViewUser);

        allDataList = new ArrayList<>();
        paginationList = new ArrayList<>();
        layoutInflater = LayoutInflater.from(context);
        footerView = layoutInflater.inflate(R.layout.load_more_view, null);
        listViewUser.addFooterView(footerView);

        Call_api();

        listViewUser.setOnScrollListener(new AbsListView.OnScrollListener() {

       @Override
        public void onScrollStateChanged(AbsListView view, int scrollState) {

        }

        @Override
        public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {

           lastItem = (firstVisibleItem + visibleItemCount);
            if (lastItem == totalItemCount) {
                if (preLast != lastItem) {
                    //to avoid multiple calls for last item

                    preLast = lastItem;

                    footerView.findViewById(R.id.progress_bar).setVisibility(View.VISIBLE);
                    footerView.postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            itemsCount += 10;
                            LoadMoreList();
                            listViewUser.setSelection(lastItem - 1); //to display more loaded records @ current displayed position.
                        }
                    }, 1500);
                }
            }
        }
    });

    }


    @Override
    public void onStart() {
      super.onStart();
      LoadMoreList();

    }

public interface AppService{

    @FormUrlEncoded
    @POST("getUserList")
    Call<User_pojo> getUserList(@FieldMap(encoded = true) Map<String, String> map);

}       

void Call_api() {

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://your_api_url_here.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build();


    Call<User_pojo> call = retrofit.create(AppService.class).getUserList(getUserMap());

    call.enqueue(new Callback<User_pojo>() {
        @Override
        public void onResponse(Call<User_pojo> call, Response<User_pojo> response) {
            Log.e("Response", new Gson().toJson(response.body()));
            if (response.body().getResponse().equalsIgnoreCase("true")) {
                allDataList = response.body().getData();
                Log.e("size", allDataList.size() + "");
                LoadMoreList();
            }
        }

        @Override
        public void onFailure(Call<User_pojo> call, Throwable t) {
            t.printStackTrace();
            t.getMessage();
            Log.e("Failed", t.getMessage());
        }
    });
}

    private void LoadMoreList() {
    try {
        Log.e("size", String.valueOf(allDataList.size()));
        if (allDataList.size() >= itemsCount) {
            paginationList.clear();
            for (int i = 0; i < itemsCount; i++) {
                paginationList.add(allDataList.get(i));
            }
            Log.e("paginationList_Size", String.valueOf(paginationList.size()));
            adapter = new Adapter_UserList(context, paginationList);
        } else {
            adapter = new Adapter_UserList(context, allDataList);
            listViewUser.removeFooterView(footerView); // loaded all list then simply remove footerView.
        }

        if (footerView != null)
            footerView.findViewById(R.id.progress_bar).setVisibility(View.INVISIBLE);

        listViewUser.setAdapter(adapter);
    } catch (Exception ignored) {

    }
}


private Map<String, String> getUserMap() {
    Map<String, String> map = new HashMap<>();
    map.put("uid", "001");
    map.put("token", "5526");

    Log.e("logs", map.toString());
    return map;
}

公共静态int itemscont=10；
//我需要分页的10条记录，所以在这里我通过了10，你可以增加这个号码。在这里，你的要求。
ArrayList allDataList，分页列表；
适配器\用户列表适配器；
ListView listViewUser；
视图页脚视图；
LayoutInflater LayoutInflater；
最后一项，最后一项；
语境；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
上下文=这个；
listViewUser=（ListView）findViewById（R.id.listViewUser）；
allDataList=newArrayList（）；
paginationList=新的ArrayList（）；
layoutInflater=layoutInflater.from（上下文）；
footerView=LayoutFlater.充气（R.layout.load\u more\u视图，空）；
listViewUser.addFooterView（footerView）；
调用api（）；
listViewUser.setOnScrollListener（新的AbsListView.OnScrollListener（）{
@凌驾
公共无效onScrollStateChanged（AbsListView视图，int scrollState）{
}
@凌驾
public void onScroll（AbsListView视图、int firstVisibleItem、int visibleItemCount、int totalItemCount）{
lastItem=（firstVisibleItem+visibleItemCount）；
如果（lastItem==totalItemCount）{
如果（最后一个！=最后一个项目）{
//避免多次调用最后一项
最后一项=最后一项；
footerView.findViewById（R.id.progress\u bar）.setVisibility（View.VISIBLE）；
footerView.postDelayed（新的Runnable（）{
@凌驾
公开募捐{
itemsCount+=10；
LoadMoreList（）；
listViewUser.setSelection（lastItem-1）；//在当前显示位置显示更多加载的记录。
}
}, 1500);
}
}
}
});
}
@凌驾
public void onStart（）{
super.onStart（）；
LoadMoreList（）；
}
公共接口应用服务{
@FormUrlEncoded
@POST（“getUserList”）
调用getUserList（@FieldMap（encoded=true）Map）；
}       
void Call_api（）{
改装改装=新改装.Builder（）
.baseUrl（“http://your_api_url_here.com/")
.addConverterFactory（GsonConverterFactory.create（））
.build（）；
Call Call=reformation.create（AppService.class）.getUserList（getUserMap（））；
call.enqueue（新回调（）{
@凌驾
公共void onResponse（调用、响应）{
Log.e（“Response”，new Gson（）.toJson（Response.body（））；
if（response.body（）.getResponse（）.equalsIgnoreCase（“true”））{
allDataList=response.body（）.getData（）；
Log.e（“size”，allDataList.size（）+）；
LoadMoreList（）；
}
}
@凌驾
失败时公共无效（调用调用，可丢弃的t）{
t、 printStackTrace（）；
t、 getMessage（）；
Log.e（“失败”，t.getMessage（））；
}
});
}
私有void LoadMoreList（）{
试一试{
Log.e（“size”，String.valueOf（allDataList.size（））；
如果（allDataList.size（）>=itemsCount）{
paginationList.clear（）；
对于（int i=0；i
希望有此帮助。

使用
RecyclerView.OnScrollListener
和
RecyclerView.LayoutManager
可以找到最后一个可见项的索引。如果索引等于总项目数1，则可以将其视为列表的末尾并加载下一页。

recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
    @Override
    public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
        if (dy > 0) //check for scroll down
        {
            int totalItemCount = layoutManager.getItemCount();
            int lastVisibleItemPosition = layoutManager.findLastVisibleItemPosition();
            if (!loading && lastVisibleItemPosition == totalItemCount - 1) {
                loading = true;
                currentPage = currentPage + 1;
                if (!dynamicPages.equalsIgnoreCase("")) {
                    loadMoreData(currentPage);
                }
            }
        }
    }
});
如果您使用的是recycler视图，则使用Recyclerview.AddOnScrollListener从服务器加载前10个数据，然后在列表底部找到最后一个可见项的id（如果您的后端为每个数据提供了一些id）在您的服务呼叫中，然后将另外10个数据添加到您现有的列表中，并继续添加其他数据。为什么要添加这一行2次？rv.addOnScrollListener（）；根据您的代码审查，我认为您的自定义EndlessScrollook存在一些问题不是问题，只要确保EndlessScroll在到达列表底部时返回正确的位置将日志放入滚动侦听器，然后检查正确的位置，否则让我知道我会尽我所能帮助您进行编辑，你检查过这个了吗？你能告诉我如何使用回收服务吗？你可以共享适配器吗？请添加你所做工作的最低说明。请提供问题的正确解释 
recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
    @Override
    public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
        if (dy > 0) //check for scroll down
        {
            int totalItemCount = layoutManager.getItemCount();
            int lastVisibleItemPosition = layoutManager.findLastVisibleItemPosition();
            if (!loading && lastVisibleItemPosition == totalItemCount - 1) {
                loading = true;
                currentPage = currentPage + 1;
                if (!dynamicPages.equalsIgnoreCase("")) {
                    loadMoreData(currentPage);
                }
            }
        }
    }
});