onCompleted called early before processing RxJava concatMap

Question

I have two observables and used concatDelayError for sequential processing.

My problem is that onNext and onCompleted are called early before processing. How do I know that all processing has been completed with concatDelayError?

Psudo code:

public Observable<Integer> concat(){
     int x = 10;
     int y = 20;


        Observable obx = Observable.create(emitter -> {
                    try {
                        int x = doSomeThing();
                        emitter.onNext(x);
                        emitter.onCompleted();
                    } catch (SQLiteException e) {
                        emitter.onError(e);
                    }
                }, Emitter.BackpressureMode.BUFFER);   
        Observable oby = Observable.create(emitter -> {
                    try {
                        int y = doSomeThing();
                        emitter.onNext(y);
                        emitter.onCompleted();
                    } catch (SQLiteException e) {
                        emitter.onError(e);
                    }
                }, Emitter.BackpressureMode.BUFFER);       
        Observable concated =  Observable.concatDelayError(ob1,ob2)
                 .compose(applySchedulers())
                 .replay().autoConnect();  

  }

    //somewhere else

    concat().subscribe(mReplaySubject);


    //somewhere else

     mReplaySubject.subscribe(new Observer<Integer>() {
                        @Override
                        public void onCompleted() {
                            launchActivity(SplashActivity.this, HomeActivity.class);
                            SplashActivity.this.finish();
                        }    
                        @Override
                        public void onError(Throwable e) {
                            e.printStackTrace();
                        }    
                        @Override
                        public void onNext(Integer value) {

                        }
                    });

I am using reply() with autoConnect() and subscribing over ReplySubject as I need to share single subscription.

Are you sure your `Observer.onCompleted()` is called multiple times for a single subscription? — akarnokd, Jan 10 '18 at 09:28
Pls add some logging by applying *.doOnEach()* to both source observables, and the concatenated one. Otherwise it is indeed unclear. — Maxim Volgin, Jan 10 '18 at 09:58
@akarnokd I am using ReplaySubject. I have changed the question. Can you please answer the question? — krupal.agile, Jan 10 '18 at 10:54
@akarnokd I logged onCompleted and it is not calling multiple times but it is calling early even before processing has been completed — krupal.agile, Jan 10 '18 at 10:57
Have you tried subscribing to `concated` directly without `ReplaySubject`? `replay().autoConnect()` does the caching for you already at that point. — akarnokd, Jan 10 '18 at 11:24
@akarnokd I want to do some processing when it subscribes only for first time, then how can I do that? — krupal.agile, Jan 10 '18 at 11:41
Please provide the full standalone code you have trouble with as the code you listed is inconsistent with your comments. — akarnokd, Jan 10 '18 at 11:43
@akarnokd I have edited the question. I want to initialize this x and y on "only first time" subscription. How can I do that? — krupal.agile, Jan 10 '18 at 11:50
@akarnokd This is just an example of initializing. In actual I am clearing multiple arrays etc. — krupal.agile, Jan 10 '18 at 11:50

score 1 · Accepted Answer · answered Jan 10 '18 at 12:02

You can use doOnSubscribe before replay().autoConnect(), but you also need a way to make sure the returned Observable is set up at most once:

final class OnceObservable {

    final AtomicReference<Observable<Integer>> ref = new AtomicReference<>();

    int x;
    int y;

    Observable<Integer> concat() {
        Observable<Integer> obs = ref.get();
        if (obs != null) {
            return;
        }

        obs = Observable.concatDelayError(
            Observable.fromCallable(() -> doSomething()),
            Observable.fromCallable(() -> doSomethingElse())
        )
        .doOnSubscribe(() -> {
            x = 10;
            y = 20;
        })
        .replay().autoConnect();

        if (!ref.compareAndSet(null, obs)) {
            obs = ref.get();
        }
        return obs;
    }
}

One last question : Does .replay().autoConnect(); automatically do caching of subscription? — krupal.agile, Jan 10 '18 at 12:16

onCompleted called early before processing RxJava concatMap

1 Answers1