倒计时工具类

package com.example.testdemo.utils;

import android.os.CountDownTimer;

/*
 * ================================================
 * 描述：倒计时工具类
 * 作者：zhuangzeqin
 * 时间: 2023/8/25 11:27
 * 邮箱：zzq@eeepay.cn
 * 备注:
 * ----------------------------------------------------------------
 * You never know what you can do until you try !
 *      _              _           _     _   ____  _             _ _
 *     / \   _ __   __| |_ __ ___ (_) __| | / ___|| |_ _   _  __| (_) ___
 *    / _ \ | '_ \ / _` | '__/ _ | |/ _` | ___ | __| | | |/ _` | |/ _ \
 *   / ___ | | | | (_| | | | (_) | | (_| |  ___) | |_| |_| | (_| | | (_) |
 *  /_/   __| |_|__,_|_|  ___/|_|__,_| |____/ __|__,_|__,_|_|___/
 *
 * 签名：最痛苦的事不是我失败了，而是我本可以.--zzq
 * ----------------------------------------------------------------
 *     //定时器，时间单位毫秒
        CountDownTimerUtils.getCountDownTimer()
                .setMillisInFuture(60 * 1000)//总时长
                .setCountDownInterval(1000)//定期回调时间
                .setTickDelegate(new CountDownTimerUtils.TickDelegate() {
        @Override
        public void onTick(long pMillisUntilFinished) {
        Log.i("剩余 "+(pMillisUntilFinished / 1000)+"s");

        }
    })
            .setFinishDelegate(new CountDownTimerUtils.FinishDelegate() {
        @Override
        public void onFinish() {//倒计时结束，也就是相当于定时器，用于延后处理的机制，如超时，延时关闭等等
            Log.i("倒计时结束");

        }
    }).start();

 * ================================================
 */
public class CountDownTimerUtils {
    /**
     * 倒计时结束的回调接口
     */
    public interface FinishDelegate {
        void onFinish();
    }

    /**
     * 定期回调的接口
     */
    public interface TickDelegate {
        void onTick(long pMillisUntilFinished);
    }

    private final static long ONE_SECOND = 1000;
    /**
     * 总倒计时时间
     */
    private long mMillisInFuture = 0;
    /**
     * 定期回调的时间 必须大于0 否则会出现ANR
     */
    private long mCountDownInterval;
    /**
     * 倒计时结束的回调
     */
    private FinishDelegate mFinishDelegate;
    /**
     * 定期回调
     */
    private TickDelegate mTickDelegate;
    private MyCountDownTimer mCountDownTimer;

    /**
     * 获取 CountDownTimerUtils
     *
     * @return CountDownTimerUtils
     */
    public static CountDownTimerUtils getCountDownTimer() {
        return new CountDownTimerUtils();
    }

    /**
     * 设置定期回调的时间 调用{@link #setTickDelegate(TickDelegate)}
     *
     * @param pCountDownInterval 定期回调的时间 必须大于0
     * @return CountDownTimerUtils
     */
    public CountDownTimerUtils setCountDownInterval(long pCountDownInterval) {
        this.mCountDownInterval = pCountDownInterval;
        return this;
    }

    /**
     * 设置倒计时结束的回调
     *
     * @param pFinishDelegate 倒计时结束的回调接口
     * @return CountDownTimerUtils
     */
    public CountDownTimerUtils setFinishDelegate(FinishDelegate pFinishDelegate) {
        this.mFinishDelegate = pFinishDelegate;
        return this;
    }

    /**
     * 设置总倒计时时间
     *
     * @param pMillisInFuture 总倒计时时间
     * @return CountDownTimerUtils
     */
    public CountDownTimerUtils setMillisInFuture(long pMillisInFuture) {
        this.mMillisInFuture = pMillisInFuture;
        return this;
    }

    /**
     * 设置定期回调
     *
     * @param pTickDelegate 定期回调接口
     * @return CountDownTimerUtils
     */
    public CountDownTimerUtils setTickDelegate(TickDelegate pTickDelegate) {
        this.mTickDelegate = pTickDelegate;
        return this;
    }

    public void create() {
        if (mCountDownTimer != null) {
            mCountDownTimer.cancel();
            mCountDownTimer = null;
        }
        if (mCountDownInterval <= 0) {
            mCountDownInterval = mMillisInFuture + ONE_SECOND;
        }
        mCountDownTimer = new MyCountDownTimer(mMillisInFuture, mCountDownInterval);
        mCountDownTimer.setTickDelegate(mTickDelegate);
        mCountDownTimer.setFinishDelegate(mFinishDelegate);
    }

    /**
     * 开始倒计时
     */
    public void start() {
        if (mCountDownTimer == null) {
            create();
        }
        mCountDownTimer.start();
    }

    /**
     * 取消倒计时
     */
    public void cancel() {
        if (mCountDownTimer != null) {
            mCountDownTimer.cancel();
        }
    }

    private static class MyCountDownTimer extends CountDownTimer {
        private FinishDelegate mFinishDelegate;
        private TickDelegate mTickDelegate;

        /**
         * @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) {
            super(millisInFuture, countDownInterval);
        }

        @Override
        public void onTick(long millisUntilFinished) {
            if (mTickDelegate != null) {
                mTickDelegate.onTick(millisUntilFinished);
            }
        }

        @Override
        public void onFinish() {
            if (mFinishDelegate != null) {
                mFinishDelegate.onFinish();
            }
        }

        void setFinishDelegate(FinishDelegate pFinishDelegate) {
            this.mFinishDelegate = pFinishDelegate;
        }

        void setTickDelegate(TickDelegate pTickDelegate) {
            this.mTickDelegate = pTickDelegate;
        }
    }
}