Pagination with Paging 3

dependencies {
    implementation("androidx.paging:paging-runtime:<paging-version>")
    implementation("androidx.paging:paging-compose:<paging-version>")
    testImplementation("androidx.paging:paging-testing:<paging-version>")
}

class ArticlePagingSource(
    private val api: ArticleApi,
    private val query: String,
) : PagingSource<Int, Article>() {

    override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Article> {
        val page = params.key ?: 1
        return try {
            val items = api.search(query, page = page, pageSize = params.loadSize).map { it.toDomain() }
            LoadResult.Page(
                data = items,
                prevKey = if (page == 1) null else page - 1,
                nextKey = if (items.isEmpty()) null else page + 1,
            )
        } catch (e: IOException) {
            LoadResult.Error(e)
        } catch (e: HttpException) {
            LoadResult.Error(e)
        }
    }

    // Which page to load when the list is refreshed (e.g. after invalidation), based on scroll position
    override fun getRefreshKey(state: PagingState<Int, Article>): Int? =
        state.anchorPosition?.let { anchor ->
            state.closestPageToPosition(anchor)?.let { it.prevKey?.plus(1) ?: it.nextKey?.minus(1) }
        }
}

class SearchViewModel(private val api: ArticleApi) : ViewModel() {
    private val query = MutableStateFlow("android")

    @OptIn(ExperimentalCoroutinesApi::class)
    val results: Flow<PagingData<Article>> = query
        .flatMapLatest { q ->
            Pager(PagingConfig(pageSize = 20, prefetchDistance = 5, enablePlaceholders = false)) {
                ArticlePagingSource(api, q)
            }.flow
        }
        .cachedIn(viewModelScope)        // survive rotation; share between collectors

    fun search(q: String) { query.value = q }
}

@Composable
fun SearchResults(viewModel: SearchViewModel) {
    val items = viewModel.results.collectAsLazyPagingItems()

    when (val refresh = items.loadState.refresh) {
        is LoadState.Loading -> if (items.itemCount == 0) { FullScreenLoading(); return }
        is LoadState.Error -> if (items.itemCount == 0) {
            FullScreenError(refresh.error.message ?: "Couldn't load", onRetry = items::retry); return
        }
        is LoadState.NotLoading -> if (items.itemCount == 0 && refresh.endOfPaginationReached) { EmptyState(); return }
    }

    LazyColumn {
        items(count = items.itemCount, key = items.itemKey { it.id }) { index ->
            items[index]?.let { ArticleRow(it) }
        }
        when (val append = items.loadState.append) {
            is LoadState.Loading -> item { LoadingFooter() }
            is LoadState.Error -> item { RetryFooter(onRetry = items::retry) }
            else -> Unit
        }
    }
}

@OptIn(ExperimentalPagingApi::class)
class ArticleRemoteMediator(
    private val api: ArticleApi,
    private val db: AppDatabase,
) : RemoteMediator<Int, ArticleEntity>() {

    override suspend fun load(loadType: LoadType, state: PagingState<Int, ArticleEntity>): MediatorResult {
        val page = when (loadType) {
            LoadType.REFRESH -> 1
            LoadType.PREPEND -> return MediatorResult.Success(endOfPaginationReached = true)
            LoadType.APPEND -> db.remoteKeysDao().lastKey()?.nextPage
                ?: return MediatorResult.Success(endOfPaginationReached = true)
        }
        return try {
            val response = api.list(page = page, pageSize = state.config.pageSize)
            db.withTransaction {
                if (loadType == LoadType.REFRESH) { db.articleDao().clearAll(); db.remoteKeysDao().clear() }
                db.remoteKeysDao().insert(RemoteKey(nextPage = if (response.isEmpty()) null else page + 1))
                db.articleDao().insertAll(response.map { it.toEntity() })
            }
            MediatorResult.Success(endOfPaginationReached = response.isEmpty())
        } catch (e: IOException) {
            MediatorResult.Error(e)
        }
    }
}
// Pager(config, remoteMediator = ArticleRemoteMediator(api, db)) { db.articleDao().pagingSource() }

@Test
fun `loads first page and sets next key`() = runTest {
    val source = ArticlePagingSource(FakeArticleApi(totalItems = 45), query = "kotlin")
    val pager = TestPager(PagingConfig(pageSize = 20), source)
    val result = pager.refresh() as PagingSource.LoadResult.Page
    assertEquals(20, result.data.size)
    assertEquals(2, result.nextKey)
}