暂停/恢复CountDownTimer Android [英] Pause/Resume CountDownTimer Android

问题描述

是否可以在Android中暂停CountDownTimer?我一直在寻找好的解决方案，但我只是找到一些我真的不喜欢的方法来做到这一点.只需将剩余时间保存在变量中，然后使用该值初始化新的CountDownTimer.

Is it possible to pause a CountDownTimer in Android? I have been looking for good solutions but I just find some ways to do this that I really don't like. As just save the left time in a variable and initialize a new CountDownTimer with that values.

这种解决方案行得通，但它们看起来不太好，因为我将圆形进度条和Textview与我的countdownTimer一起使用.尝试在CountDown上使这两个外观看起来真的很丑，却无法真正暂停"它.

That kind of solutions work but they didn't look so good because I´m using a circle Progress bar and a Textview together with my countdownTimer. Was really ugly try to look this two look good with the CountDown without be able to really "pause" it.

这是我的代码，用于使用ProgressBar和TextView初始化CountDownTimer.

Here is my code for initialize the CountDownTimer with a ProgressBar and a TextView.

    public void initProgress() {
    if (mCountdownProgressBar == null)
        mCountdownProgressBar = (CircleProgressBar) findViewById(R.id.progressBar);

    mCountDownTime = 30000; //Insert your desire time in Milliseconds here
    mCountdownProgressBar.setMaxProgress((int)TimeUnit.MILLISECONDS.toSeconds(mCountDownTime));
    mCountDownTimer = new CustomCountDownTimer(mCountDownTime, 1000) {

        @Override
        public void onTick(long millisUntilFinished) {
            Log.v("Log_tag", "Tick of Progress" + TimeUnit.MILLISECONDS.toSeconds(millisUntilFinished));
            mCountdownProgressBar.setmProgress(TimeUnit.MILLISECONDS.toSeconds(millisUntilFinished));
            mTimer.setText(Util.getTimeForTimer(millisUntilFinished, Util.TIME_FORMAT));
        }


        @Override
        public void onFinish() {
            mCountdownProgressBar.setmProgress(0);
            mTimer.setText(Util.getTimeForTimer(0, Util.TIME_FORMAT));
        }
    };
    mCountDownTimer.start();
}

使用此代码，您将可以与CountDownTimer一起设置progressBar和TextView.为了能够轻松地暂停和恢复，我接下来将发布CountDownTimer的自定义类.

With this code you will be able to set a progressBar and a TextView together with your CountDownTimer. To be able to pause and resume it pretty easy I will post next a Custom Class for CountDownTimer.

推荐答案

这是解决方案！

import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.util.Log;

public abstract class CustomCountDownTimer {

    private final String TAG = "CustomCountDownTimer";
    /**
     * Millis since epoch when alarm should stop.
     */

    private final long mMillisInFuture;
    /**
     * The interval in millis that the user receives callbacks
     */
    private final long mCountdownInterval;

    /**
     * The time in millis when the timer was paused
     */
    private long mTimePaused;

    /**
     * The final time when the timer must to stop (actual hour + countdown in millis)
     */
    private long mStopTimeInFuture;

    /**
     * boolean representing if the timer was cancelled
     */
    private boolean mCancelled = false;

    /**
     * boolean representing if the timer is paused
     */
    private boolean mPause = false;


    /**
     * @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 CustomCountDownTimer(long millisInFuture, long countDownInterval) {
        mMillisInFuture = millisInFuture;
        mCountdownInterval = countDownInterval;
    }

    /**
     * Cancel the countdown.
     */
    public synchronized final void cancel() {
        mCancelled = true;
        mHandler.removeMessages(MSG);
    }

    /**
     * Pause the countdown.
     */
    public synchronized final void pause() {
        cancel();
        //Save the time and hour to resume the timer correctly later.
        mTimePaused = SystemClock.elapsedRealtime();
        mPause = true;
    }

    /**
     * Resume the countdown.
     */
    public synchronized final void resume() {
        //Booleans back to false value
        mPause = false;
        mCancelled = false;
        //We set the time to a new one because the elapsedTime as change
        mStopTimeInFuture = mStopTimeInFuture + (SystemClock.elapsedRealtime() - mTimePaused);
        Log.d(TAG, "mStopTimeInFuture: " + mStopTimeInFuture);
        mHandler.sendMessage(mHandler.obtainMessage(MSG));
    }

    /**
     * Start the countdown.
     */
    public synchronized final CustomCountDownTimer start() {
        mCancelled = false;
        mPause = false;
        if (mMillisInFuture <= 0) {
            onFinish();
            return this;
        }
        mStopTimeInFuture = SystemClock.elapsedRealtime() + mMillisInFuture;
        mHandler.sendMessage(mHandler.obtainMessage(MSG));
        return this;
    }


    /**
     * 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 (CustomCountDownTimer.this) {
                if (mCancelled || mPause) {
                    return;
                }

                final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();
                Log.d(TAG, "millisLeft: " + millisLeft);
                if (millisLeft <= 0) {
                    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 = lastTickStart + mCountdownInterval - SystemClock.elapsedRealtime();

                    // special case: user's onTick took more than interval to
                    // complete, skip to next interval
                    while (delay < 0) delay += mCountdownInterval;

                    sendMessageDelayed(obtainMessage(MSG), delay);
                }
            }
        }
    };
}

这篇关于暂停/恢复CountDownTimer Android的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！