Android 带暂停和恢复的倒计时计时器

我想暂停并重新启动倒计时。现在我通过实现ontick（）和onfinish（）来显示倒计时。请帮助我。这是倒计时的代码

final CountDownTimer Counter1 = new CountDownTimer(timervalue1 , 1000)

     {
 public void onTick(long millisUntilFinished)

  {
            System.out.println("onTick method!"(String.valueOf(millisUntilFinished/1000)));long s1=millisUntilFinished;
  }

public void onFinish() 

{
            System.out.println("Finished!");
}

}

---

在onTick方法中..保存剩余的毫秒数

   long s1=millisUntilFinished;

如果要暂停计时器，请使用

   Counter.cancel();

当您要继续时，请创建一个新的倒数计时器，剩余毫秒

 timervalue=s1
  counter= new Counter1();
   counter.start();

---

我会在

onTick

处理程序中添加一些内容，以保存类中计时器的进度（剩余毫秒数）

在计时器上的活动调用

cancel（）

的

onPause（）

方法中

在活动的

onResume（）

方法中，使用保存的剩余毫秒数创建一个新计时器

请参阅以下链接

---

恐怕无法暂停或停止

倒计时

，而在onTick中暂停或停止对用户

计时器任务

没有任何影响

设置

TimerTask

class UpdateTimeTask extends TimerTask {
   public void run() {
       long millis = System.currentTimeMillis() - startTime;
       int seconds = (int) (millis / 1000);
       int minutes = seconds / 60;
       seconds     = seconds % 60;

       timeLabel.setText(String.format("%d:%02d", minutes, seconds));
   }

}
if(startTime == 0L) {
   startTime = evt.getWhen();
   timer = new Timer();
   timer.schedule(new UpdateTimeTask(), 100, 200);
}

您可以像这样添加事件侦听器

private Handler mHandler = new Handler();

...

OnClickListener mStartListener = new OnClickListener() {
   public void onClick(View v) {
       if (mStartTime == 0L) {
            mStartTime = System.currentTimeMillis();
            mHandler.removeCallbacks(mUpdateTimeTask);
            mHandler.postDelayed(mUpdateTimeTask, 100);
       }
   }
};

OnClickListener mStopListener = new OnClickListener() {
   public void onClick(View v) {
       mHandler.removeCallbacks(mUpdateTimeTask);
   }
};

---

有关更多信息，请参阅。

在本例中，我使用了两个专用变量：

private long startPauseTime;
private long pauseTime = 0L;

public void pause() { 
    startPauseTime = System.currentTimeMillis(); 
}

public void resumen(){ 
    pauseTime +=  System.currentTimeMillis() - startPauseTime; 
}

---

为倒计时器创建暂停/恢复的一个简单方法是为计时器的启动、暂停和恢复创建一个单独的方法，如下所示：

