Comment appeler une méthode après un retard dans Android en utilisant rxjava?

Question

J'essaie de remplacer ma méthode Handler par Rx java. mon exigence

Je veux appeler la méthode getTransactionDetails () seulement après 5 secondes.

ce mon code de travail en utilisant Handler

 new Handler().postDelayed(new Runnable() {
      @Override
      public void run() {
        getTransactionDetails();
      }
    }, 5000); 
 

Code Java RX - cela ne fonctionne pas

 Observable.empty().delay(5000, TimeUnit.MILLISECONDS)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .doOnNext(o -> getTransactionDetails())
        .subscribe();
 

Answer 1

C'est la façon dont je le ferais:

    Completable.timer(5, TimeUnit.SECONDS, AndroidSchedulers.mainThread())
        .subscribe(this::getTransactionDetails);

Un Complétées représente un différé de calcul avec pas de valeur, mais une indication pour l'achèvement ou de l'exception. La méthode statique appel timer() renvoie un Completable que des signaux de la fin après la période de temps spécifiée est écoulée, et l' subscribe() appel signifie que la méthode de getTransactionDetails() sera appelée sur l'objet courant lorsque la minuterie se déclenche. En fournissant un Scheduler comme le dernier argument Completable.timer() vous contrôlez le thread qui est utilisé pour exécuter getTransactionDetails().

Answer 2

doOnNext() est pour les effets secondaires. Il pourrait être utilisé par exemple pour l'enregistrement de but, car l'enregistrement n'a pas d'altérer le flux de données. Mais vous voulez transmettre le résultat de l' getTransactionDetails(), de sorte que vous devez utiliser une carte à la place.

Deuxièmement, Observable.empty() créer un Observable qui vient de propager la finition/débarrasser message, il déclenche ni doOnNext() ni map(). Vous pouvez résoudre ce problème en utilisant Observable.just() à la place, mais un plus idiomatiques moyen serait d'utiliser Observable.timer():

Observable.timer(5000, TimeUnit.MILLISECONDS)
        .map(o -> getTransactionDetails())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe( ... );

Une dernière remarque sur les Planificateurs. Observable.timer() et delay() sont exécutés sur le calcul ordonnanceur par défaut de sorte que vous n'avez pas besoin d'appeler .subscribeOn(Schedulers.io()) d'exécuter getTransactionDetails() à l'extérieur du thread principal. Observable.timer() et delay() pourrait prendre un Scheduler comme paramètre si vous voulez contrôler cela. Si vous avez besoin d'appeler .observeOn(AndroidSchedulers.mainThread()) si vous souhaitez utiliser getTransactionDetails() résultat sur le thread de l'INTERFACE utilisateur. Chaque opérateur après l' observeOn() est exécutée sur l'définis Scheduler, de sorte que vous avez à mettre observeOn() après le calcul.

Edit: C'est bien sûr, si vous vous souciez du résultat de l' getTransactionDetails(). Si non, voir Clyde réponse.

Answer 3

 Observable
     .timer( 5000, TimeUnit.MILLISECONDS )
     .subscribeOn(Schedulers.io())
     .map(o -> getTransactionDetails() )
     .subscribe();
 

vous n'avez pas besoin d'observer car abonnez-vous vide. utiliser la minuterie, ce sera une manière plus correcte

Answer 4

Cela ne fonctionne pas, car delay() besoin que quelque chose soit émis, mais empty() n'émet en fait rien.

À la place, vous devez utiliser Observable.timer() .

Answer 5

Essaye ça

 Observable.just(true).delay(5000, TimeUnit.MILLISECONDS)
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .map(o -> getTransactionDetails())
    .subscribe();