android countdowntimer tick is not accurate

Question

I am using a countdown timer for audio notification... and it's not accurate from the start...

using initial parameters

private final long startCountDown; 
private final long intervalCountDown;
    ...
    startCountDown = 180 * 1000;   // 3 mns  - to be set from Preferences later
intervalCountDown = 60 * 1000;   // 1 mns - to be set from Preferences later
    ...
    public void onTick(long millisUntilFinished) {
       Log.d(TAG, "notify countDown: " + millisUntilFinished + " msecs");
    }


    countDownTimer = new SwimCountDownTimer(startCountDown,intervalCountDown);
    ....

public void startCountDown() {
    Log.d(TAG, "start countDown for " + startCountDown + " msecs" );
    countDownTimer.start();
}

I can see in the log that the initial countdown is correctly set to 180000 but the next one should be 120000 and it's set to 119945 !!!

04-27 14:50:42.146: I/SWIMMER(8670): notify countDown: 180000 msecs
04-27 14:51:42.206: I/SWIMMER(8670): notify countDown: 119945 msecs

This is quite annoying as the audio notifier is expecting to say only '2 minutes" and not "1 minute and fifty nine seconds" ...; why the interval is not right ... ? I can tricj it in setting myself the text to speech string ... but is there any way to get correct data ?

thanks for suggestions

Is 55 milliseconds such a big problem? It's 1/20th of a second off. Most people would not be able to discern the difference. — indivisible, Apr 27 '14 at 13:23
If it's consistently slow by about 55 milliseconds, and never greater than 120000ms, then that's probably how long it takes to call on onTick method. Just round it up. — Greg, Apr 27 '14 at 15:16
thanks ... problem is not accuracy , but reusing the value for audio notification, so I guess rounding is the solution as Greg mentioned... 120000ms is "2 minutes" audio message... 119945 is not ... — , Apr 27 '14 at 20:40

score 18 · Accepted Answer · answered Sep 13 '15 at 20:14

I know it's an old question- but I've also encountered the problem, and thought I would share my solution.

Apperantly CountDownTimer isn't very accurate, so I've decided to implement a more percise countdown timer, using java.util.Timer:

public abstract class PreciseCountdown extends Timer {
    private long totalTime, interval, delay;
    private TimerTask task;
    private long startTime = -1;
    private boolean restart = false, wasCancelled = false, wasStarted = false;

    public PreciseCountdown(long totalTime, long interval) {
        this(totalTime, interval, 0);
    }

    public PreciseCountdown(long totalTime, long interval, long delay) {
        super("PreciseCountdown", true);
        this.delay = delay;
        this.interval = interval;
        this.totalTime = totalTime;
        this.task = getTask(totalTime);
    }

    public void start() {
        wasStarted = true;
        this.scheduleAtFixedRate(task, delay, interval);
    }

    public void restart() {
        if(!wasStarted) {
            start();
        }
        else if(wasCancelled) {
            wasCancelled = false;
            this.task = getTask(totalTime);
            start();
        }
        else{
            this.restart = true;
        }
    }

    public void stop() {
        this.wasCancelled = true;
        this.task.cancel();
    }

    // Call this when there's no further use for this timer
    public void dispose(){
        cancel();
        purge();
    }

    private TimerTask getTask(final long totalTime) {
        return new TimerTask() {

            @Override
            public void run() {
                long timeLeft;
                if (startTime < 0 || restart) {
                    startTime = scheduledExecutionTime();
                    timeLeft = totalTime;
                    restart = false;
                } else {
                    timeLeft = totalTime - (scheduledExecutionTime() - startTime);

                    if (timeLeft <= 0) {
                        this.cancel();
                        startTime = -1;
                        onFinished();
                        return;
                    }
                }

                onTick(timeLeft);
            }
        };
    }

    public abstract void onTick(long timeLeft);
    public abstract void onFinished();
}

Usage example would be:

