前言

原生的倒计时功能比较简单，没有暂停和重新开始计时功能，所以仿照原生的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.     private 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.             if (mCountDownListener!=null){
  82.                 mCountDownListener.onCancel();
  83.             }
  84.         }
  85.     }
  87.     /**
  88.      * 按一下暂停，再按一下继续倒计时
  89.      */
  90.     public synchronized final void pause() {
  91.         if (mHandler != null) {
  92.             if (mCancelled) {
  93.                 return;
  94.             }
  95.             if (mCurrentMillisLeft < mCountdownInterval) {
  96.                 return;
  97.             }
  98.             if (!mPause) {
  99.                 mHandler.removeMessages(MSG);
  100.                 mPause = true;
  101.                 if (mCountDownListener!=null){
  102.                     mCountDownListener.onPause();
  103.                 }
  104.             }
  105.         }
  106.     }
  108.     /**
  109.      * 恢复暂停，开始
  110.      */
  111.     public synchronized final  void resume() {
  112.         if (mMillisInFuture <= 0 && mCountdownInterval <= 0) {
  113.             throw new RuntimeException("you must set the millisInFuture > 0 or countdownInterval >0");
  114.         }
  115.         if (mCancelled) {
  116.             return;
  117.         }
  118.         //剩余时长少于
  119.         if (mCurrentMillisLeft < mCountdownInterval || !mPause) {
  120.             return;
  121.         }
  122.         mStopTimeInFuture = SystemClock.elapsedRealtime() + mCurrentMillisLeft;
  123.         mHandler.sendMessage(mHandler.obtainMessage(MSG));
  124.         mPause = false;
  125.         if (mCountDownListener!=null){
  126.             mCountDownListener.onResume();
  127.         }
  128.     }
  131.     @SuppressLint("HandlerLeak")
  132.     private Handler mHandler = new Handler() {
  133.         @Override
  134.         public void handleMessage(@NonNull Message msg) {
  135.             synchronized (LCountDownTimer.this) {
  136.                 if (mCancelled) {
  137.                     return;
  138.                 }
  139.                 //剩余毫秒数
  140.                 final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();
  141.                 if (millisLeft <= 0) {
  142.                     mCurrentMillisLeft = 0;
  143.                     if (mCountDownListener != null) {
  144.                         mCountDownListener.onFinish();
  145.                     }
  146.                 } else if (millisLeft < mCountdownInterval) {
  147.                     mCurrentMillisLeft = 0;
  148.                     // 剩余时间小于一次时间间隔的时候，不再通知，只是延迟一下
  149.                     sendMessageDelayed(obtainMessage(MSG), millisLeft);
  150.                 } else {
  151.                     //有多余的时间
  152.                     long lastTickStart = SystemClock.elapsedRealtime();
  153.                     if (mCountDownListener != null) {
  154.                         mCountDownListener.onTick(millisLeft);
  155.                     }
  156.                     mCurrentMillisLeft = millisLeft;
  157.                     // 考虑用户的onTick需要花费时间,处理用户onTick执行的时间
  158.                     // 打印这个delay时间，大概是997毫秒
  159.                     long delay = lastTickStart + mCountdownInterval - SystemClock.elapsedRealtime();
  160.                     // 特殊情况：用户的onTick方法花费的时间比interval长，那么直接跳转到下一次interval
  161.                     // 注意，在onTick回调的方法中，不要做些耗时的操作
  162.                     boolean isWhile = false;
  163.                     while (delay < 0){
  164.                         delay += mCountdownInterval;
  165.                         isWhile = true;
  166.                     }
  167.                     if (isWhile){
  168.                     }
  169.                     sendMessageDelayed(obtainMessage(MSG), delay);
  170.                 }
  171.             }
  172.         }
  173.     };
  175.     /**
  176.      * 设置倒计时总时间
  177.      * @param millisInFuture                    毫秒值
  178.      */
  179.     public void setMillisInFuture(long millisInFuture) {
  180.         long total = millisInFuture + 20;
  181.         this.mMillisInFuture = total;
  182.     }
  184.     /**
  185.      * 设置倒计时间隔值
  186.      * @param countdownInterval                 间隔，一般设置为1000毫秒
  187.      */
  188.     public void setCountdownInterval(long countdownInterval) {
  189.         this.mCountdownInterval = countdownInterval;
  190.     }
  192.     /**
  193.      * 设置倒计时监听
  194.      * @param countDownListener                 listener
  195.      */
  196.     public void setCountDownListener(TimerListener countDownListener) {
  197.         this.mCountDownListener = countDownListener;
  198.     }
  200. }

用到的抽象类：

  1. public abstract class TimerListener {
  3.     /**
  4.      * 当倒计时开始
  5.      */
  6.    public void onStart(){
  8.    }
  10.     /**
  11.      * 当倒计时恢复暂停
  12.      */
  13.    public void onResume(){
  15.    }
  17.     /**
  18.      * 当倒计时暂停
  19.      */
  20.    public void onPause(){
  22.    }
  24.     /**
  25.      * 当倒计时结束
  26.      */
  27.     public void onFinish(){
  29.     }
  31.     /**
  32.      * 当倒计时取消
  33.      */
  34.     public void onCancel(){
  36.     }
  37.     /**倒计时进行中
  38.      * @param millisUntilFinished 剩余时间
  39.      */
  40.     public abstract void onTick(long millisUntilFinished);
  42. }

使用示例

  1. class CountDownActivity: AppCompatActivity(R.layout.activity_countdown) {
  2.     //初始化倒计时相关
  3.     private val mLTime by lazy {
  4.         LCountDownTimer(9*1000 + 100, 1000)
  5.     }
  6.     override fun onCreate(savedInstanceState: Bundle?) {
  7.         super.onCreate(savedInstanceState)
  9.         btnCountdownStart.setOnClickListener {
  10.             mLTime.start()
  11.         }
  12.         btnCountdownPause.setOnClickListener {
  13.             mLTime.pause()
  14.         }
  15.         btnCountdownResume.setOnClickListener {
  16.             mLTime.resume()
  17.         }
  18.         btnCountdownCancel.setOnClickListener {
  19.             mLTime.cancel()
  20.         }
  21.         btnCountdownStart2.setOnClickListener {
  22.             mLTime.start()
  23.         }
  25.         //时间的监听
  26.         mLTime.setCountDownListener(object :TimerListener(){
  27.             override fun onTick(millisUntilFinished: Long) {
  28.                 Log.e(TAG, "onTick: $millisUntilFinished");
  29.                 tvCountDownTime.text = "倒计时: ${millisUntilFinished/1000}"
  30.             }
  32.             override fun onStart() {
  33.                 super.onStart()
  34.                 Log.e(TAG, "onStart: ");
  35.             }
  37.             override fun onResume() {
  38.                 super.onResume()
  39.                 Log.e(TAG, "onResume: ");
  40.             }
  42.             override fun onPause() {
  43.                 super.onPause()
  44.                 Log.e(TAG, "onPause: ");
  45.             }
  47.             override fun onFinish() {
  48.                 super.onFinish()
  49.                 Log.e(TAG, "onFinish: ");
  50.                 tvCountDownTime.text = "倒计时结束"
  51.             }
  53.             override fun onCancel() {
  54.                 super.onCancel()
  55.                 Log.e(TAG, "onCancel: ");
  56.                 tvCountDownTime.text = "倒计时取消"
  57.             }
  58.         })
  59.     }
  61.     override fun onDestroy() {
  62.         super.onDestroy()
  63.         mLTime.cancel()
  64.     }
  65. }