RxPagingSource

Kotlin |Java

abstract class RxPagingSource<Key : Any, Value : Any> : PagingSource<Key, Value>

kotlin.Any
↳	androidx.paging.PagingSource<Key, Value>
	↳	androidx.paging.rxjava2.RxPagingSource

Rx-based compatibility wrapper around PagingSource's suspending APIs.


/**
 * Sample RxPagingSource which loads `Item`s from network requests via Retrofit to a backend
 * service, which uses String tokens to load pages (each response has a next/previous token).
 */
class MyPagingSource(
    val myBackend: RxBackendService,
    val searchTerm: String
) : RxPagingSource<String, Item>() {
    override fun loadSingle(params: LoadParams<String>): Single<LoadResult<String, Item>> {
        return myBackend
            // Single-based network load
            .searchUsers(searchTerm, params.key)
            .subscribeOn(Schedulers.io())
            .map<LoadResult<String, Item>> { result ->
                LoadResult.Page(
                    data = result.items,
                    prevKey = result.prev,
                    nextKey = result.next
                )
            }
            .onErrorReturn { e ->
                when (e) {
                    // Retrofit calls that return the body type throw either IOException for
                    // network failures, or HttpException for any non-2xx HTTP status codes.
                    // This code reports all errors to the UI, but you can inspect/wrap the
                    // exceptions to provide more context.
                    is IOException -> LoadResult.Error(e)
                    is HttpException -> LoadResult.Error(e)
                    else -> throw e
                }
            }
    }

    override fun getRefreshKey(state: PagingState<String, Item>): String? {
        return state.anchorPosition?.let { state.closestItemToPosition(it)?.id }
    }
}

Summary

Public constructors
`<init>()` Rx-based compatibility wrapper around PagingSource's suspending APIs.

Public methods
suspend PagingSource.LoadResult<Key, Value>	`load(params: PagingSource.LoadParams<Key>)` Loading API for PagingSource.
abstract Single<PagingSource.LoadResult<Key, Value>>	`loadSingle(params: PagingSource.LoadParams<Key>)` Loading API for PagingSource.

Inherited functions

From class PagingSource

`Key?`	`getRefreshKey(state: PagingState<Key, Value>)` Provide a Key used for the initial load for the next PagingSource due to invalidation of this PagingSource. The Key is provided to load via LoadParams.key. The Key returned by this method should cause load to load enough items to fill the viewport around the last accessed position, allowing the next generation to transparently animate in. The last accessed position can be retrieved via state.anchorPosition, which is typically the top-most or bottom-most item in the viewport due to access being triggered by binding items as they scroll into view. For example, if items are loaded based on integer position keys, you can return state.anchorPosition. Alternately, if items contain a key used to load, get the key from the item in the page at index state.anchorPosition.
`Unit`	`invalidate()` Signal the PagingSource to stop loading. This method is idempotent. i.e., If invalidate has already been called, subsequent calls to this method should have no effect.
`Unit`	`registerInvalidatedCallback(onInvalidatedCallback: () -> Unit)` Add a callback to invoke when the PagingSource is first invalidated. Once invalidated, a PagingSource will not become valid again. A PagingSource will only invoke its callbacks once - the first time invalidate is called, on that thread.
`Unit`	`unregisterInvalidatedCallback(onInvalidatedCallback: () -> Unit)` Remove a previously added invalidate callback.

Inherited properties

From class PagingSource

Boolean

invalid

Whether this PagingSource has been invalidated, which should happen when the data this PagingSource represents changes since it was first instantiated.

Boolean

jumpingSupported

true if this PagingSource supports jumping, false otherwise.

Override this to true if pseudo-fast scrolling via jumps is supported.

A jump occurs when a RecyclerView scrolls through a number of placeholders defined by PagingConfig.jumpThreshold and triggers a load with LoadType.

PagingSources that support jumps should override getRefreshKey to return a Key that would load data fulfilling the viewport given a user's current PagingState.anchorPosition.

Boolean

keyReuseSupported

true if this PagingSource expects to re-use keys to load distinct pages without a call to invalidate, false otherwise.

Public constructors

<init>

RxPagingSource()

Rx-based compatibility wrapper around PagingSource's suspending APIs.


/**
 * Sample RxPagingSource which loads `Item`s from network requests via Retrofit to a backend
 * service, which uses String tokens to load pages (each response has a next/previous token).
 */
class MyPagingSource(
    val myBackend: RxBackendService,
    val searchTerm: String
) : RxPagingSource<String, Item>() {
    override fun loadSingle(params: LoadParams<String>): Single<LoadResult<String, Item>> {
        return myBackend
            // Single-based network load
            .searchUsers(searchTerm, params.key)
            .subscribeOn(Schedulers.io())
            .map<LoadResult<String, Item>> { result ->
                LoadResult.Page(
                    data = result.items,
                    prevKey = result.prev,
                    nextKey = result.next
                )
            }
            .onErrorReturn { e ->
                when (e) {
                    // Retrofit calls that return the body type throw either IOException for
                    // network failures, or HttpException for any non-2xx HTTP status codes.
                    // This code reports all errors to the UI, but you can inspect/wrap the
                    // exceptions to provide more context.
                    is IOException -> LoadResult.Error(e)
                    is HttpException -> LoadResult.Error(e)
                    else -> throw e
                }
            }
    }

    override fun getRefreshKey(state: PagingState<String, Item>): String? {
        return state.anchorPosition?.let { state.closestItemToPosition(it)?.id }
    }
}

Public methods

load

suspend fun load(params: PagingSource.LoadParams<Key>): PagingSource.LoadResult<Key, Value>

Loading API for PagingSource.

Implement this method to trigger your async load (e.g. from database or network).

loadSingle

abstract fun loadSingle(params: PagingSource.Loa