RxJava自定义倒数计时器在处置后继续“滴答”

Question

I made a simple timer class using RxJava Observables:

public abstract class CountDownTimer {

    private final TimeUnit timeUnit;  
    private final Long startValue; 
    private Disposable disposable;

    public CountDownTimer(Long startValue, TimeUnit timeUnit) {
        this.timeUnit = timeUnit;
        this.startValue = startValue;
    }

    public abstract void onTick(long tickValue);

    public abstract void onFinish();

    public void start(){
        Observable.zip(
                        Observable.range(0, startValue.intValue()), 
                        Observable.interval(1, timeUnit),  
                        (integer, aLong) -> startValue - integer)   
                .subscribeOn(Schedulers.computation())  
                .observeOn(AndroidSchedulers.mainThread())  
                .subscribe(new Observer<Long>() {   
                    @Override
                    public void onSubscribe(Disposable d) {
                        disposable = d;
                    }

                    @Override
                    public void onNext(Long aLong) {
                        onTick(aLong);
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onComplete() {
                        onFinish();
                    }
                });
    }

    public void cancel(){
        if(disposable!=null) {
            disposable.dispose();
        }
    }
}

I use this class to set progress on a ProgressBar (initiation from a method in Fragment ):

timer = new CountDownTimer(QUESTION_TIME, TimeUnit.SECONDS) {
        @Override
        public void onTick(long tickValue) {
            //set progress color
        }

        @Override
        public void onFinish() {
            //set progress color
        }
    };
    timer.start();

When onFinish() tick from timer, onDestroyView from fragment, and other places in my fragment code, I call this:

if(timer != null){
        timer.cancel();
    }

And I can see from logging that cancel() is called and it is disposed of. However, even when resetting timer (I have a class variable Countdowntimer timer) like I showns in my second code example, I can see that the old timer is still active and updates the progressbar (both the old, and new timer updates the progressbar, so progress jumps between these 2 values).

I don't understand this, why is the timer not completly disposed of? Why does the "old timer" still continue to update the values?

EDIT:

This is how the timer class behaves in a fragment:

TICK 25    //first call to create new timer
TICK 24
TICK 23
TICK 22
TICK 21
TIMER CANCELLED    //first call stopped. timer.cancel() called (which then calls disposable.dispose() in CountDownTimer.class)
TICK 25    //second call
TICK 25    // somehow the first call also start again? 
TICK 24
TICK 24
TICK 23
TICK 23
TICK 22
TICK 22
TIMER CANCELLED    //cancel second call
TICK 21    //first or second call still continues
TICK 20
TICK 19
TICK 18

And it will continue to "stack on" more timers (which I called dispose() on)...

Answer 1

I'm not sure why you do this in this way, but there is an operator intervalRange that gets you this in fewer steps. Also managing the disposable could be a problem if you are reusing the same Countdowntimer . Try this:

class CountdownTimer {
    SerialDisposable disposable = new SerialDisposable();

    //...

    public void start() {
         disposable.set(
             Observable.intervalRange(0, startValue, 
                 1, timeUnit, AndroidSchedulers.mainThread())
             .subscribe(
                 tick -> onTick(startValue - tick)
                 error -> error.printStackTrace()
                 () -> onFinish()
             )
         );
    }

    public void cancel() {
         disposable.set(null);
    }
}

Answer 2

Try to clear the instance through GC too. add the following to all the places where you are calling timer.cancel() . Setting it to null will notify the GC that the timer instance is ready to be cleared.

if(timer != null) {
   timer.cancel();
   timer= null;
}