如何在本地数据上正确使用带有 PagingDataAdapter 的自定义 PagingSource？

Question

问题

我有本地生成的数据，需要在RecyclerView中显示。 我尝试使用带有PagingDataAdapter PagingSource减少 memory 中的数据量，但是当我使数据无效时会出现视觉效果，例如，如果我插入或删除一项：

• 当可见项目属于 2 个不同的“页面”时，许多未更改的项目 flash 就好像它们已被修改
• 如果所有可见项目都属于同一页面，那么一切都很好。 只有插入/删除的项目显示 animation。

我采用了 Google 文档 ( PagingSample ) 引用的示例应用程序来测试这个概念。 带有 Room 的原始版本没有显示人工制品，但我的带有自定义PagingSource的修改版本可以。

Room 生成和使用的代码太复杂，看不出任何可以解释问题的差异。

我的数据必须是本地生成的，我不能使用 Room 作为解决方法来显示它们。

我的问题

如何为我的本地数据正确定义PagingSource ，并将其与 PagingDataAdapter 一起使用而不会出现视觉故障？

或者，我如何知道数据何时被丢弃（这样我也可以丢弃我的本地数据）？

代码摘录和细节

完整的示例项目托管在这里： https://github.com/blueglyph/PagingSampleModified

这是数据：

    private val _data = ArrayMap<Int, Cheese>()
    val data = MutableLiveData <Map<Int, Cheese>>(_data)
    val sortedData = data.map { data -> data.values.sortedBy { it.name.lowercase() } }

和PagingSource 。 我正在使用 key = item position。 我尝试使用 key = 页码，每页包含 30 个项目（10 个可见），但它没有改变任何东西。

    private class CheeseDataSource(val dao: CheeseDaoLocal, val pageSize: Int): PagingSource<Int, Cheese>() {
        fun max(a: Int, b: Int): Int = if (a > b) a else b

        override fun getRefreshKey(state: PagingState<Int, Cheese>): Int? {
            val lastPos = dao.count() - 1
            val key = state.anchorPosition?.let { anchorPosition ->
                val anchorPage = state.closestPageToPosition(anchorPosition)
                anchorPage?.prevKey?.plus(pageSize)?.coerceAtMost(lastPos) ?: anchorPage?.nextKey?.minus(pageSize)?.coerceAtLeast(0)
            }
            return key
        }

        override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Cheese> {
            val pageNumber = params.key ?: 0
            val count = dao.count()
            val data = dao.allCheesesOrdName().drop(pageNumber).take(pageSize)
            return LoadResult.Page(
                data = data,
                prevKey = if (pageNumber > 0) max(0, pageNumber - pageSize) else null,
                nextKey = if (pageNumber + pageSize < count) pageNumber + pageSize else null
            )
        }
    }

PagingData 上的Flow在视图PagingData中创建：

    val pageSize = 30
    var dataSource: PagingSource<Int, Cheese>? = null
    val allCheeses: Flow<PagingData<CheeseListItem>> = Pager(
        config = PagingConfig(
            pageSize = pageSize,
            enablePlaceholders = false,
            maxSize = 90
        )
    ) {
        dataSource = dao.getDataSource(pageSize)
        dataSource!!
    }.flow
        .map { pagingData -> pagingData.map { cheese -> CheeseListItem.Item(cheese) } }

dao.getDataSource(pageSize)返回上面显示的CheeseDataSource 。

在活动中，收集并提交数据页面：

        lifecycleScope.launch {
            viewModel.allCheeses.collectLatest { adapter.submitData(it) }
        }

当数据被修改时，观察者触发失效：

        dao.sortedData.observeForever {
            dataSource?.invalidate()
        }

页面的滚动和加载很好，唯一的问题出现在使用invalidate和同时显示 2 个页面的项目时。

适配器很经典：

