Android: Comment mettre en pause et reprendre un compte à rebours?
J'ai développé un compte à rebours et je ne suis pas sûr de savoir comment mettre en pause et reprendre le chronomètre car la visualisation de texte pour le minuteur est en cours de clic. Cliquez pour démarrer puis cliquez à nouveau pour mettre en pause et pour reprendre, cliquez à nouveau sur la vue texte du minuteur.
Ceci est mon code:
Timer = (TextView) this.findViewById(R.id.time); //TIMER
Timer.setOnClickListener(TimerClickListener);
counter = new MyCount(600000, 1000);
}//end of create
private OnClickListener TimerClickListener = new OnClickListener() {
public void onClick(View v) {
updateTimeTask();
}
private void updateTimeTask() {
if (decision == 0) {
counter.start();
decision = 1;
} else if (decision == 2) {
counter.onResume1();
decision = 1;
} else {
counter.onPause1();
decision = 2;
}//end if
}
;
};
class MyCount extends CountDownTimer {
public MyCount(long millisInFuture, long countDownInterval) {
super(millisInFuture, countDownInterval);
}//MyCount
public void onResume1() {
onResume();
}
public void onPause1() {
onPause();
}
public void onFinish() {
Timer.setText("00:00");
p1++;
if (p1 <= 4) {
TextView PScore = (TextView) findViewById(R.id.pscore);
PScore.setText(p1 + "");
}//end if
}//finish
public void onTick(long millisUntilFinished) {
Integer milisec = new Integer(new Double(millisUntilFinished).intValue());
Integer cd_secs = milisec / 1000;
Integer minutes = (cd_secs % 3600) / 60;
Integer seconds = (cd_secs % 3600) % 60;
Timer.setText(String.format("%02d", minutes) + ":"
+ String.format("%02d", seconds));
///long timeLeft = millisUntilFinished / 1000;
/}//on tick
}//class MyCount
protected void onResume() {
super.onResume();
//handler.removeCallbacks(updateTimeTask);
//handler.postDelayed(updateTimeTask, 1000);
}//onResume
@Override
protected void onPause() {
super.onPause();
//do stuff
}//onPause
/*
* Copyright (C) 2010 Andrew Gainer
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.Apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Adapted from Android's CountDownTimer class
package com.cycleindex.multitimer;
import Android.os.Handler;
import Android.os.Message;
import Android.os.SystemClock;
/**
* Schedule a countdown until a time in the future, with
* regular notifications on intervals along the way.
*
* The calls to {@link #onTick(long)} are synchronized to this object so that
* one call to {@link #onTick(long)} won't ever occur before the previous
* callback is complete. This is only relevant when the implementation of
* {@link #onTick(long)} takes an amount of time to execute that is significant
* compared to the countdown interval.
*/
public abstract class CountDownTimerWithPause {
/**
* Millis since boot when alarm should stop.
*/
private long mStopTimeInFuture;
/**
* Real time remaining until timer completes
*/
private long mMillisInFuture;
/**
* Total time on timer at start
*/
private final long mTotalCountdown;
/**
* The interval in millis that the user receives callbacks
*/
private final long mCountdownInterval;
/**
* The time remaining on the timer when it was paused, if it is currently paused; 0 otherwise.
*/
private long mPauseTimeRemaining;
/**
* True if timer was started running, false if not.
*/
private boolean mRunAtStart;
/**
* @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 in millis at which to execute
* {@link #onTick(millisUntilFinished)} callbacks
* @param runAtStart True if timer should start running, false if not
*/
public CountDownTimerWithPause(long millisOnTimer, long countDownInterval, boolean runAtStart) {
mMillisInFuture = millisOnTimer;
mTotalCountdown = mMillisInFuture;
mCountdownInterval = countDownInterval;
mRunAtStart = runAtStart;
}
/**
* Cancel the countdown and clears all remaining messages
*/
public final void cancel() {
mHandler.removeMessages(MSG);
}
/**
* Create the timer object.
*/
public synchronized final CountDownTimerWithPause create() {
if (mMillisInFuture <= 0) {
onFinish();
} else {
mPauseTimeRemaining = mMillisInFuture;
}
if (mRunAtStart) {
resume();
}
return this;
}
/**
* Pauses the counter.
*/
public void pause () {
if (isRunning()) {
mPauseTimeRemaining = timeLeft();
cancel();
}
}
/**
* Resumes the counter.
*/
public void resume () {
if (isPaused()) {
mMillisInFuture = mPauseTimeRemaining;
mStopTimeInFuture = SystemClock.elapsedRealtime() + mMillisInFuture;
mHandler.sendMessage(mHandler.obtainMessage(MSG));
mPauseTimeRemaining = 0;
}
}
/**
* Tests whether the timer is paused.
* @return true if the timer is currently paused, false otherwise.
*/
public boolean isPaused () {
return (mPauseTimeRemaining > 0);
}
/**
* Tests whether the timer is running. (Performs logical negation on {@link #isPaused()})
* @return true if the timer is currently running, false otherwise.
*/
public boolean isRunning() {
return (! isPaused());
}
/**
* Returns the number of milliseconds remaining until the timer is finished
* @return number of milliseconds remaining until the timer is finished
*/
public long timeLeft() {
long millisUntilFinished;
if (isPaused()) {
millisUntilFinished = mPauseTimeRemaining;
} else {
millisUntilFinished = mStopTimeInFuture - SystemClock.elapsedRealtime();
if (millisUntilFinished < 0) millisUntilFinished = 0;
}
return millisUntilFinished;
}
/**
* Returns the number of milliseconds in total that the timer was set to run
* @return number of milliseconds timer was set to run
*/
public long totalCountdown() {
return mTotalCountdown;
}
/**
* Returns the number of milliseconds that have elapsed on the timer.
* @return the number of milliseconds that have elapsed on the timer.
*/
public long timePassed() {
return mTotalCountdown - timeLeft();
}
/**
* Returns true if the timer has been started, false otherwise.
* @return true if the timer has been started, false otherwise.
*/
public boolean hasBeenStarted() {
return (mPauseTimeRemaining <= mMillisInFuture);
}
/**
* Callback fired on regular interval
* @param millisUntilFinished The amount of time until finished
*/
public abstract void onTick(long millisUntilFinished);
/**
* Callback fired when the time is up.
*/
public abstract void onFinish();
private static final int MSG = 1;
// handles counting down
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
synchronized (CountDownTimerWithPause.this) {
long millisLeft = timeLeft();
if (millisLeft <= 0) {
cancel();
onFinish();
} else if (millisLeft < mCountdownInterval) {
// no tick, just delay until done
sendMessageDelayed(obtainMessage(MSG), millisLeft);
} else {
long lastTickStart = SystemClock.elapsedRealtime();
onTick(millisLeft);
// take into account user's onTick taking time to execute
long delay = mCountdownInterval - (SystemClock.elapsedRealtime() - lastTickStart);
// special case: user's onTick took more than mCountdownInterval to
// complete, skip to next interval
while (delay < 0) delay += mCountdownInterval;
sendMessageDelayed(obtainMessage(MSG), delay);
}
}
}
};
}
Source: This Gist.
Un moyen simple et agréable de créer une pause/reprise pour votre CountDownTimer est de créer une méthode distincte pour votre minuterie start , pause et resume comme suit:
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");
}
}
timer.start();
TimerStart a un paramètre long car il sera réutilisé par la méthode resume () ci-dessous. N'oubliez pas de stocker votre milliTillFinished (ci-dessus en tant que milliLeft) afin de pouvoir l'envoyer dans votre resume () méthode. Mettre en pause et reprendre les méthodes ci-dessous:
public void timerPause() {
timer.cancel();
}
private void timerResume() {
Log.i("min", Long.toString(min));
Log.i("Sec", Long.toString(sec));
timerStart(milliLeft);
}
Voici le code pour le bouton FYI:
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();
}
Eh bien, il n'y a pas d'API pour le suspendre ou le reprendre. Ce que vous devez faire est cancel() la minuterie et stocker le temps restant dans une variable. Lorsque vous appuyez à nouveau sur le bouton de reprise, redémarrez le chronomètre avec la valeur de la variable.
Vous savez Les chronomètres peuvent vous intéresser.
Vous pouvez essayer d'utiliser une bibliothèque que j'ai créée, Hourglass
Hourglass hourglass = new Hourglass(50000, 1000) {
@Override
public void onTimerTick(long timeRemaining) {
// Update UI
Toast.show(MainActivity.this, String.valueOf(timeRemaining), Toast.LENGTH_SHORT).show();
}
@Override
public void onTimerFinish() {
// Timer finished
Toast.show(MainActivity.this, "Timer finished", Toast.LENGTH_SHORT).show();
}
};
Utilisez hourglass.startTimer(); pour démarrer le chronomètre.
Il a des méthodes d'assistance qui permettent de mettre en pause et de reprendre le chronomètre.
hourglass.pauseTimer();
ET
hourglass.resumeTimer();
public static void setTimerMillis(Context context, long millis)
{ SharedPreferences sp =
context.getSharedPreferences(SessionManager.FILE_USER, Context.MODE_PRIVATE);
SharedPreferences.Editor spe = sp.edit(); spe.putLong(SessionManager.TIMER_MILLIS, millis); spe.apply(); }
void setExamTimer() {
setTimerColors();
final long maxTimeToShow = 60000; //testing
final long lastTimeinMillisLeftSaved = TestyBookHelper.getTimerMillis(context); //take saved value from sharedpref
final long intervalTime = 1000;
donut_exam_timer.setMax((int) maxTimeToShow);
CountDownTimer countDownTimer = new CountDownTimer(lastTimeinMillisLeftSaved, intervalTime) {
@Override
public void onTick(long millis) {
TestyBookHelper.setTimerMillis(context, millis);
String hms = String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis),
TimeUnit.MILLISECONDS.toMinutes(millis) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis))); System.out.println(hms);
donut_exam_timer.setText(hms);
donut_exam_timer.setProgress(millis);
}
@Override
public void onFinish() {
}
};
countDownTimer.start();
}
public static long getTimerMillis(Context context) {
SharedPreferences sp = context.getSharedPreferences(SessionManager.FILE_USER, Context.MODE_PRIVATE);
return sp.getLong(SessionManager.TIMER_MILLIS, 60000L);}
J'ai une solution simple. Tout ce que vous avez à faire est d’ajouter une variable supplémentaire qui stocke l’heure actuelle. Le seul ajout est currentMillis au sommet et dans onTick (). Utilisez cancel () pour faire une pause.
PS: J'utilise la bibliothèque butterknife, elle permet d'éviter d'utiliser findviewbyid et setonclicklisteners. Si vous ne souhaitez pas l'utiliser, vous pouvez simplement utiliser la méthode de base pour configurer les écouteurs et findviewbyid.
@BindView(R.id.play_btn) ImageButton play;
@BindView(R.id.pause_btn) ImageButton pause;
@BindView(R.id.close_btn) ImageButton close;
@BindView(R.id.time) TextView time;
private CountDownTimer countDownTimer;
private long currentMillis=10;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_game);
ButterKnife.bind(this);
}
@OnClick(R.id.play_btn) void play_game(){
this.play();
}
@OnClick(R.id.pause_btn) void pause_game(){
this.pause();
}
@OnClick(R.id.close_btn) void close_game(){
this.close();
}
void play(){
play.setVisibility(View.GONE);
close.setVisibility(View.GONE);
pause.setVisibility(View.VISIBLE);
time.setText(""+currentMillis);
countDownTimer = new CountDownTimer(currentMillis*1000,1000) {
@Override
public void onTick(long millisUntilFinish) {
currentMillis=millisUntilFinish/1000;
time.setText(""+millisUntilFinish/1000);
}
@Override
public void onFinish() {
time.setText("Done!");
}
};
countDownTimer.start();
}
void pause(){
play.setVisibility(View.VISIBLE);
close.setVisibility(View.VISIBLE);
pause.setVisibility(View.GONE);
countDownTimer.cancel();
}
void close(){
if(countDownTimer!=null){
countDownTimer.cancel();
countDownTimer=null;
}
Intent intent = new Intent(this,MainActivity.class);
startActivity(intent);
}
}