深入解读一下`android.os.CountDownTimer`

news2024/11/19 8:43:19

请添加图片描述

简介

在 Android 开发中，CountDownTimer 是一个非常有用的类，它可以用于倒计时任务，比如倒计时器、限时活动等。CountDownTimer 提供了一个简单的方式来实现定时操作，无需我们手动管理线程和计时器。

本文将深入解析 CountDownTimer 的工作原理、使用方法及其在实际应用中的一些技巧。

`CountDownTimer` 的基本用法

构造函数

要使用 CountDownTimer，我们首先需要创建一个实例。其构造函数如下：

public CountDownTimer(long millisInFuture, long countDownInterval) {
    // Implementation
}

millisInFuture: 表示倒计时的总时间（以毫秒为单位）。
countDownInterval: 表示倒计时间隔（以毫秒为单位），每隔多长时间回调一次 onTick 方法。

方法

CountDownTimer 提供了两个关键方法：

onTick(long millisUntilFinished): 每隔 countDownInterval时间会回调该方法，参数 millisUntilFinished 表示倒计时剩余的时间。
onFinish(): 倒计时完成时会回调该方法。

示例代码

下面是一个简单的示例，演示如何使用 CountDownTimer：

new CountDownTimer(30000,1000) {
    public void onTick ( long millisUntilFinished){
        Log.d("CountDownTimer", "剩余时间: " + millisUntilFinished / 1000);
    }
    public void onFinish () {
        Log.d("CountDownTimer", "倒计时结束");
    }
}.

start();

在这个示例中，我们创建了一个 30 秒的倒计时器，每秒回调一次 onTick方法，并在倒计时结束时回调 onFinish 方法。

Kotlin 示例代码

下面是一个使用 Kotlin 实现的示例：

object : CountDownTimer(30000, 1000) {
    override fun onTick(millisUntilFinished: Long) {
        Log.d("CountDownTimer", "剩余时间: ${millisUntilFinished / 1000}")
    }
    override fun onFinish() {
        Log.d("CountDownTimer", "倒计时结束")
    }
}.start()

深入理解 `CountDownTimer`

工作原理

CountDownTimer 的实现主要依赖于 Handler 和 Runnable。在其内部，通过 Handler 来发送延时消息，从而实现定时功能。

在 CountDownTimer 内部，有一个 Handler对象，负责在指定的时间间隔内不断发送消息。每当消息到达时，倒计时器的剩余时间会减少相应的间隔，并回调 onTick方法。

源码解析

让我们深入看看 CountDownTimer 的源码，了解其内部实现。

public abstract class CountDownTimer {
    private final long    mMillisInFuture;  // 倒计时总时间
    private final long    mCountdownInterval;  // 每次回调的间隔时间
    private       long    mStopTimeInFuture;  // 结束时间点
    private       boolean mCancelled = false;  // 取消标志

    // 构造函数，初始化倒计时总时间和回调间隔
    public CountDownTimer(long millisInFuture, long countDownInterval) {
        mMillisInFuture = millisInFuture;
        mCountdownInterval = countDownInterval;
    }

    // 取消倒计时
    public synchronized final void cancel() {
        mCancelled = true;
        mHandler.removeMessages(MSG);
    }

    // 开始倒计时
    public synchronized final CountDownTimer start() {
        mCancelled = false;
        if (mMillisInFuture <= 0) {
            onFinish();
            return this;
        }
        mStopTimeInFuture = SystemClock.elapsedRealtime() + mMillisInFuture;
        mHandler.sendMessage(mHandler.obtainMessage(MSG));
        return this;
    }

    // 每次间隔回调的抽象方法，需要子类实现
    public abstract void onTick(long millisUntilFinished);

    // 倒计时结束回调的抽象方法，需要子类实现
    public abstract void onFinish();

    private static final int MSG = 1;  // 消息标识

    // Handler 用于处理定时消息
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            synchronized (CountDownTimer.this) {
                if (mCancelled) {
                    return;
                }

                final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();  // 计算剩余时间
                if (millisLeft <= 0) {
                    onFinish();  // 倒计时结束
                } else if (millisLeft < mCountdownInterval) {
                    // 剩余时间小于回调间隔时，最后一次回调
                    mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG), millisLeft);
                } else {
                    long lastTickStart = SystemClock.elapsedRealtime();
                    onTick(millisLeft);  // 每次间隔回调

                    long delay = lastTickStart + mCountdownInterval - SystemClock.elapsedRealtime();
                    while (delay < 0) delay += mCountdownInterval;

                    // 发送下一个消息
                    mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG), delay);
                }
            }
        }
    };
}