Question

我使用了https://github.com/CodingDoug/firebase-jetpack上的Android体系结构模式，了解了道格·史蒂文森（Doug Stevenson）的Firestore分页解决方案。我担心的是如何使用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的解决方案）。这是因为分页组件的工作方式。它仅处理通过将一次性查询分页到实际数据而检索到的静态数据集。

如何在Android上使分页在Firestore上实时工作？

1 个答案: