Question

首先，这纯粹是地狱。我从来没有像回调地狱那样艰难。我讨厌它。一般的想法是我有Firebase Storage和Firestore云设置。存储中包含图像，而云中包含引用了存储中图像位置的模型。然后，我必须从存储中获取图像网址，这样我就可以使用它并轻松下载它。示例：Firebase云为我提供了带有（title =“ blabla”，imageUrl =“ scg / asd / asd”）的drillType，然后将远程存储的imageUrl设置为“ scg / asd / asd”，并将其替换为一个我可以用。问题是回调。我无法按预期方式进行。我尝试了挂起功能，观察者等等。这个想法是，onNext应该调用getImageUrl并使用新的Url（而不是存储位置）更新DrillType。但是目前，我无法让onNext（或.map）在继续执行之前等待getImageUrl的执行。

存储库当前不起作用

class DrillRepository(
    private val remoteDataSource: DataSource,
    private val remoteFilesDataSource: ImageUrlDataSource
) : CoroutineScope {


    private val job = Job()
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.IO + job


    fun loadDrillTypes(): Observable<DrillsType> {

        return Observable.create<DrillsType> { emitter ->
            val observer = object : DisposableObserver<DrillsType>() {
                override fun onError(e: Throwable) {
                    Log.d("TAG", "error " + e.message)
                    emitter.onError(e)
                }

                override fun onNext(data: DrillsType) {
                    data.let {
                    val singleObserver = object : SingleObserver<String>{
                        override fun onSuccess(t: String) {
                            it.drillType_imageUrl = t
                            dispose()
                        }

                        override fun onSubscribe(d: Disposable) {

                        }

                        override fun onError(e: Throwable) {
                            dispose()
                        }

                    }
                        getImageUrl(it.drillType_imageUrl).subscribeWith(singleObserver)
                    }
                }

                override fun onComplete() {
                    Log.d("TAG", "COMPLETE")
                    emitter.onComplete()
                    job.cancel()
                    dispose()
                }
            }

            remoteDataSource.loadDrillTypes().subscribeWith(observer)
        }
    }

fun getImageUrl(storageLocation: String): io.reactivex.Single<String> {
        return remoteFilesDataSource.getImageUrl(storageLocation)
    }

class FirebaseStorageDataSource(val firebaseStorage: FirebaseStorage) : ImageUrlDataSource {

    override fun getImageUrl(storageLocation: String): Single<String>
    {
        return Single.create<String>{emitter->
        firebaseStorage.getReferenceFromUrl(storageLocation).downloadUrl.addOnSuccessListener {
            emitter.onSuccess(it.toString())
        }.addOnFailureListener {
            emitter.onError(it)
        }
    }

class FirebaseFirestoreDataSource(val firebaseFirestore: FirebaseFirestore) : DataSource {


    override fun loadDrillTypes(): Observable<DrillsType> {

        return Observable.create<DrillsType> { emitter ->
            firebaseFirestore.collection("drilltypes")
                .get()
                .addOnSuccessListener { documents ->
                    for (document in documents) {
                        try {
                            val doc = document.toObject(DrillsType::class.java)
                            emitter.onNext(doc)
                        } catch (e: Exception) {
                            emitter.onError(e)
                        }
                    }
                    emitter.onComplete()
                }
                .addOnFailureListener { exception ->
                    Log.w("TAG", "Error getting documents: ", exception)
                    emitter.onError(exception)
                }
        }
    }

data class DrillsType(
    var drillType_title: String = "",
    var drillType_imageUrl: String = ""
)

我正在获取DrillType，但是无法更新其ImageUrl。我某种程度上需要等待执行，即来自getImageUrl的回调，然后使用更新的drillType进行onNext。

编辑：我已经多次遇到此问题。这是迄今为止最糟糕的一种。我正在寻找一种可能并且最好是优雅的方式来解决这个问题。观察者内部的观察者也绝对是疯了，但这就是我经过多次尝试和错误而最终失败的地方。

EDIT2： 解决方案，希望对未来的开发人员有所帮助

    fun loadFullDrillType(): Observable<DrillsType> {
        return loadDrillTypeWithRawImageUrl().flatMapSingle { drillTypeWithRawImageUrl ->
            loadImageUrl(drillTypeWithRawImageUrl.drillType_imageUrl).map {
                return@map drillTypeWithRawImageUrl.copy(drillType_imageUrl = it)
            }
        }
    }

    fun loadDrillTypeWithRawImageUrl(): Observable<DrillsType> {
        return remoteDataSource.loadDrillTypes()
    }

        return Observable.create<DrillsType> { emitter ->
            firebaseFirestore.collection("drilltypes")
                .get()
                .addOnSuccessListener { documents ->
                    try {
                        for (document in documents) {
                            val doc = document.toObject(DrillsType::class.java)
                            emitter.onNext(doc)
                        }
                    } catch (e: Exception) {
                        emitter.onError(e)
                    }
                    emitter.onComplete()
                }
                .addOnFailureListener { exception ->
                    Log.w("TAG", "Error getting documents: ", exception)
                    emitter.onError(exception)
                }
        }
    }

Answer 1

要完全使用RX，每个RX Firebase包装程序应仅执行一项操作（例如获取原始钻取类型或仅获取图像URL）。然后，您可以使用诸如map和flatMap之类的RX结构来合并它们：

fun loadDrillTypeWithRawImageUrl(): Single<DrillsType> = TODO()
fun loadDrillImageUrl(rawImageUrl: String): Single<String> = TODO()

fun loadFullDrillType(): Single<DrillsType> {
    return loadDrillTypeWithRawImageUrl().flatMap { rawDrillsType ->
        loadDrillImageUrl(rawDrillsType.drillType_imageUrl).map { newImageUrl ->
            DrillsType(rawDrillsType.drillType_title, newImageUrl)
        }
    }
}

将多个Firebase回调与RxJava2结合在一起

1 个答案: