Questo documento si basa sulla panoramica della libreria Paging e spiega come personalizzare la soluzione di caricamento dei dati della tua app per soddisfare le esigenze della sua architettura.
Crea un elenco osservabile
In genere, il codice della UI osserva un oggetto LiveData<PagedList> (o, se utilizzi RxJava2, un oggetto Flowable<PagedList> o Observable<PagedList>), che si trova nel ViewModel della tua app.
Questo oggetto osservabile forma una connessione tra la presentazione e i contenuti dei dati dell'elenco della tua app.
Per creare uno di questi oggetti PagedList osservabili, passa un'istanza di DataSource.Factory a un oggetto LivePagedListBuilder o RxPagedListBuilder. Un oggetto DataSource carica le pagine per un singolo PagedList. La classe factory crea nuove istanze di PagedList in risposta agli aggiornamenti dei contenuti, come le invalidazioni delle tabelle del database e gli aggiornamenti della rete. La libreria di persistenza Room può fornire oggetti DataSource.Factory per te oppure puoi crearne di tuoi.
Il seguente snippet di codice mostra come creare una nuova istanza di LiveData<PagedList> nella classe ViewModel dell'app utilizzando le funzionalità di creazione di DataSource.Factory di Room:
ConcertDao
Kotlin
@Dao
interface ConcertDao {
// The Int type parameter tells Room to use a PositionalDataSource
// object, with position-based loading under the hood.
@Query("SELECT * FROM concerts ORDER BY date DESC")
fun concertsByDate(): DataSource.Factory<Int, Concert>
}
Java
@Dao
public interface ConcertDao {
// The Integer type parameter tells Room to use a PositionalDataSource
// object, with position-based loading under the hood.
@Query("SELECT * FROM concerts ORDER BY date DESC")
DataSource.Factory<Integer, Concert> concertsByDate();
}
ConcertViewModel
Kotlin
// The Int type argument corresponds to a PositionalDataSource object.
val myConcertDataSource : DataSource.Factory<Int, Concert> =
concertDao.concertsByDate()
val concertList = myConcertDataSource.toLiveData(pageSize = 50)
Java
// The Integer type argument corresponds to a PositionalDataSource object.
DataSource.Factory<Integer, Concert> myConcertDataSource =
concertDao.concertsByDate();
LiveData<PagedList<Concert>> concertList =
LivePagedListBuilder(myConcertDataSource, /* page size */ 50).build();
Definisci la tua configurazione di paging
Per configurare ulteriormente un LiveData<PagedList> per casi avanzati, puoi anche definire la tua configurazione di paging. In particolare, puoi definire i seguenti attributi:
- Dimensioni pagina: il numero di elementi in ogni pagina.
- Distanza di precaricamento: dato l'ultimo elemento visibile nell'UI di un'app, il numero di elementi oltre quest'ultimo che la libreria Paging deve tentare di recuperare in anticipo. Questo valore deve essere diverse volte superiore alle dimensioni della pagina.
- Presenza di segnaposto: determina se la UI mostra segnaposto per gli elementi dell'elenco che non hanno ancora terminato il caricamento. Per una discussione sui vantaggi e gli svantaggi dell'utilizzo dei segnaposto, scopri come fornire segnaposto nella UI.
Se vuoi un maggiore controllo su quando la libreria Paging carica un elenco dal database della tua app, passa un oggetto Executor personalizzato a LivePagedListBuilder, come mostrato nello snippet di codice seguente:
ConcertViewModel
Kotlin
val myPagingConfig = Config(
pageSize = 50,
prefetchDistance = 150,
enablePlaceholders = true
)
// The Int type argument corresponds to a PositionalDataSource object.
val myConcertDataSource : DataSource.Factory<Int, Concert> =
concertDao.concertsByDate()
val concertList = myConcertDataSource.toLiveData(
pagingConfig = myPagingConfig,
fetchExecutor = myExecutor
)
Java
PagedList.Config myPagingConfig = new PagedList.Config.Builder()
.setPageSize(50)
.setPrefetchDistance(150)
.setEnablePlaceholders(true)
.build();
// The Integer type argument corresponds to a PositionalDataSource object.
DataSource.Factory<Integer, Concert> myConcertDataSource =
concertDao.concertsByDate();
LiveData<PagedList<Concert>> concertList =
new LivePagedListBuilder<>(myConcertDataSource, myPagingConfig)
.setFetchExecutor(myExecutor)
.build();
Scegli il tipo di origine dati corretto
È importante connettersi all'origine dati che gestisce meglio la struttura dei dati di origine:
- Utilizza
PageKeyedDataSourcese le pagine che carichi incorporano i tasti Successivo o Precedente. Ad esempio, se recuperi i post sui social media dalla rete, potresti dover passare un tokennextPageda un caricamento a un caricamento successivo. - Utilizza
ItemKeyedDataSourcese devi utilizzare i dati dell'elemento N per recuperare l'elemento N+1. Ad esempio, se recuperi i thread di commenti per un'app di discussione, potresti dover passare l'ID dell'ultimo commento per ottenere i contenuti del commento successivo. - Utilizza
PositionalDataSourcese devi recuperare pagine di dati da qualsiasi posizione scelta nel datastore. Questa classe supporta la richiesta di un insieme di elementi dati a partire dalla posizione selezionata. Ad esempio, la richiesta potrebbe restituire i 50 elementi dati a partire dalla posizione 1500.
Invia una notifica quando i dati non sono validi
Quando utilizzi la libreria Paging, spetta al livello dati comunicare agli altri livelli dell'app quando una tabella o una riga non è più aggiornata. Per farlo, chiama invalidate() dalla classe DataSource che hai scelto per la tua app.
Crea le tue origini dati
Se utilizzi una soluzione di dati locali personalizzata o se carichi i dati direttamente da una rete, puoi implementare una delle sottoclassi DataSource. Il seguente snippet di codice mostra un'origine dati basata sull'ora di inizio di un determinato concerto:
Kotlin
class ConcertTimeDataSource() :
ItemKeyedDataSource<Date, Concert>() {
override fun getKey(item: Concert) = item.startTime
override fun loadInitial(
params: LoadInitialParams<Date>,
callback: LoadInitialCallback<Concert>) {
val items = fetchItems(params.requestedInitialKey,
params.requestedLoadSize)
callback.onResult(items)
}
override fun loadAfter(
params: LoadParams<Date>,
callback: LoadCallback<Concert>) {
val items = fetchItemsAfter(
date = params.key,
limit = params.requestedLoadSize)
callback.onResult(items)
}
}
Java
public class ConcertTimeDataSource
extends ItemKeyedDataSource<Date, Concert> {
@NonNull
@Override
public Date getKey(@NonNull Concert item) {
return item.getStartTime();
}
@Override
public void loadInitial(@NonNull LoadInitialParams<Date> params,
@NonNull LoadInitialCallback<Concert> callback) {
List<Concert> items =
fetchItems(params.key, params.requestedLoadSize);
callback.onResult(items);
}
@Override
public void loadAfter(@NonNull LoadParams<Date> params,
@NonNull LoadCallback<Concert> callback) {
List<Concert> items =
fetchItemsAfter(params.key, params.requestedLoadSize);
callback.onResult(items);
}
}
Puoi quindi caricare questi dati personalizzati negli oggetti PagedList creando una sottoclasse concreta di DataSource.Factory. Il seguente snippet di codice mostra come generare nuove istanze dell'origine dati personalizzata definita nello snippet di codice precedente:
Kotlin
class ConcertTimeDataSourceFactory :
DataSource.Factory<Date, Concert>() {
val sourceLiveData = MutableLiveData<ConcertTimeDataSource>()
var latestSource: ConcertDataSource?
override fun create(): DataSource<Date, Concert> {
latestSource = ConcertTimeDataSource()
sourceLiveData.postValue(latestSource)
return latestSource
}
}
Java
public class ConcertTimeDataSourceFactory
extends DataSource.Factory<Date, Concert> {
private MutableLiveData<ConcertTimeDataSource> sourceLiveData =
new MutableLiveData<>();
private ConcertDataSource latestSource;
@Override
public DataSource<Date, Concert> create() {
latestSource = new ConcertTimeDataSource();
sourceLiveData.postValue(latestSource);
return latestSource;
}
}
Considera come funzionano gli aggiornamenti dei contenuti
Quando crei oggetti PagedList osservabili, tieni presente come funzionano gli aggiornamenti dei contenuti. Se carichi i dati direttamente da un database Room, gli aggiornamenti vengono inviati automaticamente alla UI della tua app.
Quando utilizzi un'API di rete con pagine, in genere un'interazione dell'utente, ad esempio
"Scorri per aggiornare", funge da indicatore per l'annullamento della convalida di DataSource
che hai utilizzato più di recente. Quindi, richiedi una nuova istanza di quell'origine dati. Il seguente snippet di codice mostra questo comportamento:
Kotlin
class ConcertActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
// ...
concertTimeViewModel.refreshState.observe(this, Observer {
// Shows one possible way of triggering a refresh operation.
swipeRefreshLayout.isRefreshing =
it == MyNetworkState.LOADING
})
swipeRefreshLayout.setOnRefreshListener {
concertTimeViewModel.invalidateDataSource()
}
}
}
class ConcertTimeViewModel(firstConcertStartTime: Date) : ViewModel() {
val dataSourceFactory = ConcertTimeDataSourceFactory(firstConcertStartTime)
val concertList: LiveData<PagedList<Concert>> =
dataSourceFactory.toLiveData(
pageSize = 50,
fetchExecutor = myExecutor
)
fun invalidateDataSource() =
dataSourceFactory.sourceLiveData.value?.invalidate()
}
Java
public class ConcertActivity extends AppCompatActivity {
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
// ...
viewModel.getRefreshState()
.observe(this, new Observer<NetworkState>() {
// Shows one possible way of triggering a refresh operation.
@Override
public void onChanged(@Nullable MyNetworkState networkState) {
swipeRefreshLayout.isRefreshing =
networkState == MyNetworkState.LOADING;
}
};
swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshListener() {
@Override
public void onRefresh() {
viewModel.invalidateDataSource();
}
});
}
}
public class ConcertTimeViewModel extends ViewModel {
private LiveData<PagedList<Concert>> concertList;
private DataSource<Date, Concert> mostRecentDataSource;
public ConcertTimeViewModel(Date firstConcertStartTime) {
ConcertTimeDataSourceFactory dataSourceFactory =
new ConcertTimeDataSourceFactory(firstConcertStartTime);
mostRecentDataSource = dataSourceFactory.create();
concertList = new LivePagedListBuilder<>(dataSourceFactory, 50)
.setFetchExecutor(myExecutor)
.build();
}
public void invalidateDataSource() {
mostRecentDataSource.invalidate();
}
}
Fornisci la mappatura dei dati
La libreria Paging supporta le trasformazioni basate su elementi e pagine degli elementi caricati da un DataSource.
Nello snippet di codice seguente, una combinazione di nome e data del concerto viene mappata a una singola stringa contenente sia il nome che la data:
Kotlin
class ConcertViewModel : ViewModel() {
val concertDescriptions : LiveData<PagedList<String>>
init {
val concerts = database.allConcertsFactory()
.map { "${it.name} - ${it.date}" }
.toLiveData(pageSize = 50)
}
}
Java
public class ConcertViewModel extends ViewModel {
private LiveData<PagedList<String>> concertDescriptions;
public ConcertViewModel(MyDatabase database) {
DataSource.Factory<Integer, Concert> factory =
database.allConcertsFactory().map(concert ->
concert.getName() + "-" + concert.getDate());
concertDescriptions = new LivePagedListBuilder<>(
factory, /* page size */ 50).build();
}
}
Questo può essere utile se vuoi avvolgere, convertire o preparare gli articoli dopo che sono stati caricati. Poiché questa operazione viene eseguita sull'esecutore di recupero, puoi eseguire operazioni potenzialmente costose, come la lettura dal disco o l'esecuzione di query su un database separato.
Invia il tuo feedback
Condividi con noi il tuo feedback e le tue idee tramite queste risorse:
- Issue Tracker

- Segnala i problemi per consentirci di correggere i bug.
Risorse aggiuntive
Per scoprire di più sulla libreria Paging, consulta le seguenti risorse.
Esempi
Video
- Android Jetpack: manage infinite lists with RecyclerView and Paging (Google I/O '18)
- Android Jetpack: Paging
Consigliati per te
- Nota: il testo del link viene visualizzato quando JavaScript è disattivato
- Esegui la migrazione a Paging 3
- Panoramica della libreria Paging 2
- Visualizza elenchi impaginati