一、前言

原生的倒计时功能比较简单，没有暂停和重新开始计时功能，所以仿照原生的CountDownTimer做一个更好用的倒计时功能。

二、自定义类

  1. public class LCountDownTimer {
  3.     /**
  4.      * 时间，即开始的时间，通俗来说就是倒计时总时间
  5.      */
  6.     private long mMillisInFuture;
  7.     /**
  8.      * 布尔值，表示计时器是否被取消
  9.      * 只有调用cancel时才被设置为true
  10.      */
  11.     private boolean mCancelled = false;
  12.     /**
  13.      * 用户接收回调的时间间隔，一般是1秒
  14.      */
  15.     private long mCountdownInterval;
  16.     /**
  17.      * 记录暂停时候的时间
  18.      */
  19.     private long mStopTimeInFuture;
  20.     /**
  21.      * mas.what值
  22.      */
  23.     private static final int MSG = 520;
  24.     /**
  25.      * 暂停时，当时剩余时间
  26.      */
  27.     private long mCurrentMillisLeft;
  28.     /**
  29.      * 是否暂停
  30.      * 只有当调用pause时，才设置为true
  31.      */
  32.     private boolean mPause = false;
  33.     /**
  34.      * 监听listener
  35.      */
  36.     private TimerListener mCountDownListener;
  37.     /**
  38.      * 是否创建开始
  39.      */
  40.     private boolean isStart;
  42.     public LCountDownTimer(){
  43.         isStart = true;
  44.     }
  46.     public LCountDownTimer(long millisInFuture, long countdownInterval) {
  47.         long total = millisInFuture + 20;
  48.         this.mMillisInFuture = total;
  49.         //this.mMillisInFuture = millisInFuture;
  50.         this.mCountdownInterval = countdownInterval;
  51.         isStart = true;
  52.     }
  54.     /**
  55.      * 开始倒计时，每次点击，都会重新开始
  56.      */
  57.     public synchronized final void start() {
  58.         if (mMillisInFuture <= 0 && mCountdownInterval <= 0) {
  59.             throw new RuntimeException("you must set the millisInFuture > 0 or countdownInterval >0");
  60.         }
  61.         mCancelled = false;
  62.         long elapsedRealtime = SystemClock.elapsedRealtime();
  63.         mStopTimeInFuture = elapsedRealtime + mMillisInFuture;
  64.         mPause = false;
  65.         mHandler.sendMessage(mHandler.obtainMessage(MSG));
  66.         if (mCountDownListener!=null){
  67.             mCountDownListener.onStart();
  68.         }
  69.     }
  71.     /**
  72.      * 取消计时器
  73.      */
  74.     public synchronized final void cancel() {
  75.         if (mHandler != null) {
  76.             //暂停
  77.             mPause = false;
  78.             mHandler.removeMessages(MSG);
  79.             //取消
  80.             mCancelled = true;
  81.         }
  82.     }
  84.     /**
  85.      * 按一下暂停，再按一下继续倒计时
  86.      */
  87.     public synchronized final void pause() {
  88.         if (mHandler != null) {
  89.             if (mCancelled) {
  90.                 return;
  91.             }
  92.             if (mCurrentMillisLeft < mCountdownInterval) {
  93.                 return;
  94.             }
  95.             if (!mPause) {
  96.                 mHandler.removeMessages(MSG);
  97.                 mPause = true;
  98.             }
  99.         }
  100.     }
  102.     /**
  103.      * 恢复暂停，开始
  104.      */
  105.     public synchronized final  void resume() {
  106.         if (mMillisInFuture <= 0 && mCountdownInterval <= 0) {
  107.             throw new RuntimeException("you must set the millisInFuture > 0 or countdownInterval >0");
  108.         }
  109.         if (mCancelled) {
  110.             return;
  111.         }
  112.         //剩余时长少于
  113.         if (mCurrentMillisLeft < mCountdownInterval || !mPause) {
  114.             return;
  115.         }
  116.         mStopTimeInFuture = SystemClock.elapsedRealtime() + mCurrentMillisLeft;
  117.         mHandler.sendMessage(mHandler.obtainMessage(MSG));
  118.         mPause = false;
  119.     }
  122.     @SuppressLint("HandlerLeak")
  123.     private Handler mHandler = new Handler() {
  124.         @Override
  125.         public void handleMessage(@NonNull Message msg) {
  126.             synchronized (LCountDownTimer.this) {
  127.                 if (mCancelled) {
  128.                     return;
  129.                 }
  130.                 //剩余毫秒数
  131.                 final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();
  132.                 if (millisLeft <= 0) {
  133.                     mCurrentMillisLeft = 0;
  134.                     if (mCountDownListener != null) {
  135.                         mCountDownListener.onFinish();
  136.                     }
  137.                 } else if (millisLeft < mCountdownInterval) {
  138.                     mCurrentMillisLeft = 0;
  139.                     // 剩余时间小于一次时间间隔的时候，不再通知，只是延迟一下
  140.                     sendMessageDelayed(obtainMessage(MSG), millisLeft);
  141.                 } else {
  142.                     //有多余的时间
  143.                     long lastTickStart = SystemClock.elapsedRealtime();
  144.                     if (mCountDownListener != null) {
  145.                         mCountDownListener.onTick(millisLeft);
  146.                     }
  147.                     mCurrentMillisLeft = millisLeft;
  148.                     // 考虑用户的onTick需要花费时间,处理用户onTick执行的时间
  149.                     // 打印这个delay时间，大概是997毫秒
  150.                     long delay = lastTickStart + mCountdownInterval - SystemClock.elapsedRealtime();
  151.                     // 特殊情况：用户的onTick方法花费的时间比interval长，那么直接跳转到下一次interval
  152.                     // 注意，在onTick回调的方法中，不要做些耗时的操作
  153.                     boolean isWhile = false;
  154.                     while (delay < 0){
  155.                         delay += mCountdownInterval;
  156.                         isWhile = true;
  157.                     }
  158.                     if (isWhile){
  159.                     }
  160.                     sendMessageDelayed(obtainMessage(MSG), delay);
  161.                 }
  162.             }
  163.         }
  164.     };
  166.     /**
  167.      * 设置倒计时总时间
  168.      * @param millisInFuture                    毫秒值
  169.      */
  170.     public void setMillisInFuture(long millisInFuture) {
  171.         long total = millisInFuture + 20;
  172.         this.mMillisInFuture = total;
  173.     }
  175.     /**
  176.      * 设置倒计时间隔值
  177.      * @param countdownInterval                 间隔，一般设置为1000毫秒
  178.      */
  179.     public void setCountdownInterval(long countdownInterval) {
  180.         this.mCountdownInterval = countdownInterval;
  181.     }
  183.     /**
  184.      * 设置倒计时监听
  185.      * @param countDownListener                 listener
  186.      */
  187.     public void setCountDownListener(TimerListener countDownListener) {
  188.         this.mCountDownListener = countDownListener;
  189.     }
  191. }

