ItemKeyedDataSource

Kotlin |Java

abstract class ItemKeyedDataSource<Key : Any!, Value : Any!> : ContiguousDataSource<Key, Value>

androidx.paging.ItemKeyedDataSource

Incremental data loader for paging keyed content, where loaded content uses previously loaded items as input to future loads.

Implement a DataSource using ItemKeyedDataSource if you need to use data from item N - 1 to load item N. This is common, for example, in sorted database queries where attributes of the item such just before the next query define how to execute it.

The InMemoryByItemRepository in the PagingWithNetworkSample shows how to implement a network ItemKeyedDataSource using Retrofit, while handling swipe-to-refresh, network errors, and retry.

Summary

Nested classes
abstract	LoadCallback Callback for ItemKeyedDataSource loadBefore(LoadParams, LoadCallback) and loadAfter(LoadParams, LoadCallback) to return data.
abstract	LoadInitialCallback Callback for loadInitial(LoadInitialParams, LoadInitialCallback) to return data and, optionally, position/count information.
open	LoadInitialParams Holder object for inputs to loadInitial(LoadInitialParams, LoadInitialCallback).
open	LoadParams Holder object for inputs to loadBefore(LoadParams, LoadCallback) and loadAfter(LoadParams, LoadCallback).

Public constructors
<init>() Incremental data loader for paging keyed content, where loaded content uses previously loaded items as input to future loads.

Public methods
abstract Key	getKey(@NonNull item: Value) Return a key associated with the given item.
abstract Unit	loadAfter(@NonNull params: ItemKeyedDataSource.LoadParams<Key>, @NonNull callback: ItemKeyedDataSource.LoadCallback<Value>) Load list data after the key specified in LoadParams.key.
abstract Unit	loadBefore(@NonNull params: ItemKeyedDataSource.LoadParams<Key>, @NonNull callback: ItemKeyedDataSource.LoadCallback<Value>) Load list data before the key specified in LoadParams.key.
abstract Unit	loadInitial(@NonNull params: ItemKeyedDataSource.LoadInitialParams<Key>, @NonNull callback: ItemKeyedDataSource.LoadInitialCallback<Value>) Load initial data.
ItemKeyedDataSource<Key, ToValue>	map(@NonNull function: Function<Value, ToValue>)
ItemKeyedDataSource<Key, ToValue>	mapByPage(@NonNull function: Function<MutableList<Value>!, MutableList<ToValue>!>)

Public constructors

<init>

ItemKeyedDataSource()

Incremental data loader for paging keyed content, where loaded content uses previously loaded items as input to future loads.

Implement a DataSource using ItemKeyedDataSource if you need to use data from item N - 1 to load item N. This is common, for example, in sorted database queries where attributes of the item such just before the next query define how to execute it.

The InMemoryByItemRepository in the PagingWithNetworkSample shows how to implement a network ItemKeyedDataSource using Retrofit, while handling swipe-to-refresh, network errors, and retry.

Public methods

getKey

@NonNull abstract fun getKey(@NonNull item: Value): Key

Return a key associated with the given item.

If your ItemKeyedDataSource is loading from a source that is sorted and loaded by a unique integer ID, you would return item.getID() here. This key can then be passed to loadBefore(LoadParams, LoadCallback) or loadAfter(LoadParams, LoadCallback) to load additional items adjacent to the item passed to this function.

If your key is more complex, such as when you're sorting by name, then resolving collisions with integer ID, you'll need to return both. In such a case you would use a wrapper class, such as Pair<String, Integer> or, in Kotlin, data class Key(val name: String, val id: Int)

Parameters
item	Value: Item to get the key from.

Return
Key	Key associated with given item.

loadAfter

abstract fun loadAfter(
    @NonNull params: ItemKeyedDataSource.LoadParams<Key>, 
    @NonNull callback: ItemKeyedDataSource.LoadCallback<Value>
): Unit

Load list data after the key specified in LoadParams.key.

It's valid to return a different list size than the page size if it's easier, e.g. if your backend defines page sizes. It is generally safer to increase the number loaded than reduce.

Data may be passed synchronously during the loadAfter method, or deferred and called at a later time. Further loads going down will be blocked until the callback is called.

If data cannot be loaded (for example, if the request is invalid, or the data would be stale and inconsistent, it is valid to call invalidate() to invalidate the data source, and prevent further loading.

Parameters
params	ItemKeyedDataSource.LoadParams<Key>: Parameters for the load, including the key to load after, and requested size.
callback	ItemKeyedDataSource.LoadCallback<Value>: Callback that receives loaded data.

loadBefore

abstract fun loadBefore(
    @NonNull params: ItemKeyedDataSource.LoadParams<Key>, 
    @NonNull callback: ItemKeyedDataSource.LoadCallback<Value>
): Unit

Load list data before the key specified in LoadParams.key.

It's valid to return a different list size than the page size if it's easier, e.g. if your backend defines page sizes. It is generally safer to increase the number loaded than reduce.

Note: Data returned will be prepended just before the key passed, so if you vary size, ensure that the last item is adjacent to the passed key.

Data may be passed synchronously during the loadBefore method, or deferred and called at a later time. Further loads going up will be blocked until the callback is called.

If data cannot be loaded (for example, if the request is invalid, or the data would be stale and inconsistent, it is valid to call invalidate() to invalidate the data source, and prevent further loading.

Parameters
params	ItemKeyedDataSource.LoadParams<Key>: Parameters for the load, including the key to load before, and requested size.
callback	ItemKeyedDataSource.LoadCallback<Value>: Callback that receives loaded data.

loadInitial

abstract fun loadInitial(
    @NonNull params: ItemKeyedDataSource.LoadInitialParams<Key>, 
    @NonNull callback: ItemKeyedDataSource.LoadInitialCallback<Value>
): Unit

Load initial data.

This method is called first to initialize a PagedList with data. If it's possible to count the items that can be loaded by the DataSource, it's recommended to pass the loaded data to the callback via the three-parameter LoadInitialCallback#onResult(List, int, int). This enables PagedLists presenting data from this source to display placeholders to represent unloaded items.

LoadInitialParams#requestedInitialKey and LoadInitialParams#requestedLoadSize are hints, not requirements, so they may be altered or ignored. Note that ignoring the requestedInitialKey can prevent subsequent PagedList/DataSource pairs from initializing at the same location. If your data source never invalidates (for example, loading from the network without the network ever signalling that old data must be reloaded), it's fine to ignore the initialLoadKey and always start from the beginning of the data set.

Parameters
params	ItemKeyedDataSource.LoadInitialParams<Key>: Parameters for initial load, including initial key and requested size.
callback	ItemKeyedDataSource.LoadInitialCallback<Value>: Callback that receives initial load data.

map

@NonNull fun <ToValue : Any!> map(@NonNull function: Function<Value, ToValue>): ItemKeyedDataSource<Key, ToValue>

mapByPage

@NonNull fun <ToValue : Any!> mapByPage(@NonNull function: Function<MutableList<Value>!, MutableList<ToValue>!>): ItemKeyedDataSource<Key, ToValue>