/**
 * 计时工具类
 * @author boyko
 */
public class MyTimer {
    private  OnTimeEndListener mListener;
    private Handler timehandler= new Handler();
    /**
     * 是否在规定的时间内
     */
    private static boolean inTime = false;
    private static volatile MyTimer sInst = null;  // <<< 这里添加了 volatile
    /**
     * 执行间隔倒计时操作时,所要执行的次数
     */
    private int intervaTime = -1;
    /**
     * 执行间隔倒计时操作时,已操作的次数
     */
    private int implementNumber = 0;
    private int intervalMilliSecond;
    private OnIntervalTimeEndListener intervalTimeEndListener;

    public static MyTimer getInstance() {
        MyTimer inst = sInst;  // <<< 在这里创建临时变量
        if (inst == null) {
            synchronized (MyTimer.class) {
                inst = sInst;
                if (inst == null) {
                    inst = new MyTimer();
                    sInst = inst;
                }
            }
        }
        return inst;  // <<< 注意这里返回的是临时变量
    }
    Runnable myTimer= new Runnable(){
          @Override
          public void run() {
              inTime = false;
              if (mListener != null)
                 mListener.onTimeEnd();
         }
    };
    /**\
     * 间隔时间所用到的计时器
     */
    Runnable intervalTimer= new Runnable(){
          @Override
          public void run() {
              if (implementNumber < intervaTime){
                  implementNumber++;
                  if (intervalTimeEndListener != null)
                      intervalTimeEndListener.OnIntervalTimeEnd(implementNumber);
                  timehandler.postDelayed(intervalTimer, intervalMilliSecond);
              }
         }
    };
    /**
     * 倒计时结束之后,执行操作
     * @param milliSecond 倒计时毫秒值
     */
    public void doTimeEnd(int milliSecond,OnTimeEndListener mListener){
        this.mListener = mListener;
        timehandler.postDelayed(myTimer, milliSecond);
    }

    /**
     * 间隔规定时间执行规定次数的指定操作
     *
     * @param intervalMilliSecond 间隔毫秒值
     * @param intervaTime         执行次数
     */
    public void intervalTimeEnd(int intervalMilliSecond, int intervaTime,OnIntervalTimeEndListener intervalTimeEndListener) {
        this.intervalMilliSecond = intervalMilliSecond;
        this.intervalTimeEndListener = intervalTimeEndListener;
        this.intervaTime = intervaTime;
        implementNumber++;
        if (intervalTimeEndListener != null)
            intervalTimeEndListener.OnIntervalTimeEnd(implementNumber);
        timehandler.postDelayed(intervalTimer, intervalMilliSecond);
    }

    /**
     * 在所规定的时间内,只可操作一次
     * @param milliSecond 倒计时毫秒值
     * @param toa 提示信息
     */
    public boolean doOnceTime(int milliSecond,String toa) {
        if (inTime){
            return !inTime;
        }
        inTime = true;
        timehandler.postDelayed(myTimer, milliSecond);
        return inTime;
    }
    /**
     * 停止倒计时
     */
    public void cancel() {
        timehandler.removeCallbacks(myTimer);
    }
    /**
     * 以最后依次调取该方法的时间,为起始时间开始倒计时
     * @param milliSecond
     */
    public void doLastTimeEnd(int milliSecond,OnTimeEndListener mListener){
        this.mListener = mListener;
        cancel();
        timehandler.postDelayed(myTimer, milliSecond);
    }

    /**
     * 两次确认操作
     * @param milliSecond 在多少毫秒内,触摸有效
     * @param toa 所要提示的内容
     * @param context
     * @return [true]可以继续下面的操作   [false]不可继续进行
     */
    public boolean doInTime(int milliSecond, String toa, Context context){
        this.mListener = mListener;
        if (inTime){
            inTime = false;
            return true;
        }
        inTime = true;
        timehandler.postDelayed(myTimer, milliSecond);
        return false;
    }
    public interface OnTimeEndListener {
        void onTimeEnd();
    }
    public interface OnIntervalTimeEndListener {
        /**
         * @param implementNumber 已执行次数
         */
        void OnIntervalTimeEnd(int implementNumber);
    }
}