The result of subscribe is not used

Question

I've upgraded to Android Studio 3.1 today, which seems to have added a few more lint checks. One of these lint checks is for one-shot RxJava2 subscribe() calls that are not stored in a variable. For example, getting a list of all players from my Room database:

Single.just(db)
            .subscribeOn(Schedulers.io())
            .subscribe(db -> db.playerDao().getAll());

Results in a big yellow block and this tooltip:

The result of subscribe is not used

What is the best practice for one-shot Rx calls like this? Should I keep hold of the Disposable and dispose() on complete? Or should I just @SuppressLint and move on?

This only seems to affect RxJava2 (io.reactivex), RxJava (rx) does not have this lint.

Rustication

Of both your solutions, I honestly think @SuppressLint is not the best one. Maybe I'm wrong but I really think code should never alter the IDE warnings and/or hints – Attenuator

@ArthurAttout Agreed, currently I'm keeping hold of the Disposable at member scope and calling dispose() when the single completes, but it seems needlessly cumbersome. I'm interested to see if there's any better ways of doing this. – Rustication

I think this lint warning is annoying when the RxJava stream isn't subscribed-to from within an Activity/Fragment/ViewModel. I have a Completable that can safely run without any regard for the Activity lifecycle, yet I still need to dispose of it? – Coalfield

consider RxLifecycle – Schach

Answer 1

The IDE does not know what potential effects your subscription can have when it's not disposed, so it treats it as potentially unsafe. For example, your Single may contain a network call, which could cause a memory leak if your Activity is abandoned during its execution.

A convenient way to manage a large amount of Disposables is to use a CompositeDisposable; just create a new CompositeDisposable instance variable in your enclosing class, then add all your Disposables to the CompositeDisposable (with RxKotlin you can just append addTo(compositeDisposable) to all of your Disposables). Finally, when you're done with your instance, call compositeDisposable.dispose().

This will get rid of the lint warnings, and ensure your Disposables are managed properly.

In this case, the code would look like:

CompositeDisposable compositeDisposable = new CompositeDisposable();

Disposable disposable = Single.just(db)
        .subscribeOn(Schedulers.io())
        .subscribe(db -> db.get(1)));

compositeDisposable.add(disposable); //IDE is satisfied that the Disposable is being managed. 
disposable.addTo(compositeDisposable); //Alternatively, use this RxKotlin extension function.


compositeDisposable.dispose(); //Placed wherever we'd like to dispose our Disposables (i.e. in onDestroy()).

Driblet

I'm getting compile error error: cannot find symbol method addTo(CompositeDisposable) with "rxjava:2.1.13". Where does this method come from? (RxSwift or RxKotlin I suppose) – Nonperishable

Yes, it's an RxKotlin method. – Driblet

what to do in case of flowable – Tracitracie

What if we are doing this in doOnSubscribe – Ferde

It would not cause a memory leak. Once the network call finishes and the onComplete is called, the garbage collection will deal with the rest unless you've kept an explicit reference of the disposable and don't dispose it. – Endermic

It's not work for me. I used Observable in Retrofit – Disillusionize

@GabrielVasconcelos what if the network call never finishes? Or passes context somewhere else? We need to notify upstream producers that the observing is done and to release any resources we passed to them. – Driblet

Answer 2

The moment the Activity will be destroyed, the list of Disposables gets cleared and we’re good.

io.reactivex.disposables.CompositeDisposable mDisposable;

    mDisposable = new CompositeDisposable();

    mDisposable.add(
            Single.just(db)
                    .subscribeOn(Schedulers.io())
                    .subscribe(db -> db.get(1)));

    mDisposable.dispose(); // dispose wherever is required

Jobe

Answer 3

You can subscribe with DisposableSingleObserver:

Single.just(db)
    .subscribeOn(Schedulers.io())
    .subscribe(new DisposableSingleObserver<Object>() {
            @Override
            public void onSuccess(Object obj) {
                // work with the resulting todos...
                dispose();
            }

            @Override
            public void onError(Throwable e) {
                // handle the error case...
                dispose();
            }});

In case you need to directly dispose Single object (e.g. before it emits) you can implement method onSubscribe(Disposable d) to get and use the Disposable reference.

You can also realize SingleObserver interface by your own or use other child classes.

Charolettecharon

Answer 4

As was suggested you may use some global CompositeDisposable to add the result of the subscribe operation there.

The RxJava2Extensions library contains useful methods to automatically remove created disposable from the CompositeDisposable when it completes. See subscribeAutoDispose section.

In your case it may look like this

SingleConsumers.subscribeAutoDispose(
    Single.just(db)
            .subscribeOn(Schedulers.io()),
    composite,
    db -> db.playerDao().getAll())

Boffin

Answer 5

You can use Uber AutoDispose and rxjava .as

        Single.just(db)
            .subscribeOn(Schedulers.io())
            .as(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this)))
            .subscribe(db -> db.playerDao().getAll());

Make sure that you understand when you unsubscribe based on the ScopeProvider.

Sarasvati

This assumes a lifecycle provider is available. Also, the "as" method is marked as unstable, so using it will result in a Lint warning. – Beardless

Thanks @Dabbler, agreed. The .as method was experimental until RxJava 2.1.7 and on 2.2 it's stable. – Sarasvati

Answer 6

Again and again I find myself coming back to the question of how to correctly dispose of subscriptions, and to this posting in particular. Several blogs and talks claim that failing to call dispose necessarily leads to a memory leak, which I think is a too general statement. In my understanding, the lint warning about not storing the result of subscribe is a non-issue in some cases, because:

• Not all observables run in the context of an Android activity
• The observable can be synchronous
• Dispose is called implicitly, provided the observable completes

Since I don't want to suppress lint warnings I recently started to use the following pattern for cases with a synchronous observable:

var disposable: Disposable? = null

disposable = Observable
   .just(/* Whatever */)
   .anyOperator()
   .anyOtherOperator()
   .subscribe(
      { /* onSuccess */ },
      { /* onError */ },
      {
         // onComplete
         // Make lint happy. It's already disposed because the stream completed.
         disposable?.dispose()
      }
   )

I'd be interested in any comments on this, regardless of whether it's a confirmation of correctness or the discovery of a loophole.

Beardless

Answer 7

There's another way available, which is avoiding to use Disposables manually (add and remove subscriptions).

You can define an Observable and that observable is going to receive the content from a SubjectBehaviour (in case you use RxJava). And by passing that observable to your LiveData, that should work. Check out the next example based on the initial question:

private val playerSubject: Subject<Player> = BehaviorSubject.create()

private fun getPlayer(idPlayer: String) {
        playerSubject.onNext(idPlayer)
}

private val playerSuccessful: Observable<DataResult<Player>> = playerSubject
                        .flatMap { playerId ->
                            playerRepository.getPlayer(playerId).toObservable()
                        }
                        .share()

val playerFound: LiveData<Player>
    get() = playerSuccessful
        .filterAndMapDataSuccess()
        .toLiveData()

val playerNotFound: LiveData<Unit>
    get() = playerSuccessful.filterAndMapDataFailure()
        .map { Unit }
        .toLiveData()

// These are a couple of helpful extensions

fun <T> Observable<DataResult<T>>.filterAndMapDataSuccess(): Observable<T> =
filter { it is DataResult.Success }.map { (it as DataResult.Success).data }

fun <T> Observable<DataResult<T>>.filterAndMapDataFailure(): Observable<DataResult.Failure<T>> =
filter { it is DataResult.Failure }.map { it as DataResult.Failure<T> }

Herson