web-dev-qa-db-fra.com

Est-il recommandé d'appeler Disposable.dispose () dès qu'un abonnement termine son travail?

J'ai une variable Activity dans laquelle je crée et souscris à plusieurs instances de la classe Single (chacune effectuant certaines tâches dans un fil de travail en arrière-plan distinct). Pour chaque abonnement, j'ajoute l'instance Disposable qui est créée à une instance CompositeDisposable qui est étendue à la Activity. Lorsque la Activity est détruite, j'appelle la méthode CompositeDisposable.clear() pour disposer de tous les abonnements de la Activity. Cela signifie bien sûr que toutes les instances Disposable (y compris celles relatives aux abonnements ayant terminé leur travail) traînent dans ma Activity jusqu'à ce que la Activity soit détruite.

Est-ce correct ou devrais-je appeler Disposable.dispose() pour chaque abonnement individuel chaque fois que l'instance Single particulière termine son travail (c'est-à-dire lorsque la SingleObserver reçoit le rappel onSuccess ou onError)? Le problème avec cette dernière approche est que je dois garder une trace de ce que Disposable est associé à SingleObserver (ce qui annule le point d'utiliser CompositeDisposable). Existe-t-il une meilleure approche pour disposer d’un abonnement chaque fois qu’une instance Single termine son travail?

androidrx-java2
9
Adil Hussain

Non, vous ne devriez pas. Lorsqu'un Observable est terminé, Observable est éliminé par lui-même.
Cela fait partie du Contrat observable :

Lorsqu'un observable envoie une notification OnError ou OnComplete à ses observateurs, cela met fin à la souscription. Les observateurs n'ont pas besoin d'émettre une notification de désabonnement pour mettre fin aux abonnements terminés par Observable de cette manière.

15
yosriz

La réponse de Yosriz est la bonne réponse, mais si vous voulez supprimer les instances Disposable de votre instance CompositeDrawable car les abonnements Single sont terminés (et que les instances Disposable ne traînent pas), alors j'ai mis en place cette classe ...

public abstract class MySingleObserver<T> implements SingleObserver<T> {

    private Disposable disposable;

    @Override
    public void onSubscribe(@NonNull Disposable disposable) {
        this.disposable = disposable;
        onStart();
    }

    public Disposable getDisposable() {
        return disposable;
    }

    public abstract void onStart();
}

... que vous pouvez transmettre en tant que SingleObserver à vos abonnements Single comme suit:

Single.just(1)
      .subscribe(new MySingleObserver<Integer>() {

          @Override
          public void onStart() {
              MyActivity.this.myCompositeDisposable.add(getDisposable());
              // do something further
          }

          @Override
          public void onSuccess(@NonNull Integer success) {
              MyActivity.this.myCompositeDisposable.remove(getDisposable());
              // do something further
          }

          @Override
          public void onError(@NonNull Throwable error) {
              MyActivity.this.myCompositeDisposable.remove(getDisposable());
              // do something further
          }
      });
1
Adil Hussain