Android 关于倒计时功能的实现

关于倒计时的实现，可以说有很多的方法，比较常见的就是Timer+TimerTask+Handler了，或者还可以配合Runnable。例如下面的代码：

1. import java.util.Timer;
2. import java.util.TimerTask;
3. import android.app.Activity;
4. import android.os.Bundle;
5. import android.os.Handler;
6. import android.os.Message;
7. import android.util.Log;
8. import android.view.View;
9. import android.widget.Button;
10. import android.widget.TextView;
11. public class MainActivity extends Activity {
12. Timer timer;
13. @Override
14. public void onCreate(Bundle savedInstanceState) {
15. super.onCreate(savedInstanceState);
16. setContentView(R.layout.main);
17. final TextView tv = (TextView) findViewById(R.id.textView1);
18. Button b = (Button) findViewById(R.id.button1);
19. // 定义Handler
20. final Handler handler = new Handler() {
21. @Override
22. public void handleMessage(Message msg) {
23. super.handleMessage(msg);
24. //handler处理消息
25. if(msg.what>0){
26. tv1.setText("" + msg.what);
27. }else{
28. //在handler里可以更改UI组件
29. tv.setText("倒时");
30. timer.cancel();
31. }
32. }
33. };
34. b.setOnClickListener(new View.OnClickListener() {
35. @Override
36. public void onClick(View arg0) {
37. // 定义计时器
38. timer = new Timer();
39. // 定义计划任务，根据参数的不同可以完成以下种类的工作：在固定时间执行某任务，在固定时间开始重复执行某任务，重复时间间隔可控，在延迟多久后执行某任务，在延迟多久后重复执行某任务，重复时间间隔可控
40. timer.schedule(new TimerTask() {
41. int i = 10;
42. // TimerTask 是个抽象类,实现的是Runable类
43. @Override
44. public void run() {
45. //定义一个消息传过去
46. Message msg = new Message();
47. msg.what = i--;
48. handler.sendMessage(msg);
49. }
50. }, 1000, 200);
51. }
52. });
53. }
54. }

基本逻辑就是这样，需要注意一点是 timer.schedule(task,1000,5000),如果设置为 timer.schedule(task,5000)是不会工作的。因为timer.schedule(task,5000) 是表示执行一次的任务。timer.schedule(task,1000,5000)表示1 秒钟后开始 5 秒钟为周期 的重复执行任务。

这个例子北京简单，下面给出一个完整的例子：

