Konzepte und Jetpack Compose-Implementierung
Sorge für eine bessere Nutzerfreundlichkeit, indem du dafür sorgst, dass deine App auch dann verwendet werden kann, wenn die Netzwerkverbindung unzuverlässig ist oder der Nutzer offline ist. Eine Möglichkeit besteht darin, gleichzeitig Seiten aus dem Netzwerk und aus einer lokalen Datenbank zu laden. So wird die Benutzeroberfläche Ihrer App über einen lokalen Datenbankcache gesteuert und es werden nur dann Anfragen an das Netzwerk gesendet, wenn keine Daten mehr in der Datenbank vorhanden sind.
In diesem Leitfaden wird davon ausgegangen, dass Sie mit der Room-Persistenzbibliothek und der grundlegenden Verwendung der Paging-Bibliothek vertraut sind.
Datenladevorgänge koordinieren
Die Paging-Bibliothek stellt für diesen Anwendungsfall die Komponente RemoteMediator bereit. RemoteMediator fungiert als Signal der Paging-Bibliothek, wenn die App keine im Cache gespeicherten Daten mehr hat. Sie können dieses Signal verwenden, um zusätzliche Daten aus dem Netzwerk zu laden und in der lokalen Datenbank zu speichern, wo sie von einem PagingSource geladen und der Benutzeroberfläche zur Anzeige bereitgestellt werden können.
Wenn zusätzliche Daten benötigt werden, ruft die Paging-Bibliothek die Methode load() aus der RemoteMediator-Implementierung auf. Dies ist eine aussetzende Funktion, sodass Vorgänge mit langer Ausführungszeit sicher ausgeführt werden können. Diese Funktion ruft in der Regel die neuen Daten aus einer Netzwerkquelle ab und speichert sie im lokalen Speicher.
Dieser Prozess funktioniert mit neuen Daten. Im Laufe der Zeit müssen die in der Datenbank gespeicherten Daten jedoch ungültig gemacht werden, z. B. wenn der Nutzer manuell eine Aktualisierung auslöst. Dies wird durch das Attribut LoadType dargestellt, das an die Methode load() übergeben wird. Der LoadType informiert den RemoteMediator, ob die vorhandenen Daten aktualisiert oder zusätzliche Daten abgerufen werden müssen, die an die vorhandene Liste angehängt oder vorangestellt werden müssen.
So sorgt die RemoteMediator dafür, dass Ihre App die Daten, die Nutzer sehen möchten, in der richtigen Reihenfolge lädt.
Lebenszyklus des Paging
Beim direkten Paging aus dem Netzwerk lädt die PagingSource die Daten und gibt ein LoadResult-Objekt zurück. Die PagingSource-Implementierung wird über den Parameter pagingSourceFactory an Pager übergeben.
Wenn die Benutzeroberfläche neue Daten benötigt, ruft die Pager die Methode load() aus der PagingSource auf und gibt einen Stream von PagingData-Objekten zurück, die die neuen Daten kapseln. Jedes PagingData-Objekt wird in der Regel im ViewModel im Cache gespeichert, bevor es zur Anzeige an die Benutzeroberfläche gesendet wird.
RemoteMediator ändert diesen Datenfluss. Ein PagingSource lädt die Daten weiterhin. Wenn die ausgelagerten Daten jedoch aufgebraucht sind, löst die Paging-Bibliothek den RemoteMediator aus, um neue Daten aus der Netzwerkquelle zu laden. Die RemoteMediator speichert die neuen Daten in der lokalen Datenbank, sodass ein In-Memory-Cache in der ViewModel nicht erforderlich ist. Schließlich wird die PagingSource ungültig und die Pager erstellt eine neue Instanz, um die aktuellen Daten aus der Datenbank zu laden.
Grundlegende Nutzung
Angenommen, Ihre App soll Seiten mit User Elementen aus einer elementbasierten Netzwerkdatenquelle in einen lokalen Cache laden, der in einer Room-Datenbank gespeichert ist.
Eine RemoteMediator-Implementierung hilft beim Laden von seitenbasierten Daten aus dem Netzwerk in die Datenbank, lädt Daten aber nicht direkt in die Benutzeroberfläche. Stattdessen verwendet die App die Datenbank als Source of Truth. Mit anderen Worten: Die App zeigt nur Daten an, die in der Datenbank im Cache gespeichert wurden. Eine PagingSource-Implementierung (z. B. eine von Room generierte) übernimmt das Laden von im Cache gespeicherten Daten aus der Datenbank in die Benutzeroberfläche.
Raumentitäten erstellen
Im ersten Schritt definieren Sie mit der Room-Persistenzbibliothek eine Datenbank, die einen lokalen Cache mit ausgelagerten Daten aus der Netzwerkdatenquelle enthält. Beginnen Sie mit einer Implementierung von RoomDatabase, wie unter Daten mit Room in einer lokalen Datenbank speichern beschrieben.
Definiere als Nächstes eine Room-Entität, die eine Tabelle mit Listenelementen darstellt, wie unter Daten mit Room-Entitäten definieren beschrieben.
Geben Sie ein id-Feld als Primärschlüssel sowie Felder für alle anderen Informationen an, die Ihre Listenelemente enthalten.
Java
@Entity(tableName = "users") public class User { public String id; public String label; }
Java
@Entity(tableName = "users") public class User { public String id; public String label; }
Außerdem müssen Sie ein Datenzugriffsobjekt (Data Access Object, DAO) für diese Room-Entität definieren, wie unter Mit Room-DAOs auf Daten zugreifen beschrieben. Das DAO für die Entität des Listenelements muss die folgenden Methoden enthalten:
- Eine
insertAll()-Methode, die eine Liste von Elementen in die Tabelle einfügt. - Eine Methode, die den Abfragestring als Parameter verwendet und ein
PagingSource-Objekt für die Ergebnisliste zurückgibt. So kann einPager-Objekt diese Tabelle als Quelle für paginierte Daten verwenden. - Eine
clearAll()-Methode, die alle Daten der Tabelle löscht.
Java
@Dao interface UserDao { @Insert(onConflict = OnConflictStrategy.REPLACE) void insertAll(List<User> users); @Query("SELECT * FROM users WHERE mLabel LIKE :query") PagingSource<Integer, User> pagingSource(String query); @Query("DELETE FROM users") int clearAll(); }
Java
@Dao interface UserDao { @Insert(onConflict = OnConflictStrategy.REPLACE) void insertAll(List<User> users); @Query("SELECT * FROM users WHERE mLabel LIKE :query") PagingSource<Integer, User> pagingSource(String query); @Query("DELETE FROM users") int clearAll(); }
RemoteMediator implementieren
Die Hauptaufgabe von RemoteMediator besteht darin, mehr Daten aus dem Netzwerk zu laden, wenn entweder die Pager keine Daten mehr hat oder die vorhandenen Daten ungültig werden. Sie enthält eine load()-Methode, die Sie überschreiben müssen, um das Ladeverhalten zu definieren.
Eine typische RemoteMediator-Implementierung umfasst die folgenden Parameter:
query: Ein Abfragestring, der definiert, welche Daten vom Backend-Dienst abgerufen werden sollen.database: Die Room-Datenbank, die als lokaler Cache dient.networkService: Eine API-Instanz für den Backend-Dienst.
Erstellen Sie eine RemoteMediator<Key, Value>-Implementierung. Der Typ Key und der Typ Value sollten mit dem Typ übereinstimmen, den Sie beim Definieren einer PagingSource für dieselbe Netzwerkdatenquelle verwenden würden. Weitere Informationen zur Auswahl von Typparametern finden Sie unter Schlüssel- und Werttypen auswählen.
Java
@UseExperimental(markerClass = ExperimentalPagingApi.class) class ExampleRemoteMediator extends RxRemoteMediator<Integer, User> { private String query; private ExampleBackendService networkService; private RoomDb database; private UserDao userDao; ExampleRemoteMediator( String query, ExampleBackendService networkService, RoomDb database ) { query = query; networkService = networkService; database = database; userDao = database.userDao(); } @NotNull @Override public Single<MediatorResult> loadSingle( @NotNull LoadType loadType, @NotNull PagingState<Integer, User> state ) { ... } }
Java
class ExampleRemoteMediator extends ListenableFutureRemoteMediator<Integer, User> { private String query; private ExampleBackendService networkService; private RoomDb database; private UserDao userDao; private Executor bgExecutor; ExampleRemoteMediator( String query, ExampleBackendService networkService, RoomDb database, Executor bgExecutor ) { this.query = query; this.networkService = networkService; this.database = database; this.userDao = database.userDao(); this.bgExecutor = bgExecutor; } @NotNull @Override public ListenableFuture<MediatorResult> loadFuture( @NotNull LoadType loadType, @NotNull PagingState<Integer, User> state ) { ... } }
Die Methode load() ist für die Aktualisierung des zugrunde liegenden Datasets und die Entwertung des PagingSource verantwortlich. Einige Bibliotheken, die Paging unterstützen (z. B. Room), übernehmen automatisch die Entwertung der von ihnen implementierten PagingSource-Objekte.
Die Methode load() verwendet zwei Parameter:
PagingState, das Informationen zu den bisher geladenen Seiten, dem zuletzt aufgerufenen Index und demPagingConfig-Objekt enthält, das Sie zum Initialisieren des Paging-Streams verwendet haben.LoadType, der den Typ der Last angibt:REFRESH,APPENDoderPREPEND.
Der Rückgabewert der Methode load() ist ein MediatorResult-Objekt. MediatorResult kann entweder MediatorResult.Error (enthält die Fehlerbeschreibung) oder MediatorResult.Success (enthält ein Signal, das angibt, ob weitere Daten geladen werden müssen) sein.
Die Methode load() muss die folgenden Schritte ausführen:
- Bestimmen Sie je nach Ladetyp und den bisher geladenen Daten, welche Seite aus dem Netzwerk geladen werden soll.
- Lösen Sie die Netzwerkanfrage aus.
- Führen Sie je nach Ergebnis des Ladevorgangs die folgenden Aktionen aus:
- Wenn der Ladevorgang erfolgreich ist und die empfangene Liste der Elemente nicht leer ist, speichern Sie die Listenelemente in der Datenbank und geben Sie
MediatorResult.Success(endOfPaginationReached = false)zurück. Nachdem die Daten gespeichert wurden, wird die Datenquelle ungültig gemacht, um die Paging-Bibliothek über die neuen Daten zu informieren. - Wenn der Ladevorgang erfolgreich ist und entweder die empfangene Liste der Elemente leer ist oder es sich um den letzten Seitenindex handelt, wird
MediatorResult.Success(endOfPaginationReached = true)zurückgegeben. Nachdem die Daten gespeichert wurden, müssen Sie die Datenquelle ungültig machen, um die Paging-Bibliothek über die neuen Daten zu informieren. - Wenn die Anfrage einen Fehler verursacht, wird
MediatorResult.Errorzurückgegeben.
- Wenn der Ladevorgang erfolgreich ist und die empfangene Liste der Elemente nicht leer ist, speichern Sie die Listenelemente in der Datenbank und geben Sie
Java
@NotNull @Override public Single<MediatorResult> loadSingle( @NotNull LoadType loadType, @NotNull PagingState<Integer, User> state ) { // The network load method takes an optional after=<user.id> parameter. For // every page after the first, pass the last user ID to let it continue from // where it left off. For REFRESH, pass null to load the first page. String loadKey = null; switch (loadType) { case REFRESH: break; case PREPEND: // In this example, you never need to prepend, since REFRESH will always // load the first page in the list. Immediately return, reporting end of // pagination. return Single.just(new MediatorResult.Success(true)); case APPEND: User lastItem = state.lastItemOrNull(); // You must explicitly check if the last item is null when appending, // since passing null to networkService is only valid for initial load. // If lastItem is null it means no items were loaded after the initial // REFRESH and there are no more items to load. if (lastItem == null) { return Single.just(new MediatorResult.Success(true)); } loadKey = lastItem.getId(); break; } return networkService.searchUsers(query, loadKey) .subscribeOn(Schedulers.io()) .map((Function<SearchUserResponse, MediatorResult>) response -> { database.runInTransaction(() -> { if (loadType == LoadType.REFRESH) { userDao.deleteByQuery(query); } // Insert new users into database, which invalidates the current // PagingData, allowing Paging to present the updates in the DB. userDao.insertAll(response.getUsers()); }); return new MediatorResult.Success(response.getNextKey() == null); }) .onErrorResumeNext(e -> { if (e instanceof IOException || e instanceof HttpException) { return Single.just(new MediatorResult.Error(e)); } return Single.error(e); }); }
Java
@NotNull @Override public ListenableFuture<MediatorResult> loadFuture( @NotNull LoadType loadType, @NotNull PagingState<Integer, User> state ) { // The network load method takes an optional after=<user.id> parameter. For // every page after the first, pass the last user ID to let it continue from // where it left off. For REFRESH, pass null to load the first page. String loadKey = null; switch (loadType) { case REFRESH: break; case PREPEND: // In this example, you never need to prepend, since REFRESH will always // load the first page in the list. Immediately return, reporting end of // pagination. return Futures.immediateFuture(new MediatorResult.Success(true)); case APPEND: User lastItem = state.lastItemOrNull(); // You must explicitly check if the last item is null when appending, // since passing null to networkService is only valid for initial load. // If lastItem is null it means no items were loaded after the initial // REFRESH and there are no more items to load. if (lastItem == null) { return Futures.immediateFuture(new MediatorResult.Success(true)); } loadKey = lastItem.getId(); break; } ListenableFuture<MediatorResult> networkResult = Futures.transform( networkService.searchUsers(query, loadKey), response -> { database.runInTransaction(() -> { if (loadType == LoadType.REFRESH) { userDao.deleteByQuery(query); } // Insert new users into database, which invalidates the current // PagingData, allowing Paging to present the updates in the DB. userDao.insertAll(response.getUsers()); }); return new MediatorResult.Success(response.getNextKey() == null); }, bgExecutor); ListenableFuture<MediatorResult> ioCatchingNetworkResult = Futures.catching( networkResult, IOException.class, MediatorResult.Error::new, bgExecutor ); return Futures.catching( ioCatchingNetworkResult, HttpException.class, MediatorResult.Error::new, bgExecutor ); }
Methode „initialize“ definieren
RemoteMediator-Implementierungen können auch die Methode initialize() überschreiben, um zu prüfen, ob im Cache gespeicherte Daten veraltet sind, und zu entscheiden, ob eine Remote-Aktualisierung ausgelöst werden soll. Diese Methode wird ausgeführt, bevor ein Ladevorgang stattfindet. Sie können die Datenbank also bearbeiten (z. B. alte Daten löschen), bevor Sie lokale oder Remote-Ladevorgänge auslösen.
Da initialize() eine asynchrone Funktion ist, können Sie Daten laden, um die Relevanz der vorhandenen Daten in der Datenbank zu bestimmen. Am häufigsten sind die im Cache gespeicherten Daten nur für einen bestimmten Zeitraum gültig. Die RemoteMediator kann prüfen, ob diese Ablaufzeit überschritten wurde. In diesem Fall muss die Paging-Bibliothek die Daten vollständig aktualisieren. Implementierungen von initialize() sollten einen InitializeAction wie folgt zurückgeben:
- Wenn die lokalen Daten vollständig aktualisiert werden müssen, sollte
initialize()den WertInitializeAction.LAUNCH_INITIAL_REFRESHzurückgeben. Dadurch wird dieRemoteMediatorveranlasst, eine Remote-Aktualisierung durchzuführen, um die Daten vollständig neu zu laden. Alle Remote-APPEND- oderPREPEND-Ladevorgänge warten, bis derREFRESH-Ladevorgang erfolgreich abgeschlossen ist, bevor sie fortgesetzt werden. - Wenn die lokalen Daten nicht aktualisiert werden müssen, sollte
initialize()den WertInitializeAction.SKIP_INITIAL_REFRESHzurückgeben. Dadurch überspringtRemoteMediatordie Remote-Aktualisierung und lädt die im Cache gespeicherten Daten.
Java
@NotNull @Override public Single<InitializeAction> initializeSingle() { long cacheTimeout = TimeUnit.MILLISECONDS.convert(1, TimeUnit.HOURS); return mUserDao.lastUpdatedSingle() .map(lastUpdatedMillis -> { if (System.currentTimeMillis() - lastUpdatedMillis <= cacheTimeout) { // Cached data is up-to-date, so there is no need to re-fetch // from the network. return InitializeAction.SKIP_INITIAL_REFRESH; } else { // Need to refresh cached data from network; returning // LAUNCH_INITIAL_REFRESH here will also block RemoteMediator's // APPEND and PREPEND from running until REFRESH succeeds. return InitializeAction.LAUNCH_INITIAL_REFRESH; } }); }
Java
@NotNull @Override public ListenableFuture<InitializeAction> initializeFuture() { long cacheTimeout = TimeUnit.MILLISECONDS.convert(1, TimeUnit.HOURS); return Futures.transform( mUserDao.lastUpdated(), lastUpdatedMillis -> { if (System.currentTimeMillis() - lastUpdatedMillis <= cacheTimeout) { // Cached data is up-to-date, so there is no need to re-fetch // from the network. return InitializeAction.SKIP_INITIAL_REFRESH; } else { // Need to refresh cached data from network; returning // LAUNCH_INITIAL_REFRESH here will also block RemoteMediator's // APPEND and PREPEND from running until REFRESH succeeds. return InitializeAction.LAUNCH_INITIAL_REFRESH; } }, mBgExecutor); }
Pager erstellen
Schließlich müssen Sie eine Pager-Instanz erstellen, um den Stream der seitenbasierten Daten einzurichten.
Das ist ähnlich wie das Erstellen einer Pager aus einer einfachen Netzwerkdatenquelle, aber Sie müssen zwei Dinge anders machen:
- Anstatt einen
PagingSource-Konstruktor direkt zu übergeben, müssen Sie die Abfragemethode angeben, die einPagingSource-Objekt vom DAO zurückgibt. - Sie müssen eine Instanz Ihrer
RemoteMediator-Implementierung alsremoteMediator-Parameter angeben.
Java
UserDao userDao = database.userDao(); Pager<Integer, User> pager = Pager( new PagingConfig(/* pageSize = */ 20), null, // initialKey, new ExampleRemoteMediator(query, database, networkService) () -> userDao.pagingSource(query));
Java
UserDao userDao = database.userDao(); Pager<Integer, User> pager = Pager( new PagingConfig(/* pageSize = */ 20), null, // initialKey new ExampleRemoteMediator(query, database, networkService, bgExecutor), () -> userDao.pagingSource(query));
Remote-Schlüssel verwalten
Remote-Schlüssel sind Schlüssel, die von einer RemoteMediator-Implementierung verwendet werden, um dem Backend-Dienst mitzuteilen, welche Daten als Nächstes geladen werden sollen. Im einfachsten Fall enthält jedes Element der ausgelagerten Daten einen Remote-Schlüssel, auf den Sie ganz einfach verweisen können. Wenn die Remote-Schlüssel jedoch nicht einzelnen Elementen entsprechen, müssen Sie sie separat speichern und in der Methode load() verwalten.
In diesem Abschnitt wird beschrieben, wie Sie Remote-Schlüssel erfassen, speichern und aktualisieren, die nicht in einzelnen Elementen gespeichert sind.
Schlüssel für das Feedelement
In diesem Abschnitt wird beschrieben, wie Sie mit Remote-Schlüsseln arbeiten, die einzelnen Elementen entsprechen. Wenn eine API auf einzelne Elemente zugreift, wird die Element-ID normalerweise als Abfrageparameter übergeben. Der Parametername gibt an, ob der Server mit Elementen vor oder nach der angegebenen ID antworten soll. Im Beispiel der Modellklasse User wird das Feld id vom Server als Remote-Schlüssel verwendet, wenn zusätzliche Daten angefordert werden.
Wenn Ihre load()-Methode elementspezifische Remote-Schlüssel verwalten muss, sind diese Schlüssel in der Regel die IDs der vom Server abgerufenen Daten. Für Aktualisierungsvorgänge ist kein Ladeschlüssel erforderlich, da nur die neuesten Daten abgerufen werden.
Ebenso müssen bei Voranstellen-Vorgängen keine zusätzlichen Daten abgerufen werden, da bei der Aktualisierung immer die neuesten Daten vom Server abgerufen werden.
Für Anhängevorgänge ist jedoch eine ID erforderlich. Dazu müssen Sie das letzte Element aus der Datenbank laden und seine ID verwenden, um die nächste Datenseite zu laden. Wenn die Datenbank keine Elemente enthält, wird endOfPaginationReached auf „true“ gesetzt, was bedeutet, dass eine Datenaktualisierung erforderlich ist.
Java
@NotNull @Override public Single>MediatorResult< loadSingle( @NotNull LoadType loadType, @NotNull PagingState>Integer, User< state ) { // The network load method takes an optional String parameter. For every page // after the first, pass the String token returned from the previous page to // let it continue from where it left off. For REFRESH, pass null to load the // first page. Single>String< remoteKeySingle = null; switch (loadType) { case REFRESH: // Initial load should use null as the page key, so you can return null // directly. remoteKeySingle = Single.just(null); break; case PREPEND: // In this example, you never need to prepend, since REFRESH will always // load the first page in the list. Immediately return, reporting end of // pagination. return Single.just(new MediatorResult.Success(true)); case APPEND: User lastItem = state.lastItemOrNull(); // You must explicitly check if the last item is null when // appending, since passing null to networkService is only // valid for initial load. If lastItem is null it means no // items were loaded after the initial REFRESH and there are // no more items to load. if (lastItem == null) { return Single.just(new MediatorResult.Success(true)); } remoteKeySingle = Single.just(lastItem.getId()); break; } return remoteKeySingle .subscribeOn(Schedulers.io()) .flatMap((Function<String, Single<MediatorResult>>) remoteKey -> { return networkService.searchUsers(query, remoteKey) .map(response -> { database.runInTransaction(() -> { if (loadType == LoadType.REFRESH) { userDao.deleteByQuery(query); } // Insert new users into database, which invalidates the current // PagingData, allowing Paging to present the updates in the DB. userDao.insertAll(response.getUsers()); }); return new MediatorResult.Success(response.getUsers().isEmpty()); }); }) .onErrorResumeNext(e -> { if (e instanceof IOException || e instanceof HttpException) { return Single.just(new MediatorResult.Error(e)); } return Single.error(e); }); }
Java
@NotNull @Override public ListenableFuture<MediatorResult> loadFuture( @NotNull LoadType loadType, @NotNull PagingState<Integer, User> state ) { // The network load method takes an optional after=<user.id> parameter. // For every page after the first, pass the last user ID to let it continue // from where it left off. For REFRESH, pass null to load the first page. ResolvableFuture<String> remoteKeyFuture = ResolvableFuture.create(); switch (loadType) { case REFRESH: remoteKeyFuture.set(null); break; case PREPEND: // In this example, you never need to prepend, since REFRESH will always // load the first page in the list. Immediately return, reporting end of // pagination. return Futures.immediateFuture(new MediatorResult.Success(true)); case APPEND: User lastItem = state.lastItemOrNull(); // You must explicitly check if the last item is null when appending, // since passing null to networkService is only valid for initial load. // If lastItem is null it means no items were loaded after the initial // REFRESH and there are no more items to load. if (lastItem == null) { return Futures.immediateFuture(new MediatorResult.Success(true)); } remoteKeyFuture.set(lastItem.getId()); break; } return Futures.transformAsync(remoteKeyFuture, remoteKey -> { ListenableFuture<MediatorResult> networkResult = Futures.transform( networkService.searchUsers(query, remoteKey), response -> { database.runInTransaction(() -> { if (loadType == LoadType.REFRESH) { userDao.deleteByQuery(query); } // Insert new users into database, which invalidates the current // PagingData, allowing Paging to present the updates in the DB. userDao.insertAll(response.getUsers()); }); return new MediatorResult.Success(response.getUsers().isEmpty()); }, bgExecutor); ListenableFuture<MediatorResult> ioCatchingNetworkResult = Futures.catching( networkResult, IOException.class, MediatorResult.Error::new, bgExecutor ); return Futures.catching( ioCatchingNetworkResult, HttpException.class, MediatorResult.Error::new, bgExecutor ); }, bgExecutor); }
Seitenschlüssel
In diesem Abschnitt wird beschrieben, wie Sie mit Remote-Schlüsseln arbeiten, die nicht einzelnen Elementen entsprechen.
Remote-Schlüsseltabelle hinzufügen
Wenn Remote-Schlüssel nicht direkt mit Listenelementen verknüpft sind, sollten sie am besten in einer separaten Tabelle in der lokalen Datenbank gespeichert werden. Definieren Sie eine Room-Entität, die eine Tabelle mit Remote-Schlüsseln darstellt:
Java
@Entity(tableName = "remote_keys") public class RemoteKey { public String label; public String nextKey; }
Java
@Entity(tableName = "remote_keys") public class RemoteKey { public String label; public String nextKey; }
Sie müssen auch ein DAO für die Entität RemoteKey definieren:
Java
@Dao interface RemoteKeyDao { @Insert(onConflict = OnConflictStrategy.REPLACE) void insertOrReplace(RemoteKey remoteKey); @Query("SELECT * FROM remote_keys WHERE label = :query") Single<RemoteKey> remoteKeyByQuerySingle(String query); @Query("DELETE FROM remote_keys WHERE label = :query") void deleteByQuery(String query); }
Java
@Dao interface RemoteKeyDao { @Insert(onConflict = OnConflictStrategy.REPLACE) void insertOrReplace(RemoteKey remoteKey); @Query("SELECT * FROM remote_keys WHERE label = :query") ListenableFuture<RemoteKey> remoteKeyByQueryFuture(String query); @Query("DELETE FROM remote_keys WHERE label = :query") void deleteByQuery(String query); }
Mit Remote-Schlüsseln laden
Wenn Ihre load()-Methode Remote-Seitenschlüssel verwalten muss, müssen Sie sie im Vergleich zur grundlegenden Verwendung von RemoteMediator so definieren:
- Füge ein zusätzliches Attribut hinzu, das einen Verweis auf das DAO für deine Remote-Schlüsseltabelle enthält.
- Ermitteln Sie, welcher Schlüssel als Nächstes geladen werden soll, indem Sie die Remote-Schlüsseltabelle abfragen, anstatt
PagingStatezu verwenden. - Füge den zurückgegebenen Remote-Schlüssel aus der Netzwerkdatenquelle zusätzlich zu den ausgelagerten Daten selbst ein oder speichere ihn.
Java
@NotNull @Override public Single<MediatorResult> loadSingle( @NotNull LoadType loadType, @NotNull PagingState<Integer, User> state ) { // The network load method takes an optional String parameter. For every page // after the first, pass the String token returned from the previous page to // let it continue from where it left off. For REFRESH, pass null to load the // first page. Single<RemoteKey> remoteKeySingle = null; switch (loadType) { case REFRESH: // Initial load should use null as the page key, so you can return null // directly. remoteKeySingle = Single.just(new RemoteKey(mQuery, null)); break; case PREPEND: // In this example, you never need to prepend, since REFRESH will always // load the first page in the list. Immediately return, reporting end of // pagination. return Single.just(new MediatorResult.Success(true)); case APPEND: // Query remoteKeyDao for the next RemoteKey. remoteKeySingle = mRemoteKeyDao.remoteKeyByQuerySingle(mQuery); break; } return remoteKeySingle .subscribeOn(Schedulers.io()) .flatMap((Function<RemoteKey, Single<MediatorResult>>) remoteKey -> { // You must explicitly check if the page key is null when appending, // since null is only valid for initial load. If you receive null // for APPEND, that means you have reached the end of pagination and // there are no more items to load. if (loadType != REFRESH && remoteKey.getNextKey() == null) { return Single.just(new MediatorResult.Success(true)); } return networkService.searchUsers(query, remoteKey.getNextKey()) .map(response -> { database.runInTransaction(() -> { if (loadType == LoadType.REFRESH) { userDao.deleteByQuery(query); remoteKeyDao.deleteByQuery(query); } // Update RemoteKey for this query. remoteKeyDao.insertOrReplace(new RemoteKey(query, response.getNextKey())); // Insert new users into database, which invalidates the current // PagingData, allowing Paging to present the updates in the DB. userDao.insertAll(response.getUsers()); }); return new MediatorResult.Success(response.getNextKey() == null); }); }) .onErrorResumeNext(e -> { if (e instanceof IOException || e instanceof HttpException) { return Single.just(new MediatorResult.Error(e)); } return Single.error(e); }); }
Java
@NotNull @Override public ListenableFuture<MediatorResult> loadFuture( @NotNull LoadType loadType, @NotNull PagingState<Integer, User> state ) { // The network load method takes an optional after=<user.id> parameter. For // every page after the first, pass the last user ID to let it continue from // where it left off. For REFRESH, pass null to load the first page. ResolvableFuture<RemoteKey> remoteKeyFuture = ResolvableFuture.create(); switch (loadType) { case REFRESH: remoteKeyFuture.set(new RemoteKey(query, null)); break; case PREPEND: // In this example, you never need to prepend, since REFRESH will always // load the first page in the list. Immediately return, reporting end of // pagination. return Futures.immediateFuture(new MediatorResult.Success(true)); case APPEND: User lastItem = state.lastItemOrNull(); // You must explicitly check if the last item is null when appending, // since passing null to networkService is only valid for initial load. // If lastItem is null it means no items were loaded after the initial // REFRESH and there are no more items to load. if (lastItem == null) { return Futures.immediateFuture(new MediatorResult.Success(true)); } // Query remoteKeyDao for the next RemoteKey. remoteKeyFuture.setFuture( remoteKeyDao.remoteKeyByQueryFuture(query)); break; } return Futures.transformAsync(remoteKeyFuture, remoteKey -> { // You must explicitly check if the page key is null when appending, // since null is only valid for initial load. If you receive null // for APPEND, that means you have reached the end of pagination and // there are no more items to load. if (loadType != LoadType.REFRESH && remoteKey.getNextKey() == null) { return Futures.immediateFuture(new MediatorResult.Success(true)); } ListenableFuture<MediatorResult> networkResult = Futures.transform( networkService.searchUsers(query, remoteKey.getNextKey()), response -> { database.runInTransaction(() -> { if (loadType == LoadType.REFRESH) { userDao.deleteByQuery(query); remoteKeyDao.deleteByQuery(query); } // Update RemoteKey for this query. remoteKeyDao.insertOrReplace(new RemoteKey(query, response.getNextKey())); // Insert new users into database, which invalidates the current // PagingData, allowing Paging to present the updates in the DB. userDao.insertAll(response.getUsers()); }); return new MediatorResult.Success(response.getNextKey() == null); }, bgExecutor); ListenableFuture<MediatorResult> ioCatchingNetworkResult = Futures.catching( networkResult, IOException.class, MediatorResult.Error::new, bgExecutor ); return Futures.catching( ioCatchingNetworkResult, HttpException.class, MediatorResult.Error::new, bgExecutor ); }, bgExecutor); }
Zusätzliche Ressourcen
Weitere Informationen zur Paging-Bibliothek findest du in den folgenden zusätzlichen Ressourcen:
Beispiele
Empfehlungen für Sie
- Hinweis: Der Linktext wird angezeigt, wenn JavaScript deaktiviert ist.
- Seitenweise Daten laden und anzeigen
- Paging-Implementierung testen
- Zu Paging 3 migrieren