O resultado da assinatura não é usado

Atualizei para o Android Studio 3.1 hoje, o que parece ter adicionado mais algumas verificações. Uma dessas verificações de fiapos é para subscribe()chamadas RxJava2 de uma só vez que não são armazenadas em uma variável. Por exemplo, obtendo uma lista de todos os jogadores do banco de dados da minha sala:

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

Resulta em um grande bloco amarelo e esta dica de ferramenta:

O resultado de subscribenão é usado

Qual é a melhor prática para chamadas Rx únicas como essa? Devo manter a preensão do Disposablee dispose()em completa? Ou devo apenas @SuppressLintseguir em frente?

Isso parece afetar apenas RxJava2 ( io.reactivex), RxJava ( rx) não possui esse fiapo.

O IDE não sabe quais os efeitos potenciais que sua assinatura pode ter quando não é descartada; portanto, trata-a como potencialmente insegura. Por exemplo, você Singlepode conter uma chamada de rede, o que pode causar um vazamento de memória se você Activityfor abandonado durante a execução.

Uma maneira conveniente de gerenciar uma grande quantidade de Disposables é usar um CompositeDisposable ; basta criar uma nova CompositeDisposablevariável de instância em sua classe anexa e adicionar todos os seus Disposables ao CompositeDisposable (com o RxKotlin, você pode simplesmente anexar addTo(compositeDisposable)todos os seus Disposables). Por fim, quando terminar sua instância, ligue compositeDisposable.dispose().

Isso eliminará os avisos de fiapos e garantirá que você Disposablesseja gerenciado corretamente.

Nesse caso, o código seria semelhante 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()).

No momento em que a atividade será destruída, a lista de descartáveis ​​é limpa e nós estamos bem.

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

Você pode se inscrever com 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();
            }});

Caso você precise descartar diretamente o Singleobjeto (por exemplo, antes que ele seja emitido), você pode implementar o método onSubscribe(Disposable d)para obter e usar a Disposablereferência.

Você também pode realizar a SingleObserverinterface por conta própria ou usar outras classes filho.

Como foi sugerido, você pode usar um pouco de global CompositeDisposablepara adicionar o resultado da operação de inscrição lá.

A biblioteca RxJava2Extensions contém métodos úteis para remover automaticamente o descartável criado do CompositeDisposablequando ele é concluído. Consulte a seção subscribeAutoDispose .

No seu caso, pode ser assim

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

Você pode usar o Uber AutoDispose e o rxjava.as

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

Certifique-se de entender quando cancelar a inscrição com base no ScopeProvider.

Repetidas vezes, volto à questão de como descartar corretamente as assinaturas e a esta publicação em particular. Vários blogs e conversas afirmam que não chamar disposenecessariamente leva a um vazamento de memória, o que eu acho que é uma afirmação muito geral. Em meu entendimento, o aviso de não utilização do resultado de subscribenão é um problema em alguns casos, porque:

• Nem todos os observáveis ​​são executados no contexto de uma atividade do Android
• O observável pode ser síncrono
• Dispose é chamado implicitamente, desde que o observável seja concluído

Como não quero suprimir avisos de fiapos, recentemente comecei a usar o seguinte padrão para casos com um observável síncrono:

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

Eu estaria interessado em quaisquer comentários sobre isso, independentemente de ser uma confirmação de correção ou a descoberta de uma brecha.

Existe outra maneira disponível, que é evitar o uso manual de descartáveis ​​(adicionar e remover assinaturas).

Você pode definir um Observável e esse observável receberá o conteúdo de um SubjectBehaviour (caso você use RxJava). E passando isso observável ao seu LiveData , isso deve funcionar. Confira o próximo exemplo com base na pergunta 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> }

Se você tem certeza de que o descartável foi tratado corretamente, por exemplo, usando o operador doOnSubscribe (), você pode adicioná-lo ao Gradle:

android {
lintOptions {
     disable 'CheckResult'
}}