How to make N-retries with D-delay when observable fail with RxJava

RxRetryWithDelaySample.java

Observable.<Integer>error(new RuntimeException("Hey, try to catch it!"))
                .doOnError(new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e("TEST", "DO ON ERROR CALLBACK");
                    }
                })
                .compose(new Observable.Transformer<Integer, Integer>() {
                    @Override
                    public Observable<Integer> call(Observable<Integer> integerObservable) {
                        Log.e("TEST", "OBSERVABLE IS " + integerObservable);
                        return integerObservable;
                    }
                })
                .retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
                    @Override
                    public Observable<?> call(Observable<? extends Throwable> observable) {
                        Log.e("TEST", "RETRY WHEN");
                        return observable
                                .zipWith(Observable.range(1, 3),
                                        new Func2<Throwable, Integer, Integer>() {
                                            @Override
                                            public Integer call(Throwable throwable, Integer attemptNumber) {
                                                if (attemptNumber > 3 - 1) {
                                                    throw new RuntimeException(throwable);
                                                }
                                                return attemptNumber;
                                            }
                                        })
                                .flatMap(new Func1<Integer, Observable<Long>>() {
                                    @Override
                                    public Observable<Long> call(Integer attemptNumber) {
                                        long delay = attemptNumber * 10;
                                        Log.e("TEST", "Delay retry by " + delay + " ms");
                                        return Observable.timer(delay, TimeUnit.MILLISECONDS);
                                    }
                                })
                                .onErrorResumeNext(new Func1<Throwable, Observable<? extends Long>>() {
                                    @Override
                                    public Observable<? extends Long> call(Throwable throwable) {
                                        if (throwable.getCause() == null) {
                                            return Observable.error(throwable);
                                        }
                                        return Observable.error(throwable.getCause());
                                    }
                                });
                    }
                }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e("TEST", "ON COMPLETED()");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("TEST", "ON ERROR: " + e.getMessage());
            }

            @Override
            public void onNext(Integer integer) {
                Log.e("TEST", "ON NEXT: " + integer);
            }
        });