El resultado de la suscripción no se utiliza

Hoy he actualizado a Android Studio 3.1, que parece haber agregado algunas comprobaciones de pelusa más. Una de estas comprobaciones de pelusa es para subscribe()llamadas RxJava2 de una sola vez que no están almacenadas en una variable. Por ejemplo, obteniendo una lista de todos los jugadores de la base de datos de mi sala:

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

Da como resultado un gran bloque amarillo y esta información sobre herramientas:

El resultado de subscribeno se usa

¿Cuál es la mejor práctica para llamadas Rx únicas como esta? ¿Debo mantener pulsado Disposabley dispose()encendido completo? ¿O debería simplemente @SuppressLintseguir adelante?

Esto solo parece afectar a RxJava2 ( io.reactivex), RxJava ( rx) no tiene esta pelusa.

El IDE no sabe qué efectos potenciales puede tener su suscripción cuando no se desecha, por lo que la trata como potencialmente insegura. Por ejemplo, su Singlepuede contener una llamada de red, lo que podría causar una pérdida de memoria si Activityse abandona durante su ejecución.

Una forma conveniente de administrar una gran cantidad de mensajes de correo Disposableelectrónico es utilizar un CompositeDisposable ; simplemente cree una nueva CompositeDisposablevariable de instancia en su clase adjunta, luego agregue todos sus Desechables al CompositeDisposable (con RxKotlin puede simplemente agregar addTo(compositeDisposable)a todos sus Desechables). Finalmente, cuando haya terminado con su instancia, llame compositeDisposable.dispose().

Esto eliminará las advertencias de pelusa y garantizará que Disposablesse administren correctamente.

En este caso, el código se vería así:

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

En el momento en que se destruya la Actividad, la lista de Desechables se borra y estamos bien.

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

Puede suscribirse 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();
            }});

En caso de que necesite eliminar el Singleobjeto directamente (por ejemplo, antes de que se emita), puede implementar un método onSubscribe(Disposable d)para obtener y usar la Disposablereferencia.

También puede realizar la SingleObserverinterfaz por su cuenta o utilizar otras clases secundarias.

Como se sugirió, puede usar algunos globales CompositeDisposablepara agregar el resultado de la operación de suscripción allí.

La biblioteca RxJava2Extensions contiene métodos útiles para eliminar automáticamente los elementos desechables creados CompositeDisposablecuando se completa. Consulte la sección subscribeAutoDispose .

En su caso puede verse así

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

Puedes usar Uber AutoDispose y rxjava.as

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

Asegúrese de comprender cuándo cancela la suscripción en función de ScopeProvider.

Una y otra vez me encuentro volviendo a la cuestión de cómo deshacerse correctamente de las suscripciones, y a esta publicación en particular. Varios blogs y charlas afirman que no llamar disposenecesariamente conduce a una pérdida de memoria, lo que creo que es una afirmación demasiado general. Según tengo entendido, la advertencia de pelusa sobre no almacenar el resultado de no subscribees un problema en algunos casos, porque:

• No todos los observables se ejecutan en el contexto de una actividad de Android
• Lo observable puede ser sincrónico
• Dispose se llama implícitamente, siempre que el observable complete

Como no quiero suprimir las advertencias de pelusa, recientemente comencé a usar el siguiente patrón para casos con un observable sincrónico:

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

Me interesaría cualquier comentario sobre esto, independientemente de si es una confirmación de la corrección o el descubrimiento de una laguna.

Hay otra forma disponible, que es evitar usar Desechables manualmente (agregar y eliminar suscripciones).

Puede definir un Observable y ese observable recibirá el contenido de un SubjectBehaviour (en caso de que use RxJava). Y al pasar ese observable a su LiveData , debería funcionar. Vea el siguiente ejemplo basado en la pregunta inicial:

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