Wie Sie die Observable.interval-Emitting-Ticks stoppen und fortsetzen

Hier ist eine mögliche Lösung:

class TickHandler {

    private AtomicLong lastTick = new AtomicLong(0L);
    private Subscription subscription;

    void resume() {
        System.out.println("resumed");
        subscription = Observable.interval(5, TimeUnit.SECONDS, Schedulers.io())
                                 .map(tick -> lastTick.getAndIncrement())
                                 .subscribe(tick -> System.out.println("tick = " + tick));
    }

    void stop() {
        if (subscription != null && !subscription.isUnsubscribed()) {
            System.out.println("stopped");
            subscription.unsubscribe();
        }
    }
}

InformationsquelleAutor der Antwort AndroidEx

Einige Zeit her, ich war auch auf der Suche nach Art von RX "timer" - Lösungen, aber nicht von Ihnen erfüllt meine Erwartungen. Also, dort finden Sie meine eigene Lösung:

AtomicLong elapsedTime = new AtomicLong();
AtomicBoolean resumed = new AtomicBoolean();
AtomicBoolean stopped = new AtomicBoolean();

public Flowable<Long> startTimer() { //Create and starts timper
    resumed.set(true);
    stopped.set(false);
    return Flowable.interval(1, TimeUnit.SECONDS)
            .takeWhile(tick -> !stopped.get())
            .filter(tick -> resumed.get())
            .map(tick -> elapsedTime.addAndGet(1000));
}

public void pauseTimer() {
    resumed.set(false);
}

public void resumeTimer() {
    resumed.set(true);
}

public void stopTimer() {
    stopped.set(true);
}

public void addToTimer(int seconds) {
    elapsedTime.addAndGet(seconds * 1000);
}

InformationsquelleAutor der Antwort Artur Szymański

Sorry das ist in RxJS statt RxJava, aber das Konzept wird das gleiche sein. Ich angepasst, das von lernen-rxjs.io und hier ist es auf codepen.

Die Idee ist, dass Sie beginnen mit zwei streams klicken Sie auf Ereignisse, startClick$ und stopClick$. Jeder Klick erfolgt auf der stopClick$ stream bekommen zugeordnet, um eine leere zu beobachten, und klickt auf startClick$ jeweils zugeordnet interval$ stream. Die beiden resultierenden streams bekommen merge-d zusammen in einer observable-der-observablen. In anderen Worten, eine neue beobachtbare einer der beiden Typen, die emittiert werden von merge jedes mal gibt es ein klicken. Die daraus resultierenden messbaren gehen durch switchMap beginnt das hören dieser neuen beobachtbare und Haltestellen zu hören, was er hörte, bevor. Switchmap startet auch das Zusammenführen der Werte aus dieser neuen beobachtbar auf den vorhandenen stream.

Nach dem Wechsel scan immer nur sieht die "increment" - Wert emittiert interval$und er sieht keine Werte, wenn "stop" geklickt wurde.

Bis der erste auf tritt, startWith beginnen emittierende Werte von $intervalnur um die Dinge in Gang:

const start = 0;
const increment = 1;
const delay = 1000;
const stopButton = document.getElementById('stop');
const startButton = document.getElementById('start');
const startClick$ = Rx.Observable.fromEvent(startButton, 'click');
const stopClick$ = Rx.Observable.fromEvent(stopButton, 'click');
const interval$ = Rx.Observable.interval(delay).mapTo(increment);
const setCounter = newValue => document.getElementById("counter").innerHTML = newValue;
setCounter(start);

const timer$ = Rx.Observable

    //a "stop" click will emit an empty observable,
    //and a "start" click will emit the interval$ observable.  
    //These two streams are merged into one observable.
    .merge(stopClick$.mapTo(Rx.Observable.empty()), 
           startClick$.mapTo(interval$))

    //until the first click occurs, merge will emit nothing, so 
    //use the interval$ to start the counter in the meantime
    .startWith(interval$)

    //whenever a new observable starts, stop listening to the previous
    //one and start emitting values from the new one
    .switchMap(val => val)

    //add the increment emitted by the interval$ stream to the accumulator
    .scan((acc, curr) => curr + acc, start)

    //start the observable and send results to the DIV
    .subscribe((x) => setCounter(x));

Und hier ist der HTML -

<html>
<body>
  <div id="counter"></div>
  <button id="start">
    Start
  </button>
  <button id="stop">
    Stop
  </button>
</body>
</html>

InformationsquelleAutor der Antwort mikebridge