Wynik subskrypcji nie jest używany

Zaktualizowałem dzisiaj do Android Studio 3.1, który wydaje się mieć kilka dodatkowych sprawdzeń kłaczków. Jedno z tych sprawdzeń lintów dotyczy jednorazowych subscribe()wywołań RxJava2 , które nie są przechowywane w zmiennej. Na przykład, pobieranie listy wszystkich graczy z mojej bazy danych Pokoju:

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

W rezultacie powstaje duży żółty blok i ta podpowiedź:

Wynik subscribenie jest używany

Jaka jest najlepsza praktyka w przypadku takich jednorazowych wywołań Rx? Czy powinienem zachować kompletność Disposablei dispose()na? A może powinienem po prostu @SuppressLintiść dalej?

Wydaje się, że dotyczy to tylko RxJava2 ( io.reactivex), RxJava ( rx) nie ma tego linta .

Środowisko IDE nie wie, jakie potencjalne skutki może mieć Twoja subskrypcja, gdy nie zostanie wyrzucona, więc traktuje ją jako potencjalnie niebezpieczną. Na przykład Singlemoże zawierać wywołanie sieciowe, które może spowodować wyciek pamięci, jeśli Activityzostanie porzucone podczas wykonywania.

Wygodnym sposobem zarządzania dużą liczbą Disposables jest użycie CompositeDisposable ; po prostu utwórz nową CompositeDisposablezmienną instancji w klasie otaczającej, a następnie dodaj wszystkie swoje produkty jednorazowe do CompositeDisposable (za pomocą RxKotlin możesz po prostu dołączyć addTo(compositeDisposable)do wszystkich swoich produktów jednorazowych). Wreszcie, kiedy skończysz z instancją, zadzwoń compositeDisposable.dispose().

Pozwoli to usunąć ostrzeżenia o kłaczkach i zapewni Disposablesprawidłowe zarządzanie.

W tym przypadku kod wyglądałby tak:

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

W momencie zniszczenia Aktywności lista rzeczy jednorazowego użytku zostaje wyczyszczona i wszystko jest w porządku.

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

Możesz subskrybować za pomocą 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();
            }});

W przypadku, gdy chcesz bezpośrednio pozbyć się Singleobiektu (np. Zanim wyemituje), możesz zaimplementować metodę, onSubscribe(Disposable d)aby uzyskać i użyć Disposablereferencji.

Możesz również zrealizować SingleObserverinterfejs samodzielnie lub użyć innych klas podrzędnych.

Jak sugerowano, możesz użyć globalnego, CompositeDisposableaby dodać tam wynik operacji subskrypcji.

RxJava2Extensions biblioteka zawiera użyteczne sposoby, aby automatycznie usunąć utworzone jednorazowe od CompositeDisposablekiedy to kończy. Zobacz sekcję subscribeAutoDispose .

W twoim przypadku może to wyglądać tak

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

Możesz użyć Uber AutoDispose i rxjava.as

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

Upewnij się, że rozumiesz, kiedy rezygnujesz z subskrypcji na podstawie ScopeProvider.

Ciągle wracam do pytania, jak prawidłowo pozbyć się subskrypcji, aw szczególności do tego postu. Kilka blogów i wykładów twierdzi, że nieudane wezwanie disposeprowadzi do wycieku pamięci, co moim zdaniem jest zbyt ogólne. W moim rozumieniu ostrzeżenie o subscribenieprzechowywaniu wyniku w niektórych przypadkach nie stanowi problemu, ponieważ:

• Nie wszystkie obserwowalne działają w kontekście działania systemu Android
• Obserwowalne może być synchroniczne
• Dispose jest wywoływana niejawnie, pod warunkiem, że obserwowalne zostaną zakończone

Ponieważ nie chcę tłumić ostrzeżeń o kłaczkach, ostatnio zacząłem używać następującego wzorca dla przypadków z obserwowalnym synchronicznym:

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

Byłbym zainteresowany wszelkimi komentarzami na ten temat, niezależnie od tego, czy jest to potwierdzenie poprawności, czy odkrycie luki.

Istnieje inny sposób, który polega na unikaniu ręcznego używania produktów jednorazowych (dodawanie i usuwanie subskrypcji).

Możesz zdefiniować Observable, który otrzyma zawartość z SubjectBehaviour (w przypadku korzystania z RxJava). I przekazując to obserwowalne do LiveData , powinno to działać. Sprawdź następny przykład oparty na pierwszym pytaniu:

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

Jeśli jesteś pewien, że disposable obsługiwane poprawnie, na przykład za pomocą operatora doOnSubscribe (), możesz dodać to do Gradle:

android {
lintOptions {
     disable 'CheckResult'
}}