1. import java.util.Timer;
2. import java.util.TimerTask;
3. import com.example.jishiqi.SaveRun;
4. import android.app.Activity;
5. import android.app.AlertDialog;
6. import android.content.DialogInterface;
7. import android.os.Bundle;
8. import android.os.Handler;
9. import android.os.Message;
10. import android.view.View;
11. import android.view.View.OnClickListener;
12. import android.widget.Button;
13. import android.widget.TextView;
14. public class MainActivity extends Activity {
15. Button btnselecttime, daojishijicubutton;
16. TextView tvTime;
17. private Timer timer = null;
18. private TimerTask task = null;
19. private Handler handler = null;
20. private Message msg = null;
21. float predegree = 0;
22. float secondpredegree = 0;
23. float hourpredegree = 0;
24. int mlCount = -1;
25. @Override
26. public void onCreate(Bundle icicle) {
27. super.onCreate(icicle);
28. setContentView(R.layout.main);
29. btnselecttime = (Button) findViewById(R.id.daojishistartbutton);
30. daojishijicubutton = (Button) findViewById(R.id.daojishijicubutton);
31. tvTime = (TextView) findViewById(R.id.daojishitvTime);
32. SaveRun.setisdaojishi(false);
33. handler = new Handler() {
34. @Override
35. public void handleMessage(Message msg) {
36. switch (msg.what) {
37. case 1:
38. mlCount--;
39. if (mlCount <= 0) {
40. enddaojishi();
41. }
42. int totalSec = 0;
43. int yushu = 0;
44. totalSec = (int) (mlCount / 10);
45. yushu = (int) (mlCount % 10);
46. int min = (totalSec / 60);
47. int sec = (totalSec % 60);
48. try {
49. tvTime.setText(String.format("%1$02d:%2$02d.%3$d", min,
50. sec, yushu));
51. predegree = (float) (0.6 * mlCount);
52. secondpredegree = (float) (36.0 * mlCount);
53. hourpredegree = (float) (mlCount / 100);
54. } catch (Exception e) {
55. tvTime.setText("" + min + ":" + sec + "." + yushu);
56. e.printStackTrace();
57. }
58. break;
59. default:
60. break;
61. }
62. super.handleMessage(msg);
63. }
64. };
65. }
66. private void enddaojishi() {
67. try {
68. task.cancel();
69. task = null;
70. timer.cancel();
71. timer.purge();
72. timer = null;
73. handler.removeMessages(msg.what);
74. new AlertDialog.Builder(MainActivity.this)
75. .setTitle("提示 ")
76. .setMessage("倒计时结束")
77. .setPositiveButton("确定",
78. new DialogInterface.OnClickListener() {
79. @Override
80. public void onClick(DialogInterface dialog,
81. int which) {
82. dialog.cancel();
83. mlCount = 600;
84. btnselecttime.setText("开始");
85. SaveRun.setisdaojishi(false);
86. }
87. }).setCancelable(false).create().show();
88. } catch (Exception e) {
89. e.printStackTrace();
90. }
91. }
92. @Override
93. protected void onStart() {
94. daojishijicubutton.setOnClickListener(new OnClickListener() {
95. @Override
96. public void onClick(View v) {
97. predegree = 0;
98. secondpredegree = 0;
99. hourpredegree = 0;
100. mlCount = -1;
101. btnselecttime.setText("开始");
102. SaveRun.setisdaojishi(false);
103. try {
104. if (task != null) {
105. task.cancel();
106. task = null;
107. timer.cancel();
108. timer.purge();
109. timer = null;
110. handler.removeMessages(msg.what);
111. }
112. } catch (Exception e) {
113. e.printStackTrace();
114. }
115. }
116. });
117. btnselecttime.setOnClickListener(new OnClickListener() {
118. @Override
119. public void onClick(View arg0) {
120. if (null == timer) {
121. if (mlCount == -1 || mlCount == 0) {
122. mlCount = 600;
123. }
124. if (mlCount > 0) {
125. SaveRun.setisdaojishi(true);
126. btnselecttime.setText("暂停");
127. if (null == task) {
128. task = new TimerTask() {
129. @Override
130. public void run() {
131. if (null == msg) {
132. msg = new Message();
133. } else {
134. msg = Message.obtain();
135. }
136. msg.what = 1;
137. handler.sendMessage(msg);
138. }
139. };
140. }
141. timer = new Timer(true);
142. timer.schedule(task, 100, 100);
143. }
144. } else {
145. try {
146. SaveRun.setisdaojishi(false);
147. btnselecttime.setText("继续");
148. task.cancel();
149. task = null;
150. timer.cancel();
151. timer.purge();
152. timer = null;
153. handler.removeMessages(msg.what);
154. } catch (Exception e) {
155. e.printStackTrace();
156. }
157. }
158. }
159. });
160. super.onStart();
161. }
162. }

布局：

1. <?xml version="1.0" encoding="utf-8"?>
2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:layout_width="fill_parent"
4. android:layout_height="fill_parent"
5. android:orientation="vertical" >
6. <TextView
7. android:id="@+id/daojishitvTime"
8. android:layout_width="wrap_content"
9. android:layout_height="wrap_content"
10. android:layout_above="@+id/daojishibuttonlinear"
11. android:layout_centerInParent="true"
12. android:text="00:00.0"
13. android:textSize="35sp"
14. android:textStyle="bold" />
15. <LinearLayout
16. android:id="@+id/daojishibuttonlinear"
17. android:layout_width="match_parent"
18. android:layout_height="wrap_content"
19. android:layout_alignParentBottom="true"
20. android:orientation="vertical" >
21. <LinearLayout
22. android:layout_width="match_parent"
23. android:layout_height="74sp"
24. android:background="@drawable/v5_bottom_bar_bg_light"
25. android:orientation="horizontal" >
26. <Button
27. android:id="@+id/daojishistartbutton"
28. android:layout_width="wrap_content"
29. android:layout_height="50sp"
30. android:layout_gravity="center_vertical"
31. android:layout_marginLeft="8sp"
32. android:layout_marginRight="3sp"
33. android:layout_weight="1"
34. android:background="@drawable/startbutton"
35. android:text="开始" />
36. <Button
37. android:id="@+id/daojishijicubutton"
38. android:layout_width="wrap_content"
39. android:layout_height="50sp"
40. android:layout_gravity="center_vertical"
41. android:layout_marginLeft="3sp"
42. android:layout_marginRight="8sp"
43. android:layout_weight="1"
44. android:background="@drawable/startbutton"
45. android:text="取消" />
46. </LinearLayout>
47. </LinearLayout>
48. </RelativeLayout>

    

显然，这个方式比较笨拙，我们可以对此进行一个封装，利用Handler和Eunnable，看下面的代码：