class CheeseAdapter : PagingDataAdapter<CheeseListItem, CheeseViewHolder>(diffCallback) {
...
    companion object {
        val diffCallback = object : DiffUtil.ItemCallback<CheeseListItem>() {
            override fun areItemsTheSame(oldItem: CheeseListItem, newItem: CheeseListItem): Boolean {
                return if (oldItem is CheeseListItem.Item && newItem is CheeseListItem.Item) {
                    oldItem.cheese.id == newItem.cheese.id
                } else if (oldItem is CheeseListItem.Separator && newItem is CheeseListItem.Separator) {
                    oldItem.name == newItem.name
                } else {
                    oldItem == newItem
                }
            }
            override fun areContentsTheSame(oldItem: CheeseListItem, newItem: CheeseListItem): Boolean {
                return oldItem == newItem
            }
        }
...

我尝试过的（在许多其他事情中）

• 使用 LiveData 而不是 Flow
• 使用/删除 Flow 上的缓存
• 删除观察者并直接在插入/删除函数中无效以使代码更直接
• 而不是 key = position，使用 key = 页码 (0, 1, 2, ...)，每页包含 pageSize=30 个项目

在这一点上，我不再确定 paging-3 是否用于自定义数据。 我正在观察一个简单的插入/删除操作，例如适配器中的 2000-4000 比较操作，重新加载 3 页数据，......直接在我的数据上使用ListAdapter并手动执行加载/卸载似乎是更好的选择。

Answer 1

2022 年 7 月更新

page-3 存在一些问题。 最引人注目的是

• 使用带有initialKey的初始 position 时无法正确加载数据集（请参阅initial_key分支）
• 无法使用scrollToPositionWithOffset或类似的 function正确跳转到另一个position（参见test_scroll分支）

getRefreshKey function 用奇怪的（有时是负的） anchorPosition值调用，并且 load 被多次调用以加载不必要的数据 - 有时从末尾或从开头迭代地加载每一页。

我相信当 PagingSource 由 Room 生成时，可以观察到同样的问题。

=> 简而言之，它只能在您需要先显示顶部项目，并且不需要跳转到特定 position 时使用（仅当用户手动滚动列表时才能看到其他项目）。 修复正在进行中，但可能需要时间； 它仍然只是 alpha 版本，并针对一组特定的库版本 / SDK 进行编译。

您将在 CheeseDao.kt 中找到另一个更简单的getRefreshKey算法并load到上述分支中。

更新结束

---

我终于找到了一个可能的解决方案，但我不确定如果 Paging-3 库更新它会起作用。 我还不知道上面解释的行为是否是由于 Paging-3 组件中的错误/限制，或者这只是参考文档中的错误解释，或者我完全错过了一些东西。

I. 故障问题的解决方法。

1. 在PagingConfig中，我们必须enablePlaceholders = true否则它将无法正常工作。 使用false我观察滚动条在向上/向下滚动时在每个load操作上跳跃，并且在末尾插入项目将使所有项目在显示屏上出现故障，然后列表将一直跳到顶部。

2. 如 Google 的指南和参考文档中所示， getRefreshKey和load中的逻辑是幼稚的，并且不适用于自定义数据。 我必须按如下方式修改它们（修改已在 github 示例中推送）：

        override fun getRefreshKey(state: PagingState<Int, Cheese>): Int? = state.anchorPosition

        override suspend fun load(params: LoadParams<Int>): LoadResult<Int, Cheese> {
            data class Args(
                var start: Int = 0, var size: Int = 0, var prevKey: Int? = null, var nextKey: Int? = null,
                var itemsBefore: Int = UNDEF, var itemsAfter: Int = UNDEF
            )
            val pos = params.key ?: 0
            val args = Args()
            when (params) {
                is LoadParams.Append -> {
                    args.start = pos
                    args.prevKey = params.key
                    //args.nextKey = if (args.start < count) min(args.start + params.loadSize, count) else null
                    args.nextKey = if (args.start + params.loadSize < count) args.start + params.loadSize else null
                }
                is LoadParams.Prepend -> {
                    args.start = max(pos - pageSize, 0)
                    args.prevKey = if (args.start > 0) args.start else null
                    args.nextKey = params.key
                }
                is LoadParams.Refresh -> {
                    args.start = max((pos - params.loadSize/2)/pageSize*pageSize, 0)
                    args.prevKey = if (args.start > 0) args.start else null
                    args.nextKey = if (args.start + params.loadSize < count) min(args.start + params.loadSize, count - 1) else null
                }
            }
            args.size = min(params.loadSize, count - args.start)
            if (params is LoadParams.Refresh) {
                args.itemsBefore = args.start
                args.itemsAfter = count - args.size - args.start
            }
            val source = dao.allCheesesOrdName()
            val data = source.drop(args.start).take(args.size)
            if (params.key == null && data.count() == 0) {
                return LoadResult.Error(Exception("Empty"))
            }
            val result = LoadResult.Page(
                data = data,
                prevKey = args.prevKey,
                nextKey = args.nextKey,
                itemsBefore = args.itemsBefore,
                itemsAfter = args.itemsAfter
            )
            return result
        }

我必须通过在 DAO 代码和视图 model 之间插入包装器来观察params和LoadResult值，从 Room 生成的 PagingSource 的行为中推断出这一点。

笔记

• LoadParam.Append中的注释行模仿了 Room 生成的代码行为，在加载最后一页时有点不正确。 它使Pager在最后加载一个空页面，这不是一个严重的问题，但会触发整个链条中不必要的操作。
• 我不确定Refresh案例，很难从 Room 的代码行为中得出任何逻辑。 在这里，我将params.key position 放在加载范围的中间（ params.loadSize项）。 在最坏的情况下，它会在第二次加载操作中 append 数据。

二、 预测丢弃的数据

这应该可以从给load function 的params中实现。 在简化的启发式中（范围必须最小/最大才能获得实际索引）：

LoadParams.Append  -> loads [key .. key+loadSize[, so discard [key-maxSize..key-maxSize+loadSize[
LoadParams.Prepend -> loads [key-loadSize .. key[, do discard [key-loadSize+maxSize..key+maxSize[
LoadParams.Refresh -> discard what is not reloaded

上面代码中的Args.start.. Args.start + Args.size可以作为保留的范围，从那里很容易推断出什么被丢弃了。