RxJava. Sequential execution

Question

In my Android App I have a presenter which handles user interactions, contains kind of request manager and if needed sends user input over request manager to request manager.

Answer 1

I don't fnd any elegant native-RxJava solution. So I will custom a Subscriber to do your work.

For your 3 points:

1. For sequential execution, we create a single thread scheduler

   Scheduler sequential = Schedulers.from(Executors.newFixedThreadPool(1));

2. For stop all requests when error occur, we should subscribe all request together instead of create a Flowable every time. So we define following functions (here I request is Integer and response String):

   void sendRequest(Integer request)

   Flowable reciveResponse()

   and define a field to make association of request and response flow:

   FlowableProcessor requestQueue = UnicastProcessor.create();

3. For re-run the not-sent request, we define the rerun function:

   void rerun()

Then we can use it:

reciveResponse().subscribe(/**your subscriber**/)

Now let us implement them.

When send request, we simply push it into requestQueue

public void sendRequest(Integer request) {
  requestQueue.onNext(request);
}

First, to do the request sequentialy, we should schedule work to sequential:

requestQueue
  .observeOn(sequential)
  .map(i -> mockLongTimeRequest(i)) // mock for your serverApi.process
  .observeOn(AndroidSchedulers.mainThread());

Second, to stop request when error occur. It's a default behavior. If we do nothing, an error will broken the subscription and any futher items will not be emitted.

Third, to re-run the not-sent requests. First because that the native operator will cancel the stream, like MapSubscriber do (RxJava-2.1.0-FlowableMap#63):

try {
    v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
    fail(ex);// fail will call cancel
    return;
}

We should wrap the error. Here I use my Try class to wrap the possible exception, you can use any other implementation that can wrap the exception instead of throw it:

    .map(i -> Try.to(() -> mockLongTimeRequest(i)))

And then it's the custom OnErrorStopSubscriber implements Subscriber>, Subscription.

It request and emits items normally. When error occur(in fact is a failed Try emitted) it stopped there and won't request or emit even downstream request it. After call rerun method, it will back to the running statu and emit normally. The class is about 80 lines. You can see the code on my github.

Now we can test our code:

public static void main(String[] args) throws InterruptedException {
  Q47264933 q = new Q47264933();
  IntStream.range(1, 10).forEach(i -> q.sendRequest(i));// emit 1 to 10
  q.reciveResponse().subscribe(e -> System.out.println("\tdo for: " + e));
  Thread.sleep(10000);
  q.rerun(); // re-run after 10s
  Thread.sleep(10000);// wait for it complete because the worker thread is deamon
}

private String mockLongTimeRequest(int i) {
  Thread.sleep((long) (1000 * Math.random()));
  if (i == 5) {
    throw new RuntimeException(); // error occur when request 5
  }
  return Integer.toString(i);
}

and output:

1 start at:129
1 done  at:948
2 start at:950
    do for: 1
2 done  at:1383
3 start at:1383
    do for: 2
3 done  at:1778
4 start at:1778
    do for: 3
4 done  at:2397
5 start at:2397
    do for: 4
error happen: java.lang.RuntimeException
6 start at:10129
6 done  at:10253
7 start at:10253
    do for: 6
7 done  at:10415
8 start at:10415
    do for: 7
8 done  at:10874
9 start at:10874
    do for: 8
9 done  at:11544
    do for: 9

You can see it runs sequentialy. And stopped when error occur. After call rerun method, it continue handle the left not-sent request.

For complete code, see my github.