1. package com.example.daojishi;
2. import android.os.Handler;
3. import android.util.Log;
4. public class MyCountDownTimer {
5. private long millisInFuture;
6. private long countDownInterval;
7. private boolean status;
8. public MyCountDownTimer(long pMillisInFuture, long pCountDownInterval) {
9. this.millisInFuture = pMillisInFuture;
10. this.countDownInterval = pCountDownInterval;
11. status = false;
12. Initialize();
13. }
14. public void Stop() {
15. status = false;
16. }
17. public long getCurrentTime() {
18. return millisInFuture;
19. }
20. public void Start() {
21. status = true;
22. }
23. public void Initialize() {
24. final Handler handler = new Handler();
25. Log.v("status", "starting");
26. final Runnable counter = new Runnable() {
27. public void run() {
28. long sec = millisInFuture / 1000;
29. if (status) {
30. if (millisInFuture <= 0) {
31. Log.v("status", "done");
32. } else {
33. Log.v("status", Long.toString(sec) + " seconds remain");
34. millisInFuture -= countDownInterval;
35. handler.postDelayed(this, countDownInterval);
36. }
37. } else {
38. Log.v("status", Long.toString(sec)
39. + " seconds remain and timer has stopped!");
40. handler.postDelayed(this, countDownInterval);
41. }
42. }
43. };
44. handler.postDelayed(counter, countDownInterval);
45. }
46. }

这个类就是负责倒计时的类，下面结合Activity，看一下怎么用：

1. package com.example.daojishi;
2. import android.app.Activity;
3. import android.os.Bundle;
4. import android.os.Handler;
5. import android.util.Log;
6. import android.view.View;
7. import android.widget.Button;
8. import android.widget.TextView;
9. public class CounterActivity extends Activity {
10. /** Called when the activity is first created. */
11. TextView timeText;
12. Button startBut;
13. Button stopBut;
14. MyCountDownTimer mycounter;
15. @Override
16. public void onCreate(Bundle savedInstanceState) {
17. super.onCreate(savedInstanceState);
18. setContentView(R.layout.main);
19. timeText = (TextView) findViewById(R.id.time);
20. startBut = (Button) findViewById(R.id.start);
21. stopBut = (Button) findViewById(R.id.stop);
22. mycounter = new MyCountDownTimer(20000, 1000);
23. RefreshTimer();
24. }
25. public void StartTimer(View v) {
26. Log.v("startbutton", "开始倒计时");
27. mycounter.Start();
28. }
29. public void StopTimer(View v) {
30. Log.v("stopbutton", "暂停倒计时");
31. mycounter.Stop();
32. }
33. public void RefreshTimer() {
34. final Handler handler = new Handler();
35. final Runnable counter = new Runnable() {
36. public void run() {
37. timeText.setText(Long.toString(mycounter.getCurrentTime()));
38. handler.postDelayed(this, 100);
39. }
40. };
41. handler.postDelayed(counter, 100);
42. }
43. }

布局文件：

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:layout_width="fill_parent"
4. android:layout_height="fill_parent"
5. android:orientation="vertical"
6. android:weightSum="1" >
7. <TextView
8. android:id="@+id/time"
9. android:layout_width="wrap_content"
10. android:layout_height="wrap_content"
11. android:text="TextView"
12. android:textAppearance="?android:attr/textAppearanceLarge" >
13. </TextView>
14. <Button
15. android:id="@+id/start"
16. android:layout_width="wrap_content"
17. android:layout_height="wrap_content"
18. android:onClick="StartTimer"
19. android:text="Start" >
20. </Button>
21. <Button
22. android:id="@+id/stop"
23. android:layout_width="wrap_content"
24. android:layout_height="wrap_content"
25. android:onClick="StopTimer"
26. android:text="Stop" >
27. </Button>
28. </LinearLayout>

这样就可以比较方便地使用倒计时功能了。但是还有一个更简单的方法。

在Android中有一个CountDownTimer类，这个类就是用来实现类似倒计时方面的功能。使用的时候，只需要继承自CountDownTimer并实现它的方法。

