Gromadzenie danych z podziałem na strony

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:

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 tokena nextPage z 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