retryWhen未按预期重新订阅源

Question

I'm writing logic for checking status of an object every t seconds until it's completed. I decided to use retryWhen operator.

getObjectStatus(someObject: someObjectInstance)
    .flatMap { someObject -> Observable<SomeObject> in
        if someObject.status == .notProcessed {
            return .error(SomeObjectNotProcessed())
        } else {
            return .just(someObject)
        }
    }
    .retryWhen { errors -> Observable<Void> in
        let retry = errors.enumerated().flatMap { retryCount, error -> Observable<Void> in
            guard retryCount < statusRequestCount else {
                print("The maximum number of request has been reached.")
                return .error(error)
            }

            if error is SomeObjectNotProcessed {
                return Observable.just(Void())
                        .delay(statusRequestDelay, scheduler: BackgroundScheduler.instance)
            } else {
                return .error(error)
            }
        }

        return retry
    }
    .subscribeOn(BackgroundScheduler.instance)
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { [weak self] someObject in
        self?.someObjectProcessingSucceeded()
    }, onError: { [weak self] error in
        self?.someObjectProcessingFailed(error: error)
    })
    .disposed(by: disposeBag)

Where the getObjectStatus method create request to the server.

Now the problem is that with this code every t seconds ( statusRequestDelay actually) I'm not making a request to the server. Every t seconds it returns the same instance of someObject . If I replace getObjectStatus with:

Observable.just(Void())
    .flatMap { _ in self.getObjectStatus(someObject: someObjectInstance) }

it works perfectly, which means that it makes server request every t seconds. It looks like the first, original Observable is not repeating.

Answer 1

The problem is in how your getObjectStatus function is written. Apparently, it returns a .just or some other observable that doesn't actually retry the network call. Without seeing that code I can't give a definitive answer.

However notice this:

func getObjectStatus(someObject: Int) -> Observable<SomeObject> {
    var count = 0
    return Observable.create { observer in
        print("called getObjectStatus")
        if count < 3 {
            observer.onNext(SomeObject(status: .notProcessed))
            observer.onCompleted()
            count += 1
        }
        else {
            observer.onNext(SomeObject(status: .processed))
            observer.onCompleted()
        }
        return Disposables.create()
    }
}

Using the above with your chain will cause "called getObjectStatus" to print 3 times.

While:

var count = 0
func getObjectStatus(someObject: Int) -> Observable<SomeObject> {
    print("called getObjectStatus")
    if count < 3 {
        count += 1
        return Observable.just(SomeObject(status: .notProcessed))
    }
    else {
        return Observable.just(SomeObject(status: .processed))
    }
}

Will not.

The difference here is that in the latter case, the .just(SomeObject(status: .notProcessed)) is what is being resubscribed to, so it returns the same thing every time.

Burying the call in a flatMap works because it's the .just(Void()) that is getting resubscribed to which means the contents of the flatMap is called again.