web-dev-qa-db-ja.com

Observable.intervalのティックの放出を停止および再開する方法

これは、5秒ごとにティックを放出します。

Observable.interval(5, TimeUnit.SECONDS, Schedulers.io())
            .subscribe(tick -> Log.d(TAG, "tick = "+tick));

それを停止するには、使用することができます

Schedulers.shutdown();

しかし、その後、すべてのスケジューラが停止し、後でティックを再開することはできません。放出を「優雅に」停止および再開するにはどうすればよいですか？

javarx-javarx-android
32
Jan Seevers

考えられる解決策の1つを次に示します。

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();
        }
    }
}
34
AndroidEx

しばらく前に、RXの「タイマー」ソリューションの種類も探していましたが、それらのどれもが私の期待を満たしていませんでした。そこで、あなたは私自身の解決策を見つけることができます：

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);
}
15
Artur Szymański
val switch = new Java.util.concurrent.atomic.AtomicBoolean(true)
val tick = new Java.util.concurrent.atomic.AtomicLong(0L)

val suspendableObservable = 
  Observable.
    interval(5 seconds).
    takeWhile(_ => switch.get()).
    repeat.
    map(_ => tick.incrementAndGet())

switchをfalseに設定してティックを一時停止し、trueを設定して再開できます。

9
Sheng

これを行う別の方法があります。
ソースコードを確認すると、interval（） using class OnSubscribeTimerPeriodicallyが見つかります。以下のキーコード。

@Override
public void call(final Subscriber<? super Long> child) {
    final Worker worker = scheduler.createWorker();
    child.add(worker);
    worker.schedulePeriodically(new Action0() {
        long counter;
        @Override
        public void call() {
            try {
                child.onNext(counter++);
            } catch (Throwable e) {
                try {
                    worker.unsubscribe();
                } finally {
                    Exceptions.throwOrReport(e, child);
                }
            }
        }

    }, initialDelay, period, unit);
}

そのため、ループをカネリングしたい場合は、onNext（）で新しい例外をスローするのはどうでしょうか。以下のコード例。

Observable.interval(1000, TimeUnit.MILLISECONDS)
            .subscribe(new Action1<Long>() {
                @Override
                public void call(Long aLong) {
                    Log.i("abc", "onNext");
                    if (aLong == 5) throw new NullPointerException();
                }
            }, new Action1<Throwable>() {
                @Override
                public void call(Throwable throwable) {
                    Log.i("abc", "onError");
                }
            }, new Action0() {
                @Override
                public void call() {
                    Log.i("abc", "onCompleted");
                }
            });

次に、これが表示されます：

08-08 11:10:46.008 28146-28181/net.bingyan.test I/abc: onNext
08-08 11:10:47.008 28146-28181/net.bingyan.test I/abc: onNext
08-08 11:10:48.008 28146-28181/net.bingyan.test I/abc: onNext
08-08 11:10:49.008 28146-28181/net.bingyan.test I/abc: onNext
08-08 11:10:50.008 28146-28181/net.bingyan.test I/abc: onNext
08-08 11:10:51.008 28146-28181/net.bingyan.test I/abc: onNext
08-08 11:10:51.018 28146-28181/net.bingyan.test I/abc: onError
2
Chris Wong

申し訳ありませんが、これはRxJavaではなくRxJSにありますが、概念は同じです。私はこれを learn-rxjs.io から適合させ、ここでは codepen にあります。

アイデアは、クリックイベントの2つのストリーム、startClick$とstopClick$から始めることです。 stopClick$ストリームで発生する各クリックは、空のオブザーバブルにマップされ、startClick$をクリックすると、それぞれinterval$ストリームにマップされます。結果の2つのストリームは、merge- dを1つのobservable-of-observablesにまとめます。つまり、クリックが発生するたびに、2つのタイプのいずれかの新しいオブザーバブルがmergeから放出されます。結果のオブザーバブルはswitchMapを通過し、この新しいオブザーバブルのリッスンを開始し、以前にリッスンしていたもののリッスンを停止します。 Switchmapは、この新しいオブザーバブルの値を既存のストリームにマージし始めます。

切り替え後、scanはinterval$によって発行された「増分」値のみを参照し、「停止」がクリックされたときに値を参照しません。

そして、最初のクリックが発生するまで、startWithは$intervalから値を出力し始めます。

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));

そして、これがHTML

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

TakeWhileを使用して、条件が真になるまでループすることができます

Observable.interval(1, TimeUnit.SECONDS)
        .takeWhile {
            Log.i(TAG, " time " + it)
            it != 30L
        }
        .subscribe(object : Observer<Long> {
            override fun onComplete() {
                Log.i(TAG, "onComplete " + format.format(System.currentTimeMillis()))
            }

            override fun onSubscribe(d: Disposable) {
                Log.i(TAG, "onSubscribe " + format.format(System.currentTimeMillis()))
            }

            override fun onNext(t: Long) {
                Log.i(TAG, "onNext " + format.format(System.currentTimeMillis()))
            }

            override fun onError(e: Throwable) {
                Log.i(TAG, "onError")
                e.printStackTrace()
            }

        });
0
Alier