问如何在Android上实时实现对防火墙的分页工作？

EN

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>) {
}
}

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)

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()
                }
        )