最后的几个方法可以设置总时长，倒计时间隔，倒计时监听。

接口：

  1. public interface TimerListener {
  3.     /**
  4.      * 当倒计时开始
  5.      */
  6.     void onStart();
  8.     /**
  9.      * 当倒计时结束
  10.      */
  11.     void onFinish();
  13.     /**
  14.      * @param millisUntilFinished 剩余时间
  15.      */
  16.     void onTick(long millisUntilFinished);
  18. }

使用示例：

  1.    var mCountTime: LCountDownTimer? = null
  2.     override fun initInterface() {
  3.         //倒计时相关
  4.         mCountTime = LCountDownTimer(60*1000 + 100, 1000)
  6.         btn_click_all_start.setOnClickListener {
  7.             mCountTime?.start()
  8.         }
  10.         btn_click_all_restart.setOnClickListener {
  11.             mCountTime?.resume()
  12.         }
  14.         btn_click_all_pause.setOnClickListener {
  15.             mCountTime?.pause()
  16.         }
  17.         btn_click_all_stop.setOnClickListener {
  18.             mCountTime?.cancel()
  19.         }
  21.         mCountTime?.setCountDownListener(object : TimerListener{
  22.             override fun onFinish() {
  23.                 LogUtils.e("onFinish")
  24.             }
  26.             override fun onTick(millisUntilFinished: Long) {
  27.                 tv_click_all_num.text = "${millisUntilFinished / 1000}, 倒计时"
  28.                 LogUtils.e("onTick--${millisUntilFinished/1000}")
  29.             }
  31.             override fun onStart() {
  32.                 LogUtils.e("onStart")
  33.             }
  35.         })
  36.     }
  38.     override fun onDestroy() {
  39.         super.onDestroy()
  40.         mCountTime?.run {
  41.             cancel()
  42.         }
  43.         mCountTime = null
  44.     }

参考

Android 倒计时的五种实现方式