this.countDown = new PreciseCountdown(totalTime, interval, delay) {
    @Override
    public void onTick(long timeLeft) {
        // update..
        // note that this runs on a different thread, so to update any GUI components you need to use Activity.runOnUiThread()
    }

    @Override
    public void onFinished() {
        onTick(0); // when the timer finishes onTick isn't called
        // count down is finished
    }
};

to start the countdown, simply call countDown.start(). countDown.stop() stops the countDown, which could be restarted using countDown.restart().

Hope this is any help for anyone in the future.

Man, you are amazing) You might be the reason I ll get my new job as I was doing a test assignment ))) — Sermilion, Aug 19 '16 at 17:49

score 0 · Answer 2 · answered May 22 '19 at 02:46

Instead of using millisUntilFinished, you can use a variable to hold the remaining time and in every onTick, minus the variable with the interval. In this way, remainingTime is always accurate.

private class MyTimer(
    countDownTime: Long, 
    interval: Long
) : CountDownTimer(countDownTime, interval) {

    private var remainingTime = countDownTime

    override fun onFinish() {
    }

    override fun onTick(millisUntilFinished: Long) {
        // consume remainingTime here and then minus interval
        remainingTime -= interval
    }
}

score 0 · Answer 3 · answered Feb 18 '21 at 10:53

This is an extension on what Noam Gal posted. I added extra functionality where you can pause and resume the timer. This was very helpful in my case.

public abstract class PreciseCountdownTimer extends Timer {

    private long totalTime, interval, delay;
    private TimerTask task;
    private long startTime = -1;
    private long timeLeft;
    private boolean restart = false;
    private boolean wasCancelled = false;
    private boolean wasStarted = false;

    public PreciseCountdownTimer(long totalTime, long interval) {
        this(totalTime, interval, 0);
    }


    public PreciseCountdownTimer(long totalTime, long interval, long delay ) {
        super("PreciseCountdownTimer", true);
        this.delay = delay;
        this.interval = interval;
        this.totalTime = totalTime;
        this.task = buildTask(totalTime);
    }

    private TimerTask buildTask(final long totalTime) {
        return new TimerTask() {

            @Override
            public void run() {
                if (startTime < 0 || restart) {
                    startTime = scheduledExecutionTime();
                    timeLeft = totalTime;
                    restart = false;
                } else {
                    timeLeft = totalTime - (scheduledExecutionTime() - startTime);

                    if (timeLeft <= 0) {
                        this.cancel();
                        wasCancelled = true;
                        startTime = -1;
                        onFinished();
                        return;
                    }
                }

                onTick(timeLeft);
            }
        };
    }

    public void start() {
        wasStarted = true;
        this.scheduleAtFixedRate(task, delay, interval);
    }

    public void stop() {
        this.wasCancelled = true;
        this.task.cancel();
    }

    public void restart() {
        if (!wasStarted) {
            start();
        } else if (wasCancelled) {
            wasCancelled = false;
            this.task = buildTask(totalTime);
            start();
        } else {
            this.restart = true;
        }
    }

    public void pause(){
        wasCancelled = true;
        this.task.cancel();
        onPaused();
    }

    public void resume(){
        wasCancelled = false;
        this.task = buildTask(timeLeft);
        this.startTime = - 1;
        start();
        onResumed();
    }

    // Call this when there's no further use for this timer
    public void dispose() {
        this.cancel();
        this.purge();
    }

    public abstract void onTick(long timeLeft);

    public abstract void onFinished();

    public abstract void onPaused();

    public abstract void onResumed();
}

Usage example would be almost exactly the same:

this.timer = new PreciseCountdownTimer(totalTime, interval, delay) {
            @Override
            public void onTick(long timeLeft) {
                // note that this runs on a different thread, so to update any GUI components you need to use Activity.runOnUiThread()
            }

            @Override
            public void onFinished() {
                onTick(0); // when the timer finishes onTick isn't called
                // count down is finished
            }

            @Override
            public void onPaused() {
                // runs after the timer has been paused
            }

            @Override
            public void onResumed() {
                // runs after the timer has been resumed
            }
        };

Enjoy and have fun :D

android countdowntimer tick is not accurate

3 Answers3