What's the updated version of Manual Recursion to polling using Observables?

Question

A little bit of context: In this link: https://github.com/ReactiveX/RxJava/issues/448 @ben-lesh proposed a Manual Recursion implementation to polling using Observables. However in latest RxJava version there is no OnSubscribeFunc.

Here it is my current implementation:

Observable.create(new Observable.OnSubscribe<Item>() {
        @Override
        public void call(final Subscriber<? super Item> innerSubscriber) {

            Schedulers.io().createWorker()
                      .schedulePeriodically(new Action0() {
                          @Override
                          public void call() {
                              searchObservable()
                                      .doOnNext(new Action1<Item>() {
                                          @Override
                                          public void call(Item item) {
                                              innerSubscriber.onNext(item);
                                          }
                                      })
                                      .doOnError(new Action1<Throwable>() {
                                          @Override
                                          public void call(Throwable throwable) {
                                              if (throwable != null) {
                                                  innerSubscriber.onError(throwable);
                                              }
                                          }
                                      })
                                      .doOnCompleted(new Action0() {
                                          @Override
                                          public void call() {
                                              innerSubscriber.onCompleted();
                                          }
                                      }).subscribe(); // Set subscriber?
                          }
                      }, initialDelay, pollingInterval, TimeUnit.MINUTES);
        }
    })
            .subscribeOn(Schedulers.io()) // performs networking on background thread
            .observeOn(observeOnScheduler) // sends notifications to another Scheduler, usually the UI thread
            .subscribe(subscriber); // The subscriber

searchObservable performs a service request. This is working fine the first run, this is, the data is passed to the subscriber. However, after waiting the pollingInterval, the data returns and the doOnNext is executed but the data is not passed to the UI. Do I need to set any subscriber in the Action that schedulePeriodically takes?

score 0 · Answer 1 · answered Dec 28 '15 at 14:32

It stops because you are calling innerSubscriber.onCompleted which terminates the sequence on the first run. There are standard operators that can get you the same effect without the need to create a custom Observable:

Observable.interval(initialDelay, pollingInterval, TimeUnit.MINUTES, Schedulers.io())
.onBackpressureBuffer()
.concatMap(v -> searchObservable())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(subscriber);

(Remark: no need for subscribeOn() here because interval will emit on Schedulers.io() anyway.)

score 0 · Accepted Answer · answered Dec 28 '15 at 17:09

This is what is working fine for me and follows the paradigm of what Manual Recursion is:

public void manualRecursionPollingStrategy(Subscriber<Item> subscriber, Scheduler observeOnScheduler, long initialDelay, long pollingInterval) {
            Observable.create(new Observable.OnSubscribe<Item>() {
                @Override
                public void call(final Subscriber<? super Item> innerSubscriber) {
                    Schedulers.newThread().createWorker()
                              .schedulePeriodically(new Action0() {
                                  @Override
                                  public void call() {
                                              searchByHashtagObservable()
                                                      .subscribeOn(Schedulers.io()) // performs networking on background thread
                                                      .observeOn(observeOnScheduler) // sends notifications to a Scheduler, usually the
                                                              // UI thread
                                                      .subscribe(
                                                              new Action1<Item>() {
                                                                  @Override
                                                                  public void call(Item item) {
                                                                      subscriber.onNext(item);
                                                                  }
                                                              },
                                                              new Action1<Throwable>() {
                                                                  @Override
                                                                  public void call(Throwable throwable) {
                                                                      if (throwable != null) {
                                                                          subscriber.onError(throwable);
                                                                      }
                                                                  }
                                                              },
                                                              new Action0() {
                                                                  @Override
                                                                  public void call() {
                                                                      subscriber.onCompleted();
                                                                  }
                                                              }
                                                      )
                                  }
                              }, initialDelay, pollingInterval, TimeUnit.MINUTES);
                }
            })
              .observeOn(observeOnScheduler) // sends notifications to a Scheduler, usually the UI thread
              .subscribe(subscriber);

Please notice that I subscribe to searchByHashtagObservable() and call the onNext, onError and onCompleted of the Subscriber passed as param.

Thanks!

What's the updated version of Manual Recursion to polling using Observables?

2 Answers2