Ten dokument stanowi uzupełnienie omówienia biblioteki Paging i zawiera informacje o tym, jak dostosować rozwiązanie do wczytywania danych w aplikacji, aby spełniało wymagania jej architektury.
Tworzenie listy obserwowalnej
Zwykle kod interfejsu obserwuje obiekt LiveData<PagedList> (lub, jeśli używasz RxJava2, obiekt Flowable<PagedList> lub Observable<PagedList>), który znajduje się w ViewModel aplikacji.
Ten obiekt obserwowalny tworzy połączenie między prezentacją a zawartością danych listy aplikacji.
Aby utworzyć jeden z tych obserwowalnych obiektów PagedList, przekaż instancję DataSource.Factory do obiektu LivePagedListBuilder lub RxPagedListBuilder. Obiekt DataSource wczytuje strony dla pojedynczego elementu PagedList. Klasa fabryczna tworzy nowe instancje PagedList w odpowiedzi na aktualizacje treści, takie jak unieważnienia tabeli bazy danych i odświeżenia sieci. Biblioteka trwałości danych Room może dostarczyć obiekty DataSource.Factory lub możesz utworzyć własne.
Poniższy fragment kodu pokazuje, jak utworzyć nową instancję LiveData<PagedList> w klasie ViewModel aplikacji za pomocą funkcji tworzenia DataSource.Factory w 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();
Definiowanie własnej konfiguracji stronicowania
Aby skonfigurować LiveData<PagedList> w bardziej zaawansowanych przypadkach, możesz też zdefiniować własną konfigurację stronicowania. W szczególności możesz zdefiniować te atrybuty:
- Rozmiar strony: liczba elementów na każdej stronie.
- Odległość pobierania z wyprzedzeniem: liczba elementów poza ostatnim widocznym elementem w interfejsie aplikacji, które biblioteka stronicowania powinna spróbować pobrać z wyprzedzeniem. Ta wartość powinna być kilka razy większa niż rozmiar strony.
- Obecność obiektów zastępczych: określa, czy interfejs wyświetla obiekty zastępcze elementów listy, które nie zostały jeszcze wczytane. Dyskusję na temat zalet i wad korzystania z obiektów zastępczych znajdziesz w artykule Udostępnianie obiektów zastępczych w interfejsie.
Jeśli chcesz mieć większą kontrolę nad tym, kiedy biblioteka stronicowania wczytuje listę z bazy danych aplikacji, przekaż niestandardowy obiekt Executor do LivePagedListBuilder, jak pokazano w tym fragmencie kodu:
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();
Wybierz prawidłowy typ źródła danych
Ważne jest, aby połączyć się ze źródłem danych, które najlepiej obsługuje strukturę danych źródłowych:
- Użyj
PageKeyedDataSource, jeśli wczytywane strony zawierają klawisze następnej lub poprzedniej strony. Jeśli na przykład pobierasz posty z mediów społecznościowych, może być konieczne przekazanie tokenanextPagez jednego wczytywania do kolejnego. - Użyj
ItemKeyedDataSource, jeśli chcesz użyć danych z elementu N do pobrania elementu N+1. Jeśli na przykład pobierasz komentarze z wątkami do aplikacji do dyskusji, może być konieczne przekazanie identyfikatora ostatniego komentarza, aby uzyskać zawartość następnego komentarza. - Jeśli chcesz pobrać strony danych z dowolnej lokalizacji w magazynie danych, użyj
PositionalDataSource. Ta klasa obsługuje żądanie zestawu elementów danych, zaczynając od dowolnej wybranej lokalizacji. Na przykład żądanie może zwrócić 50 elementów danych, zaczynając od lokalizacji 1500.
Powiadamiaj, gdy dane są nieprawidłowe
Podczas korzystania z biblioteki Paging to warstwa danych powiadamia inne warstwy aplikacji, gdy tabela lub wiersz staną się nieaktualne. Aby to zrobić, wywołaj invalidate() z klasy DataSource wybranej dla aplikacji.
Tworzenie własnych źródeł danych
Jeśli używasz niestandardowego rozwiązania do obsługi danych produktów dostępnych lokalnie lub wczytujesz dane bezpośrednio z sieci, możesz zaimplementować jedną z podklas DataSource. Ten fragment kodu pokazuje źródło danych, które jest kluczowane na podstawie czasu rozpoczęcia danego koncertu:
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);
}
}
Następnie możesz wczytać te dostosowane dane do obiektów PagedList, tworząc konkretną podklasę DataSource.Factory. Poniższy fragment kodu pokazuje, jak wygenerować nowe instancje niestandardowego źródła danych zdefiniowanego w poprzednim fragmencie kodu:
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;
}
}
Zastanów się, jak działają aktualizacje treści
Podczas tworzenia obiektów PagedList, które można obserwować, zastanów się, jak działają aktualizacje treści. Jeśli wczytujesz dane bezpośrednio z bazy danych Room, aktualizacje są automatycznie przekazywane do interfejsu aplikacji.
Gdy używasz interfejsu API sieci stronicowanej, zwykle masz interakcję użytkownika, np. „przesuń, aby odświeżyć”, która służy jako sygnał do unieważnienia ostatnio używanego elementu DataSource. Następnie poprosisz o nową instancję tego źródła danych. Ten fragment kodu pokazuje, jak to działa:
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();
}
}
Mapowanie danych
Biblioteka stronicowania obsługuje przekształcenia elementów wczytanych przez DataSource na podstawie elementów i stron.
W poniższym fragmencie kodu kombinacja nazwy i daty koncertu jest mapowana na pojedynczy ciąg znaków zawierający zarówno nazwę, jak i datę:
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();
}
}
Może to być przydatne, jeśli chcesz opakować, przekonwertować lub przygotować elementy po ich załadowaniu. Ponieważ ta praca jest wykonywana w wykonawcy pobierania, możesz wykonywać potencjalnie kosztowne zadania, takie jak odczyt z dysku lub wysyłanie zapytań do oddzielnej bazy danych.
Prześlij opinię
Podziel się z nami swoją opinią i pomysłami, korzystając z tych materiałów:
- Narzędzie Issue Tracker

- Zgłaszaj problemy, abyśmy mogli naprawić błędy.
Dodatkowe materiały
Więcej informacji o bibliotece Paging znajdziesz w tych materiałach.
Przykłady
Codelabs
Filmy
- Android Jetpack: manage infinite lists with RecyclerView and Paging (Google I/O '18)
- Android Jetpack: Paging
Polecane dla Ciebie
- Uwaga: tekst linku jest wyświetlany, gdy język JavaScript jest wyłączony.
- Migracja do Paging 3
- Omówienie biblioteki Paging 2
- Wyświetlanie list podzielonych na strony