android - 如何在 Android 上实时为 firestore 分页？

Question

我了解了 Doug Stevenson 的 Firestore 分页解决方案，该解决方案使用 Android 架构模式，位于 https://github.com/CodingDoug/firebase-jetpack。 .我关心的是如何使用 Android 架构组件实时完成这项工作。我尝试了如下所述的解决方案，但存在一些问题。我试图通过创建一个 FirestoreBoundaryCallback 使分页实时工作:-

class FirestoreBoundaryCallback<T>(
    private val baseQuery: Query,
    private val factory: FirestoreQueryDataSource.Factory,
    private val lifecycleOwner: LifecycleOwner): PagedList.BoundaryCallback<QueryItemOrException<T>>() {

private val allLiveData = mutableListOf<FirebaseQueryLiveData>()
private val mutableLoadingState = MutableLiveData<LoadingState>()

val loadingState: LiveData<LoadingState>
    get() = mutableLoadingState

override fun onZeroItemsLoaded() {
    allLiveData.clear()
    mutableLoadingState.value = LoadingState.LOADING_INITIAL
    val query = baseQuery.limit(50)
    val liveData = FirebaseQueryLiveData(query)
    liveData.observe(lifecycleOwner, Observer {
        mergeAllDocs()
        if (mutableLoadingState.value != LoadingState.LOADED) {
            mutableLoadingState.value = LoadingState.LOADED
        }
    })
    allLiveData.add(liveData)
}

override fun onItemAtEndLoaded(itemAtEnd: QueryItemOrException<T>) {
    if (allLiveData.isNotEmpty() && allLiveData.last().value?.data?.documents?.isNotEmpty() == true) {
        val lastDocument = allLiveData.last().value?.data?.documents?.last()
        if (lastDocument != null) {
            val query = baseQuery.startAfter(lastDocument).limit(50)
            val liveData = FirebaseQueryLiveData(query)
            mutableLoadingState.value = LoadingState.LOADING_MORE
            liveData.observe(lifecycleOwner, Observer {
                mergeAllDocs()
                if (mutableLoadingState.value != LoadingState.LOADED) {
                    mutableLoadingState.value = LoadingState.LOADED
                }
            })
            allLiveData.add(liveData)
        }
    }
}

fun mergeAllDocs() {
    val items = mutableListOf<DocumentSnapshot>()
    allLiveData.forEach{
        val docs = it.value?.data?.documents
        if (docs != null) {
            items.addAll(docs)
        }
    }
    factory.setItems(items)
}

override fun onItemAtFrontLoaded(itemAtFront: QueryItemOrException<T>) {
}
}

然后我按以下方式修改了 FirestoreQueryDataSource:-

class FirestoreQueryDataSource private constructor(
private val documentSnapshots: List<DocumentSnapshot>
) : PageKeyedDataSource<PageKey, DocumentSnapshot>() {

companion object {
    private const val TAG = "FirestoreQueryDataSrc"
}

class Factory(private val query: Query, private val source: Source) : DataSource.Factory<PageKey, DocumentSnapshot>() {
    val sourceLiveData = MutableLiveData<FirestoreQueryDataSource>()
    var documentSnapshots: List<DocumentSnapshot> = mutableListOf()

    fun setItems(items: List<DocumentSnapshot>) {
        sourceLiveData.value?.invalidate()
        documentSnapshots = items
        sourceLiveData.postValue(FirestoreQueryDataSource(documentSnapshots))
    }

    override fun create(): DataSource<PageKey, DocumentSnapshot> {
        val dataSource = FirestoreQueryDataSource(documentSnapshots)
        sourceLiveData.postValue(dataSource)
        return dataSource
    }
}

override fun loadInitial(
        params: LoadInitialParams<PageKey>,
        callback: LoadInitialCallback<PageKey, DocumentSnapshot>) {

    val firstPageDocSnapshots = documentSnapshots.take(params.requestedLoadSize)
    val nextPageKey = getNextPageKey(firstPageDocSnapshots)
    callback.onResult(firstPageDocSnapshots, null, nextPageKey)
}

override fun loadAfter(
        params: LoadParams<PageKey>,
        callback: LoadCallback<PageKey, DocumentSnapshot>) {

    val startAfterIndex = documentSnapshots.indexOf(params.key.startAfterDoc)
    var endIndex = startAfterIndex + params.requestedLoadSize
    if (endIndex > documentSnapshots.size) {
        endIndex = documentSnapshots.size - 1;
    }
    val afterInitialPageDocs = documentSnapshots.subList(startAfterIndex, endIndex)
    val nextPageKey = getNextPageKey(afterInitialPageDocs)
    callback.onResult(afterInitialPageDocs, nextPageKey)
}

override fun loadBefore(
        params: LoadParams<PageKey>,
        callback: LoadCallback<PageKey, DocumentSnapshot>) {
    // The paging here only understands how to append new items to the
    // results, not prepend items from earlier pages.
    callback.onResult(emptyList(), null)
}

private fun getNextPageKey(documents: List<DocumentSnapshot>): PageKey? {
    return if (documents.isNotEmpty()) {
        PageKey(documents.last())
    } else {
        null
    }
}
}

data class PageKey(val startAfterDoc: DocumentSnapshot)

在我的 ViewModel 中，这是我返回的:-

val sourceFactory = FirestoreQueryDataSource.Factory(query, Source.DEFAULT)
        val deserializedDataSourceFactory = sourceFactory.map { snapshot ->
            try {
                val item = QueryItem(Deserializer.deserialize(snapshot, Record::class.java), snapshot.id)
                item.item.id = snapshot.id
                QueryItemOrException(item, null)
            } catch (e: Exception) {
                Log.e(TAG, "Error while deserializing order", e)
                QueryItemOrException<PosOrder>(null, e)
            }
        }
        val boundaryCallback = FirestoreBoundaryCallback<Record>(query, sourceFactory, lifecycleOwner)
        val livePagedList = LivePagedListBuilder(deserializedDataSourceFactory, 30)
                .setFetchExecutor(executors.cpuExecutorService)
                .setBoundaryCallback(boundaryCallback)
                .build()
        return Listing(
                pagedList = livePagedList,
                loadingState = boundaryCallback.loadingState,
                refresh = {
                    sourceFactory.sourceLiveData.value?.invalidate()
                }
        )

性能不好，而且我担心插入新记录时，第一页将丢失其最后一条记录(因为第一个查询的限制是固定的)并且第二页将在最后一条之后继续开始旧第一页的记录。在 Android 上通过实时更新对 firestore 数据进行分页的正确方法是什么？

Answer 1

Paging 架构组件的局限性在于您无法同时获得实时更新。您必须选择是否要实时更新或分页。 (或者提出完全不使用 Paging 或 LiveData 的您自己的解决方案)。这是因为分页组件的工作方式。它仅处理通过将一次性查询分页到实际数据而检索到的一组静态数据。