Android RX - Observables.compte à rebours seulement de tir une fois

Donc je suis en train de créer une observable qui se déclenche sur une base régulière, mais pour une raison que je ne peux pas comprendre, il ne se déclenche qu'une fois. N'importe qui peut voir ce que je fais de mal?

Observable<Long> observable = Observable.timer(delay, TimeUnit.SECONDS, Schedulers.io());

        subscription =  observable
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        searchByStockHelper.requestRemoteSearchByStock();
                    }
                });

actuellement de retard est réglé à 2

InformationsquelleAutor James King | 2015-09-11
  1. 50

    La documentation pour la minuterie de l'opérateur dit ceci:

    Créer une Observable qui émet un élément particulier après un délai

    Donc le comportement que vous observez est attendu- timer() émet juste un seul élément, après un retard.

    L'intervalle opérateur, d'autre part, émettent des éléments espacés avec un intervalle donné.

    Par exemple, ce Observables émet un élément à chaque seconde:

    Observable.interval(1, TimeUnit.SECONDS);
    • Hey, je viens de trouver ce en même temps. Merci beaucoup pour votre aide
    InformationsquelleAutor Tanis.7x
  2. 17

    Je sais que sujet est ancien mais peut-être pour les futurs visiteurs. (5 min de compte à rebours de la minuterie),

    Disposable timerDisposable = Observable.interval(1,TimeUnit.SECONDS, Schedulers.io())
        .take(300)
        .map(v -> 300 - v)
        .subscribe(
            onNext -> {
                //on every second pass trigger
            },
            onError -> {
                //do on error
            },
            () -> {
                //do on complete
            },
            onSubscribe -> {
                //do once on subscription
            });
    • Belle solution!
    InformationsquelleAutor Jack the Ripper
  3. 0

    J'ai mis en place comme ça dans mon code, veillez à ce que la tâche en cours est terminé avant de l'appeler à nouveau, et vous pouvez mettre à jour le retard.

     return Single.timer(5, TimeUnit.SECONDS).flatMap(
        new Function<Long, Single<Object>>() {
          @Override
          public Single<Object> apply(Long aLong) {
            //create single with task to be called repeatedly
            return Single.create();
          }
        })
        .retry(new Predicate<Throwable>() {
          @Override
          public boolean test(Throwable throwable) {
            boolean response = true;
            //implement your logic here and update response to false to stop 
              retry
            return response;
          }
        });
    InformationsquelleAutor 1'hafs