Результат подписки не используется

Сегодня я обновился до Android Studio 3.1, который, кажется, добавил еще несколько проверок на ворсинок. Одна из этих проверок линта предназначена для однократных subscribe()вызовов RxJava2 , которые не хранятся в переменной. Например, получение списка всех игроков из базы данных моей комнаты:

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

В результате появится большой желтый блок и всплывающая подсказка:

Результат subscribeне используется

Какова наилучшая практика для таких однократных вызовов Rx? Должен ли я придерживаться Disposableи dispose()по полной? Или мне просто нужно @SuppressLintдвигаться дальше?

Кажется, это влияет только на RxJava2 ( io.reactivex), RxJava ( rx) не имеет этого линта.

IDE не знает, какие потенциальные последствия может иметь ваша подписка, если она не удалена, поэтому она рассматривает ее как потенциально опасную. Например, ваш Singleможет содержать сетевой вызов, который может вызвать утечку памяти, если вас Activityбросят во время его выполнения.

Удобный способ управлять большим количеством Disposables - использовать CompositeDisposable ; просто создайте новую CompositeDisposableпеременную экземпляра в вашем включающем классе, затем добавьте все свои Disposables в CompositeDisposable (с RxKotlin вы можете просто добавить addTo(compositeDisposable)ко всем своим Disposable). Наконец, когда вы закончите со своим экземпляром, позвоните compositeDisposable.dispose().

Это избавит от предупреждений о ворсинках и обеспечит Disposablesправильное управление.

В этом случае код будет выглядеть так:

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()).

В тот момент, когда Activity будет уничтожен, список Disposables очищается, и все в порядке.

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

Вы можете подписаться с 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();
            }});

В случае, если вам нужно напрямую удалить Singleобъект (например, до того, как он испускается), вы можете реализовать метод onSubscribe(Disposable d)для получения и использованияDisposable ссылки.

Вы также можете реализовать SingleObserverинтерфейс самостоятельно или использовать другие дочерние классы.

Как было предложено, вы можете использовать некоторые глобальные данные, CompositeDisposableчтобы добавить туда результат операции подписки.

Библиотека RxJava2Extensions содержит полезные методы для автоматического удаления созданного одноразового использования из файлаCompositeDisposable после его завершения. См. Раздел subscribeAutoDispose .

В вашем случае это может выглядеть так

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

Вы можете использовать Uber AutoDispose и rxjava.as

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

Убедитесь, что вы понимаете, когда отказываетесь от подписки на основе ScopeProvider.

Снова и снова я возвращаюсь к вопросу о том, как правильно распоряжаться подписками и, в частности, с этой публикацией. В нескольких блогах и в беседах утверждается, что отказ от вызова disposeобязательно ведет к утечке памяти, что, на мой взгляд, является слишком общим утверждением. Насколько я понимаю, предупреждение о subscribeнесохранении результата не является проблемой в некоторых случаях, потому что:

• Не все наблюдаемые работают в контексте активности Android.
• Наблюдаемое может быть синхронным
• Dispose вызывается неявно, если наблюдаемый завершается

Поскольку я не хочу подавлять предупреждения о ворсинах, я недавно начал использовать следующий шаблон для случаев с синхронным наблюдаемым:

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()
      }
   )

Мне были бы интересны любые комментарии по этому поводу, независимо от того, является ли это подтверждением правильности или обнаружением лазейки.

Доступен еще один способ, который позволяет избежать использования Disposables вручную (добавлять и удалять подписки).

Вы можете определить Observable, и этот Observable будет получать контент от SubjectBehaviour (если вы используете RxJava). И если передать это наблюдаемое в LiveData , это должно сработать. Посмотрите следующий пример, основанный на первоначальном вопросе:

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> }

Если вы уверены, что одноразовые предметы обрабатываются правильно, например, используя оператор doOnSubscribe (), вы можете добавить это в Gradle:

android {
lintOptions {
     disable 'CheckResult'
}}