私はカウントダウンタイマーを開発しましたが、タイマーのテキストビューがクリックされているときにタイマーを一時停止して再開する方法がわかりません。クリックして開始し、もう一度クリックして一時停止し、再開するには、タイマーのテキストビューをもう一度クリックします。
これは私のコードです:
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);
}
}
}
};
}
出典: This Gist。
CountDownTimerのPause/Resumeを作成する素敵で簡単な方法は、タイマー用の別のメソッドを作成することですstart、pauseおよびresume as続く:
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には、以下のresume()メソッドで再利用されるため、長いパラメーターがあります。 milliTillFinished(上記のmilliLeft)を保存して、resume()メソッドで送信できるようにしてください。以下のメソッドをそれぞれ一時停止および再開します。
public void timerPause() {
timer.cancel();
}
private void timerResume() {
Log.i("min", Long.toString(min));
Log.i("Sec", Long.toString(sec));
timerStart(milliLeft);
}
ボタン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();
}
それを一時停止または再開するAPIはありません。あなたがすべきことはcancel()
タイマーであり、残り時間を変数に格納します。再開ボタンをもう一度押すと、変数の値でタイマーが再起動します。
あなたは知っています クロノメーター はあなたに興味があるかもしれません。
私が作成したライブラリを使用してみることができます 砂時計
_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();
}
};
_
タイマーを開始するには、hourglass.startTimer();
を使用します。
タイマーを一時停止および再開できるヘルパーメソッドがあります。
_hourglass.pauseTimer();
_
そして
_hourglass.resumeTimer();
_
簡単な解決策があります。あなたがしなければならないすべては、現在の時間を格納する追加の変数を追加することです。唯一の追加は、上部とonTick()のcurrentMillisです。一時停止するには、cancel()を使用します。
PS:バターナイフライブラリを使用しています。これは、findviewbyidおよびsetonclicklistenersの使用を回避するために使用されます。使用したくない場合は、リスナーと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);
}
}
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);}