Chargement différé recyclerView dans android

Vous pouvez utiliser EndlessRecyclerView

Aperçu
Une application courante est de charger automatiquement plus d'éléments que l'utilisateur fait défiler les éléments (aka infini défilement). Ceci est fait par le déclenchement d'une demande pour plus de données une fois que l'utilisateur dépasse un seuil de points restants avant qu'ils ont atteint la fin.

Les approches pour ListView, GridView et RecyclerView (le successeur de ListView) sont documentés ici. Les deux sont similaires dans le code, sauf que le LayoutManager dans le RecyclerView doit être transmise à fournir les informations nécessaires pour mettre en œuvre infini défilement.

Dans les deux cas, les informations nécessaires pour mettre en œuvre le défilement de déterminer le dernier élément visible dans la liste et un certain type de valeur de seuil pour commencer l'extraction de plus de données avant le dernier élément a été atteint. Ces données peuvent être utilisées pour décider du moment de charger plus de données à partir d'une source externe:
Pour fournir l'apparence de l'infini défilement, il est important de récupérer les données avant que l'utilisateur arrive à la fin de la liste. L'ajout d'une valeur de seuil permet donc d'anticiper le besoin d'ajouter plus de données.

De mettre en œuvre avec ListView ou GridView

Chaque AdapterView (tels que ListView et GridView) a un support pour la liaison à la OnScrollListener événements qui sont déclenchés à chaque fois qu'un utilisateur fait défiler la collection. Grâce à ce système, on peut définir une base EndlessScrollListener qui prend en charge la plupart des cas d'utilisation par créer notre propre classe qui étend la classe OnScrollListener:

import android.widget.AbsListView; 
public abstract class EndlessScrollListener implements AbsListView.OnScrollListener {
//The minimum number 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;
public EndlessScrollListener() {
}
public EndlessScrollListener(int visibleThreshold) {
this.visibleThreshold = visibleThreshold;
}
public EndlessScrollListener(int visibleThreshold, int startPage) {
this.visibleThreshold = visibleThreshold;
this.startingPageIndex = startPage;
this.currentPage = startPage;
}
@Override
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) 
{
//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;
currentPage++;
}
//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.
if (!loading && (firstVisibleItem + visibleItemCount + visibleThreshold) >= totalItemCount ) {
loading = onLoadMore(currentPage + 1, totalItemCount);
}
}
//Defines the process for actually loading more data based on page
//Returns true if more data is being loaded; returns false if there is no more data to load.
public abstract boolean onLoadMore(int page, int totalItemsCount);
@Override
public void onScrollStateChanged(AbsListView view, int scrollState) {
//Don't take any action on changed
}
}

Avis que c'est une classe abstraite, et que, pour l'utiliser, vous devez étendre cette classe de base et de définir les onLoadMore méthode de récupérer les nouvelles données. Nous pouvons maintenant définir une classe anonyme au sein de toute l'activité qui s'étend EndlessScrollListener et de la lier à l'AdapterView. Par exemple:

public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
//... the usual 
ListView lvItems = (ListView) findViewById(R.id.lvItems);
//Attach the listener to the AdapterView onCreate
lvItems.setOnScrollListener(new EndlessScrollListener() {
@Override
public boolean onLoadMore(int page, int totalItemsCount) {
//Triggered only when new data needs to be appended to the list
//Add whatever code is needed to append new items to your AdapterView
loadNextDataFromApi(page); 
//or loadNextDataFromApi(totalItemsCount); 
return true; //ONLY if more data is actually being loaded; false otherwise.
}
});
}
//Append the next page of data into the adapter
//This method probably sends out a network request and appends new data items to your adapter. 
public void loadNextDataFromApi(int offset) {
//Send an API request to retrieve appropriate paginated data 
// --> Send the request including an offset value (i.e `page`) as a query parameter.
// --> Deserialize and construct new model objects from the API response
// --> Append the new data objects to the existing set of items inside the array of items
// --> Notify the adapter of the new items made with `notifyDataSetChanged()`
}
}

Maintenant que vous faites défiler, les articles seront automatiquement le remplissage en raison de la onLoadMore méthode sera déclenchée une fois que l'utilisateur traverse la visibleThreshold. Cette approche fonctionne aussi bien pour un GridView et l'auditeur donne accès à la fois à la page ainsi que le totalItemsCount pour soutenir à la fois la pagination et le décalage de base de l'extraction.

De mettre en œuvre avec RecyclerView
Nous pouvons utiliser une approche similaire avec les RecyclerView par la définition d'une interface EndlessRecyclerViewScrollListener qui nécessite une onLoadMore() la méthode pour être mis en œuvre. Le LayoutManager, qui est responsable de la RecyclerView pour le rendu, où les articles doivent être positionnés et gère le défilement, fournit des informations sur la position de défilement actuelle par rapport à la carte. Pour cette raison, nous avons besoin de passer une instance de ce LayoutManager est utilisé pour recueillir les informations nécessaires pour déterminer si la charger davantage de données.
La mise en œuvre sans fin de la pagination pour RecyclerView nécessite les étapes suivantes:

La mise en œuvre sans fin de la pagination pour RecyclerView nécessite les étapes suivantes:

1. Copie de la EndlessRecyclerViewScrollListener.java dans votre demande.

2. Appel addOnScrollListener(...) sur un RecyclerView pour permettre sans fin de la pagination. Passer une instance de EndlessRecyclerViewScrollListener et de mettre en œuvre la onLoadMore qui se déclenche à chaque fois qu'une nouvelle page doit être chargé de remplir la liste.

3. À l'intérieur de ladite onLoadMore méthode, la charge d'éléments supplémentaires dans l'adaptateur, soit par l'envoi d'une demande du réseau ou par le chargement à partir d'une autre source.

De commencer à traiter les événements de défilement pour les étapes 2 et 3, nous avons besoin d'utiliser la addOnScrollListener() la méthode dans notre Activité ou un Fragment de passer dans l'instance de l'EndlessRecyclerViewScrollListener avec le gestionnaire de configuration comme indiqué ci-dessous:

public class MainActivity extends Activity {
//Store a member variable for the listener
private EndlessRecyclerViewScrollListener scrollListener;
@Override
protected void onCreate(Bundle savedInstanceState) {
//Configure the RecyclerView
RecyclerView rvItems = (RecyclerView) findViewById(R.id.rvContacts);
LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
rvItems.setLayoutManager(linearLayoutManager);
//Retain an instance so that you can call `resetState()` for fresh searches
scrollListener = new EndlessRecyclerViewScrollListener(linearLayoutManager) {
@Override
public void onLoadMore(int page, int totalItemsCount, RecyclerView view) {
//Triggered only when new data needs to be appended to the list
//Add whatever code is needed to append new items to the bottom of the list
loadNextDataFromApi(page);
}
};
//Adds the scroll listener to RecyclerView
rvItems.addOnScrollListener(scrollListener);
}
//Append the next page of data into the adapter
//This method probably sends out a network request and appends new data items to your adapter. 
public void loadNextDataFromApi(int offset) {
//Send an API request to retrieve appropriate paginated data 
// --> Send the request including an offset value (i.e `page`) as a query parameter.
// --> Deserialize and construct new model objects from the API response
// --> Append the new data objects to the existing set of items inside the array of items
// --> Notify the adapter of the new items made with `notifyItemRangeInserted()`
}
}

https://github.com/codepath/android_guides/wiki/Endless-Scrolling-with-AdapterViews-and-RecyclerView

OriginalL'auteur Arslan Tazhibaev