倒计时

import android.graphics.Point;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;


public class CountDownTimer
{
public final static int STOP_MINUTE = 1;// STOP_MINUTE分钟无操作就停止计时
public final static long MINTUE2SECOND = 60 * 1000;// 150000000000000分钟转换成毫秒


private static long LASTMILLISINFUTURE;// 利用静态值保存结束时间
private final long mMillisInFuture;// 总时间长度
private final long mCountdownInterval;// onTick执行事件间隔
private long mStopTimeInFuture;// 结束时间点
private boolean mCancelled = false;// 是否取消计时
public int stopMsg = 909;// 暂停发送的消息


private boolean isCountDown;// 是否是倒计时-->考场倒计时；练习正计时，5分钟无操作不计入统计
private long promptOne = 0;// 第一次提醒
private long promptTwo = 0;// 第二次提醒
private long totalTime;


private OnTimeChangeListener onTimeChangeListener;


/**
* 构造方法
* 原本是倒计时的
* 通过更改onTick可以正计时
* 
* @param millisInFuture 计时的总时间长度
* @param countDownInterval 时间间隔，多久刷新一次onTick
* @param value 正计时倒计时的标志，0是正计时，1是倒计时
* @param point 倒计时时设置的提醒点，允许设置两个点，只有在倒计时时有此功能
*/
public CountDownTimer(long millisInFuture, long countDownInterval, int value,
Point point)
{
mMillisInFuture = millisInFuture * MINTUE2SECOND;
mCountdownInterval = countDownInterval;
LASTMILLISINFUTURE = millisInFuture;


this.isCountDown = value == 0 ? false : true;
this.totalTime = millisInFuture * MINTUE2SECOND;


if (isCountDown && point != null)
{
promptOne = point.x * MINTUE2SECOND;
promptTwo = point.y * MINTUE2SECOND;
}
}


/**
* 取消计时
* 不保存剩余时间
*/
public final void cancel()
{
mHandler.removeMessages(MSG);
mCancelled = true;
}


/**
* 暂停计时
* 保存剩余时间
*/
public void stop()
{
mHandler.removeMessages(MSG);
mCancelled = true;


LASTMILLISINFUTURE = mStopTimeInFuture - SystemClock.elapsedRealtime();
}


/**
* 再次计时，紧接着上次的计时
*/
public void restart()
{
if (LASTMILLISINFUTURE <= 0)
{
onFinish();
return;
}
mStopTimeInFuture = SystemClock.elapsedRealtime() + LASTMILLISINFUTURE;
mHandler.sendMessage(mHandler.obtainMessage(MSG));
mCancelled = false;
return;
}


/**
* 有操作时调用此方法，STOP_MINUTE后没有调用此方法就要停止计时了
*/
public void count()
{
if (!isCountDown)
{// 倒计时才响应
return;
}
if (this.mCancelled)
{
restart();
}
handler.removeMessages(stopMsg);
handler.sendEmptyMessageDelayed(stopMsg, STOP_MINUTE * MINTUE2SECOND);
}


Handler handler = new Handler()
{
@Override
public void handleMessage(Message msg)
{
super.handleMessage(msg);
if (msg.what == stopMsg)
{
stop();
handler.removeMessages(stopMsg);
}
}
};


/**
* 开始计时
*/
public synchronized final CountDownTimer start()
{
if (mMillisInFuture <= 0)
{
onFinish();
return this;
}
mStopTimeInFuture = SystemClock.elapsedRealtime() + mMillisInFuture;
mHandler.sendMessage(mHandler.obtainMessage(MSG));
mCancelled = false;
if (isCountDown)
{
handler.sendEmptyMessageDelayed(stopMsg, STOP_MINUTE * MINTUE2SECOND);
}
return this;
}


/**
* 每隔countDownInterval时间执行一次
* 
* @param millisUntilFinished 剩余时间
*/
public void onTick(long millisUntilFinished)
{
if (isCountDown)
{// 倒计时
if (millisUntilFinished > promptOne
&& millisUntilFinished < (promptOne + 1000))
{// 第一次提醒
countDownTimePrompt(0);
} else if (millisUntilFinished > promptTwo
&& millisUntilFinished < (promptTwo + 1000))
{// 第二次提醒
countDownTimePrompt(1);
}
refreshTime(millisUntilFinished);
} else
{// 正计时
refreshTime(this.totalTime - millisUntilFinished);
}
};


/**
* 计时结束
*/
public void onFinish()
{
if (isCountDown)
{// 倒计时结束时
timeOver();
}
};


private static final int MSG = 1;


// handles counting down
private Handler mHandler = new Handler()
{


@Override
public void handleMessage(Message msg)
{


synchronized (CountDownTimer.this)
{
final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();


if (millisLeft <= 0)
{
onFinish();
} else if (millisLeft < mCountdownInterval)
{
// no tick, just delay until done
sendMessageDelayed(obtainMessage(MSG), millisLeft);
} else
{
long lastTickStart = SystemClock.elapsedRealtime();
onTick(millisLeft);


// take into account user's onTick taking time to execute
long delay = lastTickStart + mCountdownInterval
- SystemClock.elapsedRealtime();


// special case: user's onTick took more than interval to
// complete, skip to next interval
while (delay < 0)
delay += mCountdownInterval;


if (!mCancelled)
{
sendMessageDelayed(obtainMessage(MSG), delay);
}
}
}
}
};


/**
* 刷新时间
*/
private void refreshTime(long time)
{
if (onTimeChangeListener != null)
{
long min = time / MINTUE2SECOND;
long second = (time % MINTUE2SECOND) / 1000;
onTimeChangeListener.showNewTime(min, second);
}
}


/**
* 倒计时提醒
*/
private void countDownTimePrompt(int times)
{
if (onTimeChangeListener != null)
{
onTimeChangeListener.countDownTimePrompt(times);
}
}


/**
* 时间到
*/
private void timeOver()
{
if (onTimeChangeListener != null)
{
onTimeChangeListener.timeOver();
}
}


public void setOnTimeChangeListener(OnTimeChangeListener onTimeChangeListener)
{
this.onTimeChangeListener = onTimeChangeListener;
}


/**
* 时间变化的监听
*/
public interface OnTimeChangeListener
{
public void showNewTime(long min, long second);


public void countDownTimePrompt(int times);


public void timeOver();
}


/**
* 手指按下的监听
*/
public interface OnFingerDownListener
{
public void onFingerDown();
}
}