TimeButton

公司项目里面需要用到倒计时按钮，自己本来用 Handler + Runnable ,总感觉很麻烦，后来了解到API里提供了倒计时的功能（CountDownTimer）， 在后面贴上了。 先看一下我们实现的带有倒计时功能的按钮： 很简单，就是调用了CountDownTimer。

package com.helper.view;import android.content.Context;import android.graphics.Color;import android.os.CountDownTimer;import android.os.Handler;import android.os.Message;import android.util.AttributeSet;import android.widget.Button;/** * Created by deadline on 2015/8/28. * 带有倒计时的功能的按钮 */public class TimeButton extends Button {    private static final int DEFAULT_COUNTDOWN = 60;    private int countDown;    private int beforeColor;    private int afterColor;    private CountDownTimer timer;    public TimeButton(Context context) {        this(context, null);    }    public TimeButton(Context context, AttributeSet attrs) {        this(context, attrs, 0);    }    public TimeButton(final Context context, AttributeSet attrs, int defStyleAttr) {        super(context, attrs, defStyleAttr);        beforeColor = Color.DKGRAY;        afterColor = Color.parseColor("#0085cf");        countDown = DEFAULT_COUNTDOWN;        setTextColor(beforeColor);        setText("获取验证码");        timer = new CountDownTimer(countDown * 1000, 1000) {            @Override            public void onTick(long millisUntilFinished) {  //剩下的时间以毫秒为单位                setText(String.valueOf(millisUntilFinished / 1000) + "s后可重新获取");            }            @Override            public void onFinish() {                setEnabled(true);                setTextColor(afterColor);                setText("重新获取验证码");            }        };    }    /**     * 开始倒计时     * 0秒看不到，直接转为可点击状态即可     */    public void startCountdown()    {        setTextColor(beforeColor);        setEnabled(false);   //设置不可点击        timer.start();    }    public void stop(){        timer.cancel();    }    public int getCountDown() {        return countDown;    }    public void setCountDown(int countDown) {        this.countDown = countDown;    }    public int getAfterColor() {        return afterColor;    }    public void setAfterColor(int afterColor) {        this.afterColor = afterColor;    }    public int getBeforeColor() {        return beforeColor;    }    public void setBeforeColor(int beforeColor) {        this.beforeColor = beforeColor;    }}

package android.os;/** * Schedule a countdown until a time in the future, with * regular notifications on intervals along the way. * * Example of showing a 30 second countdown in a text field: * * <pre class="prettyprint"> * new CountDownTimer(30000, 1000) { * *     public void onTick(long millisUntilFinished) { *         mTextField.setText("seconds remaining: " + millisUntilFinished / 1000); *     } * *     public void onFinish() { *         mTextField.setText("done!"); *     } *  }.start(); * </pre> * * The calls to {@link #onTick(long)} are synchronized to this object so that * one call to {@link #onTick(long)} won't ever occur before the previous * callback is complete.  This is only relevant when the implementation of * {@link #onTick(long)} takes an amount of time to execute that is significant * compared to the countdown interval. */public abstract class CountDownTimer {    /**     * 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 CountDownTimer(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 CountDownTimer 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 (CountDownTimer.this) {                if (mCancelled) {                    return;                }                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;                    sendMessageDelayed(obtainMessage(MSG), delay);                }            }        }    };}