How to subscribe and unsubscribe or cancel an rxjava observable

Question

I am new in RxJava and trying to update my asyncTask works to RxJava. As a first try I have done the following codes:

    public class MainActivity extends AppCompatActivity 
    {
        @Override
        protected void onCreate(Bundle savedInstanceState) 
        {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            doSomeWork();
        }


        private String funcCallServerGet()
        {
            //Some code to call a HttpClient Get method & return a response string
            //this is the method which previously i used to call inside asynctask doInbackground method
        }


          private void doSomeWork() {
               getSingleObservable()
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(getSingleObserver())    ;
        }


        private Single<String> getSingleObservable() 
        {
            return Single.create(new SingleOnSubscribe<String>() {
                @Override
                public void subscribe(SingleEmitter<String> emitter) throws Exception {
                    if(!emitter.isDisposed()) {
                        String strRxResponse =  funcCallServerGet();
                        emitter.onSuccess(strRxResponse);
                    }
                }
            });
        }


         private SingleObserver<String> getSingleObserver() 
        {

            return new SingleObserver<String>() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log.d(TAG, " onSubscribe getSingleObserver: " + d.isDisposed());             }

                @Override
                public void onSuccess(String value) {
                    Log.d(TAG, " onNext : value : " + value);          }

                @Override
                public void onError(Throwable e) {
                    Log.d(TAG, " onError : " + e.getMessage());         }
            };
        }

    }

But I have some confusions:

1. Why am I getting false in onSubscribe() of SingleObserver getSingleObserver() .

2. How do I unsubscribe or cancel the observable/observer when activities onStop() is called.

3. Also, what really happens when screen oriantation. Does the observable get unsubscribed automatically or it continues its work ? what to do for the device rotation ?

Answer 1

Why am I getting false in onSubscribe() of SingleObserver getSingleObserver() .

You're currently logging whether the disposable is disposed within the onSubscribe method. At this point the disposable hasn't been disposed yet.

How do I unsubscribe or cancel the observable/observer when activities onStop() is called.

Rather than use a SingleObserver you could use the subscribe method which returns a disposable. With this you could either manage the disposable directly or use a CompositeDisposable. You would then call the dispose method on that disposable, with CompositeDisposable this is achieved by calling clear()

private final CompositeDisposable disposables = new CompositeDisposable();

@Override
protected void onStart() {
    super.onStart();
    disposables.add(getSingleObservable()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(value -> {
                Log.d(TAG, " onSuccess: " + value);
            }, error -> {
                Log.e(TAG, " onError", error);
            }
        )
    );
}

@Override
protected void onStop() {
    disposables.clear();
    super.onStop();
}

Also, what really happens when screen oriantation. Does the observable get unsubscribed automatically or it continues its work ? what to do for the device rotation ?

By default no automatic management of the observable occurs, it's your responsibility to manage it. In your example code when the device rotates you will receive another call to onCreate, here you're scheduling the work to be executed again, work that was scheduled before rotation could still be running, so you could end up leaking the old activity and receiving a callback when the work succeeds or fails - in this case you'd see a log statement.

There are some tools that provide automatic observable management, though you should read the authors article about some of the issues that exist with this approach.

• https://blog.danlew.net/2017/08/02/why-not-rxlifecycle/
• https://github.com/trello/RxLifecycle
• https://github.com/uber/AutoDispose

Another option for you could be to look at the new Architecture Components library, specifically ViewModel and LiveData. This will simplify what you need to do with respect to subscription management and configuration changes.