Single.retry(When)

[TastyPi]

It would be nice if Single had retry operators like Observable.

Single<T> retry();

Single<T> retry(long count);

Single<T> retry(Func2<Integer, Throwable, Boolean> predicate);

Single<T> retryWhen(Func1<? super Observable<? extends Throwable>, ? extends Observable<?>>
    notificationHandler);

Single<T> retryWhen(
    Func1<? super Observable<? extends Throwable>, ? extends Observable<?>> notificationHandler,
    Scheduler scheduler);

The one I actually want is retryWhen but I imagine they'd have similar enough implementations to be fairly straightforward once you have one.

[passsy]

+1

[akarnokd]

These are now implemented:

• Single retry();
• Single retry(long count);
• Single retry(Func2<Integer, Throwable, Boolean> predicate);
• Single retryWhen(Func1, ? extends Observable>
  notificationHandler);

The variant with the Scheduler isn't (and probably shouldn't even exist in the first place).

Let me know if they work out for you.

[Lechenko]

Scheduler scheduler = Schedulers.from(Executors.newSingleThreadExecutor());
        Observable.fromCallable(()-> Observable.just(""))
                .flatMapSingle(v -> rest.send())
                .repeatWhen(completed -> completed.delay(10_000,TimeUnit.MILLISECONDS))
                .retryWhen(err -> err.delay(10_000,TimeUnit.MILLISECONDS))
                .subscribeOn(scheduler)
                .subscribe(new DisposableObserver<Boolean>() {
                    @Override
                    public void onNext(Boolean flag) {
                        Timber.e("onNext %s",flag);
                        if (flag){
                            dispose();
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        Timber.e("onError %s",e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Timber.e("onComplete ");
                    }
                });