public void timerStart(long timeLengthMilli) {
        timer = new CountDownTimer(timeLengthMilli, 1000) {

            @Override
            public void onTick(long milliTillFinish) {
                milliLeft=milliTillFinish;
                min = (milliTillFinish/(1000*60));
                sec = ((milliTillFinish/1000)-min*60);
                clock.setText(Long.toString(min)+":"+Long.toString(sec));
                Log.i("Tick", "Tock");
            }

timerStart有一个长参数，因为下面的resume（）方法将重用它。请记住将您的MillTillFinished（以上为milliLeft）存储起来，以便您可以在resume（）方法中发送它。暂停和恢复方法分别如下：

public void timerPause() {
        timer.cancel();
    }

    private void timerResume() {
        Log.i("min", Long.toString(min));
        Log.i("Sec", Long.toString(sec));
        timerStart(milliLeft);
    }

以下是按钮的代码供参考：

startPause.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if(startPause.getText().equals("Start")){
                    Log.i("Started", startPause.getText().toString());
                    startPause.setText("Pause");
                    timerStart(15*1000);
                } else if (startPause.getText().equals("Pause")){
                    Log.i("Paused", startPause.getText().toString());
                    startPause.setText("Resume");
                    timerPause();
                } else if (startPause.getText().equals("Resume")){
                    startPause.setText("Pause");
                    timerResume();
                }

---

我关于stackOverFlow的第一个答案，希望能有所帮助：）。。。 这就是我解决问题的方法，根据您的要求从片段、底页、服务、对话框控制计时器，保留一个

静态布尔值

变量进行控制

在活动中声明：

long presetTime, runningTime;    
Handler mHandler =new Handler();    
Runnable countDownRunnable;
Toast toastObj;
public static boolean shouldTimerRun = true;
TextView counterTv;

在onCreate中：

presetTime =60000L;
runningTime= presetTime;
//setting up Timer
countDownRunnable=new Runnable() {
       @Override
         public void run() {
          if (shouldTimerRun) //if false, it runs but skips counting
          {
                counterTv.setText(simplifyTimeInMillis(runningTime));
             if (runningTime==0) {
                 deployToast("Task Completed"); //show toast on task completion 
                }
             runningTime -= 1000;
             presetTime = runningTime; //to resume the timer from last position
          }
          mHandler.postDelayed(countDownRunnable,1000); //simulating on-tick
         }
    };
mHandler.post(countDownRunnable); // Start our CountdownTimer

现在，每当您想暂停计时器时，请更改

shouldTimerRun

false

的值，然后继续，使其

为true

@Override
    public void onResume() {
        super.onResume();
        shouldTimerRun=true;
    }

    @Override
    public void onPause() {
        super.onPause();
        shouldTimerRun=false;
        deployToast("Timer is paused !!");
    }

帮助方法：（可以跳过）

公共静态字符串时间单位毫秒（长时间）{
字符串结果=”；
长差=时间；
长秒sinmilli=1000；
长分钟单位为毫秒=秒单位为毫秒*60；
长小时毫米=分钟毫米*60；
如果（差异=3600000）{
结果=结果+字符串.valueOf（差值/小时数）+“hr”；
差异=差异%hoursInMilli；
}
如果（差值>=60000）{
结果=结果+字符串.valueOf（差值/分钟/毫秒）+“m”；
差值=差值%minutesInMilli；
}
如果（差值>=1000）{
结果=结果+字符串.valueOf（差分/秒位数）+“s”；
}
返回结果；
}
public void deployToast（字符串msg）{
if（toastObj！=null）
toastObj.cancel（）；
toastObj=Toast.makeText（mContext、msg、Toast.LENGTH\u SHORT）；
toastObj.show（）；
}

@Override
    public void onResume() {
        super.onResume();
        shouldTimerRun=true;
    }

    @Override
    public void onPause() {
        super.onPause();
        shouldTimerRun=false;
        deployToast("Timer is paused !!");
    }

public static String simplifyTimeInMillis(long time) {

        String result="";
        long difference = time;
        long secondsInMilli = 1000;
        long minutesInMilli = secondsInMilli * 60;
        long hoursInMilli = minutesInMilli * 60;

        if (difference<1000){
            return "0";
        }

        if (difference>=3600000) {
            result = result + String.valueOf(difference / hoursInMilli) + "hr ";
            difference = difference % hoursInMilli;
        }
        if (difference>=60000) {
            result = result + String.valueOf(difference / minutesInMilli) + "m ";
            difference = difference % minutesInMilli;
        }
        if (difference>=1000){
            result = result + String.valueOf(difference / secondsInMilli) + "s";
        }

        return result;
    }

public void deployToast(String msg){
        if (toastObj!=null)
            toastObj.cancel();
        toastObj = Toast.makeText(mContext,msg,Toast.LENGTH_SHORT);
        toastObj.show();
    }

public class MainActivity extends AppCompatActivity {

TextView textView;

CountDownTimer ctimer;
boolean runCountDown;
private long leftTime;
private static final long MILL_IN_FUTURE = 6000;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    textView = findViewById(R.id.text_view);
    textView.setText("Click to start");
    textView.setOnClickListener(this::clickStartAndPauseAndResume);
    leftTime = MILL_IN_FUTURE;

}


public void clickStartAndPauseAndResume(View view) {

    if (!runCountDown) {


        long time = (leftTime == 0 || leftTime == MILL_IN_FUTURE) ? MILL_IN_FUTURE : leftTime;
        ctimer = new CountDownTimer(time, 1) {

            @Override
            public void onTick(long l) {

                leftTime = l;
                textView.setText(l + "ms");
            }

            @Override
            public void onFinish() {

                textView.setText("Done");
                leftTime = 0;
                runCountDown = false;
                textView.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        textView.setText("Click to start");
                    }
                }, 1000);
            }
        }.start();
        runCountDown = true;
    } else {
        ctimer.cancel();
        textView.setText(textView.getText() + "\n Click to resume");
        runCountDown = false;
    }
 }
}