How to reset the scroll position after process death when using Paging 3 with RemoteMediator

Question

I have set up Paging 3 with offline caching using a RemoteMediator. After process death, the RecyclerView immediately restores the correct scrolling position. However, since we need to send the search query again it triggers a LoadType.REFRESH which clears the current search results from the cache and replaces them with new values. This brings us back to the start of the list.

My RemoteMediator:

private const val NEWS_STARTING_PAGE_INDEX = 1

class SearchNewsRemoteMediator(
    private val searchQuery: String,
    private val newsDb: NewsArticleDatabase,
    private val newsApi: NewsApi
) : RemoteMediator<Int, NewsArticle>() {

    private val newsArticleDao = newsDb.newsArticleDao()

    override suspend fun load(
        loadType: LoadType,
        state: PagingState<Int, NewsArticle>
    ): MediatorResult {
        val page = when (loadType) {
            LoadType.REFRESH -> {
                val remoteKeys = getRemoteKeyClosestToCurrentPosition(state)
                remoteKeys?.nextKey?.minus(1) ?: NEWS_STARTING_PAGE_INDEX
            }
            LoadType.PREPEND -> {
                val remoteKeys = getRemoteKeyForFirstItem(state)
                    ?: throw InvalidObjectException("Remote key should not be null for $loadType")
                val prevKey = remoteKeys.prevKey
                if (prevKey == null) {
                    return MediatorResult.Success(endOfPaginationReached = true)
                }
                remoteKeys.prevKey
            }
            LoadType.APPEND -> {
                val remoteKeys = getRemoteKeyForLastItem(state)
                if (remoteKeys == null || remoteKeys.nextKey == null) {
                    throw InvalidObjectException("Remote key should not be null for $loadType")
                }
                remoteKeys.nextKey
            }
        }

        return try {
            delay(2000)
            val apiResponse = newsApi.searchNews(searchQuery, page, state.config.pageSize)
            val serverSearchResults = apiResponse.articles
            val endOfPaginationReached = serverSearchResults.isEmpty()

            val bookmarkedArticles = newsArticleDao.getAllBookmarkedArticles().first()
            val cachedBreakingNewsArticles = newsArticleDao.getCachedBreakingNews().first()

            val searchResults = serverSearchResults.map { serverSearchResultArticle ->
                val bookmarked = bookmarkedArticles.any { bookmarkedArticle ->
                    bookmarkedArticle.url == serverSearchResultArticle.url
                }
                val inBreakingNewsCache =
                    cachedBreakingNewsArticles.any { breakingNewsArticle ->
                        breakingNewsArticle.url == serverSearchResultArticle.url
                    }
                NewsArticle(
                    title = serverSearchResultArticle.title,
                    url = serverSearchResultArticle.url,
                    urlToImage = serverSearchResultArticle.urlToImage,
                    isBreakingNews = inBreakingNewsCache,
                    isBookmarked = bookmarked,
                    isSearchResult = true
                )
            }

            newsDb.withTransaction {
                if (loadType == LoadType.REFRESH) {
                    newsDb.searchRemoteKeyDao().clearRemoteKeys()
                    newsArticleDao.resetSearchResults()
                    newsArticleDao.deleteAllObsoleteArticles()
                }

                val prevKey = if (page == NEWS_STARTING_PAGE_INDEX) null else page - 1
                val nextKey = if (endOfPaginationReached) null else page + 1
                val remoteKeys = serverSearchResults.map { article ->
                    SearchRemoteKeys(article.url, prevKey, nextKey)
                }
                newsDb.searchRemoteKeyDao().insertAll(remoteKeys)
                newsDb.newsArticleDao().insertAll(searchResults)
            }
            MediatorResult.Success(endOfPaginationReached)
        } catch (exception: IOException) {
            MediatorResult.Error(exception)
        } catch (exception: HttpException) {
            MediatorResult.Error(exception)
        }
    }

    private suspend fun getRemoteKeyForLastItem(state: PagingState<Int, NewsArticle>): SearchRemoteKeys? =
        state.pages.lastOrNull { it.data.isNotEmpty() }?.data?.lastOrNull()
            ?.let { article ->
                newsDb.searchRemoteKeyDao().getRemoteKeyFromArticleUrl(article.url)
            }

    private suspend fun getRemoteKeyForFirstItem(state: PagingState<Int, NewsArticle>): SearchRemoteKeys? =
        state.pages.firstOrNull { it.data.isNotEmpty() }?.data?.firstOrNull()
            ?.let { article ->
                newsDb.searchRemoteKeyDao().getRemoteKeyFromArticleUrl(article.url)
            }

    private suspend fun getRemoteKeyClosestToCurrentPosition(
        state: PagingState<Int, NewsArticle>
    ): SearchRemoteKeys? =
        state.anchorPosition?.let { position ->
            state.closestItemToPosition(position)?.url?.let { articleUrl ->
                newsDb.searchRemoteKeyDao().getRemoteKeyFromArticleUrl(articleUrl)
            }
        }
}

The repository method that instantiates it:

fun getSearchResults(query: String): Flow<PagingData<NewsArticle>> =
        Pager(
            config = PagingConfig(pageSize = 20, enablePlaceholders = false),
            remoteMediator = SearchNewsRemoteMediator(query, newsArticleDatabase, newsApi),
            pagingSourceFactory = { newsArticleDatabase.newsArticleDao().getSearchResultsPaged() }
        ).flow

The ViewModel that triggers the query. currentQuery is restored after process death and therefore calls getSearchResults immediately with the old query.

class SearchNewsViewModel @ViewModelInject constructor(
    private val repository: NewsRepository,
    @Assisted state: SavedStateHandle
) : ViewModel() {

    private val currentQuery = state.getLiveData<String?>("currentQuery")

    val newsArticles = currentQuery.switchMap { query ->
        repository.getSearchResults(query).asLiveData().cachedIn(viewModelScope)
    }

    fun searchArticles(query: String) {
        currentQuery.value = query
    }
}