Il risultato dell'iscrizione non viene utilizzato

Ho eseguito l'aggiornamento ad Android Studio 3.1 oggi, che sembra aver aggiunto alcuni controlli di lanugine. Uno di questi controlli di lanugine è per le subscribe()chiamate RxJava2 one-shot che non sono archiviate in una variabile. Ad esempio, ottenere un elenco di tutti i giocatori dal mio database Room:

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

Risultati in un grande blocco giallo e questa descrizione comandi:

Il risultato di subscribenon viene utilizzato

Qual è la migliore pratica per chiamate Rx one-shot come questa? Devo tenere premuto il Disposablee dispose()su completo? O dovrei solo @SuppressLintandare avanti?

Questo sembra influenzare solo RxJava2 ( io.reactivex), RxJava ( rx) non ha questa lanugine.

L'IDE non sa quali potenziali effetti può avere l'abbonamento quando non viene eliminato, quindi lo considera potenzialmente pericoloso. Ad esempio, Singlepotrebbe contenere una chiamata di rete, che potrebbe causare una perdita di memoria se Activityviene abbandonato durante la sua esecuzione.

Un modo conveniente per gestire una grande quantità di Disposables è usare un CompositeDisposable ; basta creare una nuova CompositeDisposablevariabile di istanza nella classe che lo racchiude, quindi aggiungere tutti i materiali monouso a CompositeDisposable (con RxKotlin è possibile semplicemente aggiungere addTo(compositeDisposable)tutti i materiali monouso). Alla fine, quando hai finito con la tua istanza, chiama compositeDisposable.dispose().

Questo eliminerà gli avvisi di lanugine e garantirà la Disposablescorretta gestione.

In questo caso, il codice sarebbe simile a:

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

Nel momento in cui l'attività verrà distrutta, l'elenco dei prodotti usa e getta viene cancellato e siamo a posto.

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

Puoi abbonarti con 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();
            }});

Nel caso in cui sia necessario disporre direttamente l' Singleoggetto (ad es. Prima dell'emissione), è possibile implementare il metodo onSubscribe(Disposable d)per ottenere e utilizzare il Disposableriferimento.

Puoi anche realizzare l' SingleObserverinterfaccia da solo o utilizzare altre classi secondarie.

Come è stato suggerito, è possibile utilizzare alcuni globali CompositeDisposableper aggiungere lì il risultato dell'operazione di iscrizione.

La libreria RxJava2Extensions contiene metodi utili per rimuovere automaticamente gli oggetti monouso creati dal CompositeDisposablecompletamento. Vedi la sezione iscriviti AutoDispose.

Nel tuo caso potrebbe apparire così

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

È possibile utilizzare Uber AutoDispose e rxjava.as

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

Assicurati di capire quando annulli l'iscrizione in base a ScopeProvider.

Ancora e ancora mi ritrovo a tornare alla domanda su come smaltire correttamente gli abbonamenti, e in particolare a questa pubblicazione. Diversi blog e conferenze sostengono che non riuscire a chiamare disposeporta necessariamente a una perdita di memoria, che penso sia un'affermazione troppo generale. A mio avviso, subscribein alcuni casi l'avvertimento relativo al non memorizzare il risultato è un problema, poiché:

• Non tutti gli osservabili vengono eseguiti nel contesto di un'attività Android
• L'osservabile può essere sincrono
• Dispose viene chiamato implicitamente, a condizione che l'osservabile venga completato

Dato che non voglio sopprimere gli avvisi sui filacci, di recente ho iniziato a utilizzare il modello seguente per i casi con un osservatore sincrono:

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

Sarei interessato a qualsiasi commento su questo, indipendentemente dal fatto che si tratti di una conferma di correttezza o della scoperta di una scappatoia.

C'è un altro modo disponibile, che sta evitando di usare i prodotti usa e getta manualmente (aggiungere e rimuovere gli abbonamenti).

È possibile definire un osservabile e tale osservabile riceverà il contenuto da un soggetto (nel caso in cui si utilizzi RxJava). E passando quello osservabile al tuo LiveData , dovrebbe funzionare. Guarda il prossimo esempio basato sulla domanda iniziale:

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

Se si è certi che il monouso sia gestito correttamente, ad esempio utilizzando l'operatore doOnSubscribe (), è possibile aggiungere questo a Gradle:

android {
lintOptions {
     disable 'CheckResult'
}}