无法推断出复杂的闭包返回类型;添加显式类型以消除RxSwift中的歧义

Question

我需要打多个电话。

1.删​​除文档上传

2.图像1和服务器返回URL

3.上传图像2和服务器返回URL

4. Create Document API包含URL和extra 参数。

我试着写的代码是在RxSwift和MVVM中。

  let resultOfDocumentUpdateWithDelete =
            donepressed
                .filter{ $0 }
                .withLatestFrom(self.existingDocumentIDChangedProperty)
                .flatMapLatest {id in
                    let deleted_document = apiClient.deleteDocument(id).asObservable().materialize()
                    let upload_frontImage = deleted_document
                        .withLatestFrom(self.frontImageNameChangedProperty)
                        .flatMapLatest {image in
                            apiClient.uploadImage(image: image!).asObservable().materialize()
                    }
                    let upload_backImage = upload_frontImage
                        .withLatestFrom(self.backImageChangedProperty)
                        .flatMapLatest {image in
                            apiClient.uploadImage(image: image!).asObservable().materialize()
                    }

                    let upload_document = upload_backImage
                        .withLatestFrom(self.parametersChangedProperty)
                        .flatMapLatest {parameters in
                            apiClient.uploadDocument(parameters: parameters)
                    }

                    return upload_document.materialize()
                }
                .share(replay: 1)

确保在最后一个API中输入两个服务器响应，因此所有这些响应都将按顺序调用。

在RxSwift中怎么做。

Answer 1

这是一个有趣的！这里的结果是，当你有疑问时，请继续做自己的操作员。如果事后证明你后来弄清楚如何使用内置操作符完成工作，那么你可以替换你的。制作自己的唯一方法是他们需要更多的测试。

注意，要使用下面的内容，您必须将最新的observable和flatMap组合在一起，并将它们的值传递给此函数。

// all possible results from this job.
enum ProcessResult {
    case success
    case deleteFailure(Error)
    case imageFailue(Error)
    case backImageFailure(Error)
    case documentFailure(Error)
}

func uploadContent(apiClient: APIClient, documentID: Int, frontImage: UIImage, backImage: UIImage, parameters: Parameters) -> Single<ProcessResult> {
    // instead of trying to deal with all the materializes, I decided to turn it into a single process.
    return Single.create { observer in

        // each api call happens in turn. Note that there are no roll-back semantics included! You are dealing with a very poorly written server.
        let deleted = apiClient.deleteDocument(id: documentID)
            .asObservable()
            .share()

        let imagesUploaded = deleted
            .flatMap { _ in Observable.zip(apiClient.uploadImage(image: frontImage).asObservable(), apiClient.uploadImage(image: backImage).asObservable()) }
            .share()

        let documentUploaded = imagesUploaded
            .flatMap { arg -> Single<Void> in
                let (frontURL, backURL) = arg
                var updatedParams = parameters
                // add frontURL and backURL to parameters
                return apiClient.uploadDocument(parameters: updatedParams)
            }
            .share()

        let disposable = deleted
            .subscribe(onError: { observer(.success(ProcessResult.deleteFailure($0))) })
        let disposable1 = imagesUploaded
            .subscribe(onError: { observer(.success(ProcessResult.imageFailue($0))) })
        let disposable2 = documentUploaded
            .subscribe(
                onNext: { observer(.success(ProcessResult.success)) },
                onError: { observer(.success(ProcessResult.documentFailure($0))) }
        )

        return Disposables.create([disposable, disposable1, disposable2])
    }
}