CountdownTimer usage and principle analysis

[[436754]]

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

Preface

There are many ways to write countdown. Today we introduce a countdown control CountDownTimer that comes with Android.

1. CountDownTimer detailed explanation

CountDownTimer: A timed countdown that stops after a certain period of time. During the countdown, you will be notified at fixed intervals.

1. Initialization and start countdown

 public CountTimer(long millisInFuture, long countDownInterval) {
        super(millisInFuture, countDownInterval);
 }
 @Override
 public void initData() {
        countDownTimer = new CountDownTimer(200000, 1000) {
 @Override
 public void onTick(long millisUntilFinished) {
 //Unit day
                    long day = millisUntilFinished / (1000 * 24 * 60 * 60);
 //Unit time
                    long hour = (millisUntilFinished - day * (1000 * 24 * 60 * 60)) / (1000 * 60 * 60);
 //Unit points
                    long minute = (millisUntilFinished - day * (1000 * 24 * 60 * 60) - hour * (1000 * 60 * 60)) / (1000 * 60);
 //Unit: seconds
                    long second = (millisUntilFinished - day * (1000 * 24 * 60 * 60) - hour * (1000 * 60 * 60) - minute * (1000 * 60)) / 1000;
 }
 /**
 *Called after the countdown ends
 */
 @Override
 public void onFinish() {
 }
 };
        countDownTimer.start();
 }
 /**
 * Remember to close it to prevent memory overflow
 */
 @Override
 protected void onDestroy() {
 super.onDestroy();
    if (countDownTimer != null ) {
        countDownTimer.cancel();
        countDownTimer = null ;
 }
 }

2. Parameters and methods introduction

Initialization parameters

• millisInFuture The number of milliseconds from when start() is called to when the countdown is completed and the onFinish() method is called (countdown time, in milliseconds);
• countDownInterval receives the interval time of onTick(long) callback;

method

• public final void cancel () cancels the countdown (after cancellation, restarting the countdown will restart);
• public abstract void onFinish () is called when the countdown is completed;
• public abstract void onTick (long millisUntilFinished) is called at fixed intervals;
• Parameter millisUntilFinished countdown remaining time;
• public synchronized final CountDownTimer start () starts the countdown;

2. Source code annotation

 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.
 *Usage examples in official documentation:
 * Example of showing a 30 second countdown in a text field:
 *
 * <pre class= "prettyprint" >
 * new CountDownTimer(30000, 1000) {
 *
 * public void onTick(long millisUntilFinished) {
 * mTextField.setText( "seconds remaining: " + millisUntilFinished / 1000);
 * }
 *
 * public void onFinish() {
 * mTextField.setText( "done!" );
 * }
 * }.start();
 * </pre>
 *
 * 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.
 */
 /**
 * customize from CountDownTimer
 * Created by zhubingning on 16/09/16.
 */
 public abstract class CustomCountDownTimer {
 /**
     * Millis since epoch when alarm should stop.
 */
    private final long mMillisInFuture;
 //! add , to save the remaining milliseconds when pausing
    private long mCurrentMillisLeft;
 /**
     * The interval in millis that the user receives callbacks
 */
    private final long mCountdownInterval;
    private long mStopTimeInFuture;
 /**
     * boolean representing if the timer was canceled
 */
    private boolean mCancelled = 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.
 */
 //Constructor, (total countdown in milliseconds, countdown interval)
 public CustomCountDownTimer(long millisInFuture, long countDownInterval) {
        mMillisInFuture = millisInFuture;
        mCountdownInterval = countDownInterval;
 }
 //! add , get the total countdown time at this time
 public long getCountTimes(){
 return mMillisInFuture;
 }
 /**
 * Cancel the countdown.
 */
 //Cancel the countdown, the handler takes the message from the message queue
 public synchronized final void cancel() {
 mCancelled = true ;
        mHandler.removeMessages(MSG);
 }
 /**
 * Pause the countdown.
 */
 //! add , pause, call cancel() function, mCurrentMillisLeft is automatically saved as a global variable
 public synchronized final void pause() {
 cancel();
 }
 /**
 * Resume the countdown.
 */
 //! add , resume function, re-add message and start countdown according to the value of mCurrentMillisLeft
 public synchronized final void resume() {
 mCancelled = false ;
        if (mCurrentMillisLeft <= 0) {
 onFinish();
 return ;
 }
        mStopTimeInFuture = SystemClock.elapsedRealtime() + mCurrentMillisLeft;
        mHandler.sendMessage(mHandler.obtainMessage(MSG));
 return ;
 }
 /**
 * Start the countdown.
 */
 //Start countdown, handler sends message to queue
 public synchronized final CustomCountDownTimer start() {
 mCancelled = 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.
 */
 //Virtual function
 public abstract void onTick(long millisUntilFinished);
 /**
     * Callback fired when the time   is up.
 */
 //Virtual function
 public abstract void onFinish();
    private static final int MSG = 1;
 // handles counting down
 //handler
    private Handler mHandler = new Handler() {
 @Override
 public void handleMessage(Message msg) {
 //Synchronize threads
            synchronized (CustomCountDownTimer.this) {
 // Check if the countdown has been canceled
                if (mCancelled) {
 return ;
 }
 // Calculate the current remaining milliseconds
                final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();
 //According to the remaining milliseconds, either end the countdown, or just delay, or call onTick and delay
                if (millisLeft <= 0) {
                    onFinish();
                } else if (millisLeft < mCountdownInterval) {
                    // no tick, just delay until done
                    onTick(0);//! add  
                    sendMessageDelayed(obtainMessage(MSG), millisLeft);
 } else {
                    long lastTickStart = SystemClock.elapsedRealtime();
                    mCurrentMillisLeft=millisLeft;//! add  
                    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);
 }
 }
 }
 };
 }

Summarize

It's the end of the year and everyone is very busy. Everyone is trying to make more money and find a good job. If you have any questions, just send me a message.