1. import android.app.Activity;
2. import android.os.Bundle;
3. import android.content.Intent;
4. import android.os.CountDownTimer;
5. import android.widget.TextView;
6. import android.widget.Toast;
7. public class NewActivity extends Activity {
8. private MyCount mc;
9. private TextView tv;
10. @Override
11. protected void onCreate(Bundle savedInstanceState) {
12. super.onCreate(savedInstanceState);
13. setContentView(R.layout.main);
14. tv = (TextView)findViewById(R.id.show);
15. mc = new MyCount(30000, 1000);
16. mc.start();
17. }
18. /*定义一个倒计时的内部类*/
19. class MyCount extends CountDownTimer {
20. public MyCount(long millisInFuture, long countDownInterval) {
21. super(millisInFuture, countDownInterval);
22. }
23. @Override
24. public void onFinish() {
25. tv.setText("done");
26. }
27. @Override
28. public void onTick(long millisUntilFinished) {
29. tv.setText("seconds remaining: " + millisUntilFinished / 1000）;
30. }
31. }
32. }

onFinish()方法是本次倒计时结束的时候调用的，onTick是每隔1秒钟执行的，我们就是在这里执行重复的任务，像本例子的显示时间。执行完后会自动取消，如果在期间停止的话，可以调用cancel()方法。看一下它的源码就会发现，它是使用Handler+SystemClock来实现的。

1. /*
2. * Copyright (C) 2008 The Android Open Source Project
3. *
4. * Licensed under the Apache License, Version 2.0 (the "License");
5. * you may not use this file except in compliance with the License.
6. * You may obtain a copy of the License at
7. *
8. *      http://www.apache.org/licenses/LICENSE-2.0
9. *
10. * Unless required by applicable law or agreed to in writing, software
11. * distributed under the License is distributed on an "AS IS" BASIS,
12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13. * See the License for the specific language governing permissions and
14. * limitations under the License.
15. */
16. package android.os;
17. import android.util.Log;
18. /**
19. * Schedule a countdown until a time in the future, with
20. * regular notifications on intervals along the way.
21. *
22. * Example of showing a 30 second countdown in a text field:
23. *
24. * <pre class="prettyprint">
25. * new CountDownTimer(30000, 1000) {
26. *
27. *     public void onTick(long millisUntilFinished) {
28. *         mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
29. *     }
30. *
31. *     public void onFinish() {
32. *         mTextField.setText("done!");
33. *     }
34. *  }.start();
35. * </pre>
36. *
37. * The calls to {@link #onTick(long)} are synchronized to this object so that
38. * one call to {@link #onTick(long)} won't ever occur before the previous
39. * callback is complete.  This is only relevant when the implementation of
40. * {@link #onTick(long)} takes an amount of time to execute that is significant
41. * compared to the countdown interval.
42. */
43. public abstract class CountDownTimer {
44. /**
45. * Millis since epoch when alarm should stop.
46. */
47. private final long mMillisInFuture;
48. /**
49. * The interval in millis that the user receives callbacks
50. */
51. private final long mCountdownInterval;
52. private long mStopTimeInFuture;
53. /**
54. * @param millisInFuture The number of millis in the future from the call
55. *   to {@link #start()} until the countdown is done and {@link #onFinish()}
56. *   is called.
57. * @param countDownInterval The interval along the way to receive
58. *   {@link #onTick(long)} callbacks.
59. */
60. public CountDownTimer(long millisInFuture, long countDownInterval) {
61. mMillisInFuture = millisInFuture;
62. mCountdownInterval = countDownInterval;
63. }
64. /**
65. * Cancel the countdown.
66. */
67. public final void cancel() {
68. mHandler.removeMessages(MSG);
69. }
70. /**
71. * Start the countdown.
72. */
73. public synchronized final CountDownTimer start() {
74. if (mMillisInFuture <= 0) {
75. onFinish();
76. return this;
77. }
78. mStopTimeInFuture = SystemClock.elapsedRealtime() + mMillisInFuture;
79. mHandler.sendMessage(mHandler.obtainMessage(MSG));
80. return this;
81. }
82. /**
83. * Callback fired on regular interval.
84. * @param millisUntilFinished The amount of time until finished.
85. */
86. public abstract void onTick(long millisUntilFinished);
87. /**
88. * Callback fired when the time is up.
89. */
90. public abstract void onFinish();
91. private static final int MSG = 1;
92. // handles counting down
93. private Handler mHandler = new Handler() {
94. @Override
95. public void handleMessage(Message msg) {
96. synchronized (CountDownTimer.this) {
97. final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime();
98. if (millisLeft <= 0) {
99. onFinish();
100. } else if (millisLeft < mCountdownInterval) {
101. // no tick, just delay until done
102. sendMessageDelayed(obtainMessage(MSG), millisLeft);
103. } else {
104. long lastTickStart = SystemClock.elapsedRealtime();
105. onTick(millisLeft);
106. // take into account user's onTick taking time to execute
107. long delay = lastTickStart + mCountdownInterval - SystemClock.elapsedRealtime();
108. // special case: user's onTick took more than interval to
109. // complete, skip to next interval
110. while (delay < 0) delay += mCountdownInterval;
111. sendMessageDelayed(obtainMessage(MSG), delay);
112. }
113. }
114. }
115. };
116. }

所以，如果你的程序需要执行一些周期性的任务，就可以考虑使用CountDownTimer这个类了。需要注意的是，在上面的这个例子中，最后显示时间是1，也就是说其实上执行了29次。所以这个地方一定要注意，如果你的任务次数是n，那么设置的时候一定要注意设置成n+1的时间。
    
    最后，欢迎大家评论交流，谢谢。