Solution to Android CountDownTimer Skipping the Last Tick

Google's implementation of CountDownTimer in Android is a bit strange; it often skips the very last tick. I can see why they did it this way: they want to make sure that onFinish() function will be called with no delay in the case onTick() takes so much time. However, this implantation causes the last tick to skip pretty much.

Well, here is my modified version of CountDownTimer which will not skip the last tick, unless onTick() function takes too long, which it shouldn't. So, make sure that onTick() will return quickly first.

The code modification starts at line 114 below:

	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.example.unixnme.mycountdowntimerexample
	import android.os.Handler;
	import android.os.Message;
	import android.os.SystemClock;
	public abstract class MyCountDownTimer {
	/**
	* Millis since epoch when alarm should stop.
	*/
	private final long mMillisInFuture;
	/**
	* The interval in millis that the user receives callbacks
	*/
	private final long mCountdownInterval;
	private long mStopTimeInFuture;
	/**
	* boolean representing if the timer was cancelled
	*/
	private boolean mCancelled = false;
	/**
	* @param millisInFuture The number of millis in the future from the call
	* to {@link #start()} until the countdown is done and {@link #onFinish()}
	* is called.
	* @param countDownInterval The interval along the way to receive
	* {@link #onTick(long)} callbacks.
	*/
	public MyCountDownTimer(long millisInFuture, long countDownInterval) {
	mMillisInFuture = millisInFuture;
	mCountdownInterval = countDownInterval;
	}
	/**
	* Cancel the countdown.
	*/
	public synchronized final void cancel() {
	mCancelled = true;
	mHandler.removeMessages(MSG);
	}
	/**
	* Start the countdown.
	*/
	public synchronized final MyCountDownTimer start() {
	mCancelled = false;
	if (mMillisInFuture <= 0) {
	onFinish();
	return this;
	}
	mStopTimeInFuture = SystemClock.elapsedRealtime() + mMillisInFuture;
	mHandler.sendMessage(mHandler.obtainMessage(MSG));
	return this;
	}
	/**
	* Callback fired on regular interval.
	* @param millisUntilFinished The amount of time until finished.
	*/
	public abstract void onTick(long millisUntilFinished);
	/**
	* Callback fired when the time is up.
	*/
	public abstract void onFinish();
	private static final int MSG = 1;
	// handles counting down
	private Handler mHandler = new Handler() {
	@Override
	public void handleMessage(Message msg) {
	synchronized (MyCountDownTimer.this) {
	if (mCancelled) {
	return;
	}
	final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();
	if (millisLeft <= 0) {
	onFinish();
	} else {
	long lastTickStart = SystemClock.elapsedRealtime();
	onTick(millisLeft);
	// take into account user's onTick taking time to execute
	long lastTickDuration = SystemClock.elapsedRealtime() - lastTickStart;
	long delay;
	if (millisLeft - lastTickDuration <= 0) {
	delay = 0;
	} else {
	delay = mCountdownInterval - lastTickDuration;
	// special case: user's onTick took more than interval to
	// complete, skip to next interval
	while (delay < 0) delay += mCountdownInterval;
	}
	sendMessageDelayed(obtainMessage(MSG), delay);
	}
	}
	}
	};
	}

view raw MyCountDownTimer.java hosted with ❤ by GitHub

The original source code is taken from here.