AlarmManager的使用

AlarmManager的作用文档中的解释是：在特定的时刻为我们广播一个指定的Intent。简单的说就是我们设定一个时间，然后在该时间到来时，AlarmManager为我们广播一个我们设定的Intent。


android提供了四种类型的闹钟：
❑ ELAPSED_REALTIME
在指定的延时过后，发送广播，但不唤醒设备。

❑ ELAPSED_REALTIME_WAKEUP
在指定的演示后，发送广播，并唤醒设备
延时是要把系统启动的时间SystemClock.elapsedRealtime()算进去的，具体用法看代码。

❑ RTC
在指定的时刻，发送广播，但不唤醒设备

❑ RTC_WAKEUP
在指定的时刻，发送广播，并唤醒设备


AlarmManager提供的方法：
❑ void set(int type, long triggerAtTime, PendingIntent operation)
设置一个闹钟

❑ void setRepeating(int type, long triggerAtTime, long interval, PendingIntent operation)
设置一个会重复的闹钟

❑ void setInexactRepeating(int type, long triggerAtTime, long interval, PendingIntent operation)
设置一个重复闹钟的不精确版本，它相对而言更节能（power-efficient）一些，因为系统可能会将几个差不多的闹钟合并为一个来执行，减少设备的唤醒次数。
内置的几个interval为：
INTERVAL_FIFTEEN_MINUTES
INTERVAL_HALF_HOUR
INTERVAL_HOUR
INTERVAL_HALF_DAY
INTERVAL_DAY
如果你将其设为DAY，那么可能这一天中的所有闹钟都会被合并掉。

❑ void cancel(PendingIntent operation)
取消一个设置的闹钟

❑ void setTimeZone(String timeZone)
设置系统的默认时区。需要android.permission.SET_TIME_ZONE权限

Java代码

1. // 首先创建Receiver
2. public class AlarmReceiver extends BroadcastReceiver {
3. @Override
4. public void onReceive(Context context, Intent intent) {
5. Toast.makeText(context, "alarm", Toast.LENGTH_SHORT).show();
6. }
7. }

Xml代码

1. // manifest中申明，并不需要intent-filter，我们是明确指定发到哪个receiver的

PendingIntent：简单的说就是在Intent上在加个指定的动作。Intent的话，我们还需要在执行startActivity、startService或sendBroadcast才能使Intent有用。而PendingIntent的话就是将这个动作包含在内了，如PendingIntent.getBroadcast就包含了sendBroadcast的动作。

5s后发送指定广播

Java代码

1. AlarmManager alarmMgr = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
2. Intent intent = new Intent(getApplicationContext(), AlarmReceiver.class);
3. int requestCode = 0;
4. PendingIntent pendIntent = PendingIntent.getBroadcast(getApplicationContext(),
5. requestCode, intent, PendingIntent.FLAG_UPDATE_CURRENT);
6. // 5秒后发送广播，只发送一次
7. int triggerAtTime = SystemClock.elapsedRealtime() + 5 * 1000;
8. alarmMgr.set(AlarmManager.ELAPSED_REALTIME, triggerAtTime, pendIntent);

5s后发送指定广播，然后每个10秒重复发送广播

Java代码

1. AlarmManager alarmMgr = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
2. Intent intent = new Intent(getApplicationContext(), AlarmReceiver.class);
3. int requestCode = 0;
4. PendingIntent pendIntent = PendingIntent.getBroadcast(getApplicationContext(),
5. requestCode, intent, PendingIntent.FLAG_UPDATE_CURRENT);
6. // 5秒后发送广播，然后每个10秒重复发广播。广播都是直接发到AlarmReceiver的
7. int triggerAtTime = SystemClock.elapsedRealtime() + 5 * 1000;
8. int interval = 10 * 1000;
9. alarmMgr.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, interval, pendIntent);

取消一个闹钟

Java代码

1. AlarmManager alarmMgr = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
2. Intent intent = new Intent(getApplicationContext(), AlarmReceiver.class);
3. PendingIntent pendIntent = PendingIntent.getBroadcast(getApplicationContext(),
4. 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
5. // 与上面的intent匹配（filterEquals(intent)）的闹钟会被取消
6. alarmMgr.cancel(pendIntent);

AlarmManager 包含的主要方法：

[java]  view plain copy print ?

1. // 取消已经注册的与参数匹配的定时器     
2. void   cancel(PendingIntent operation)    
3. //注册一个新的延迟定时器  
4. void   set(int type, long triggerAtTime, PendingIntent operation)    
5. //注册一个重复类型的定时器  
6. void   setRepeating(int type, long triggerAtTime, long interval, PendingIntent operation)    
7. //注册一个非精密的重复类型定时器  
8. void setInexactRepeating (int type, long triggerAtTime, long interval, PendingIntent operation)  
9. //设置时区    
10. void   setTimeZone(String timeZone)   

定时器主要类型：

[java]  view plain copy print ?

1. public   static   final   int  ELAPSED_REALTIME    
2. // 当系统进入睡眠状态时，这种类型的闹铃不会唤醒系统。直到系统下次被唤醒才传递它，该闹铃所用的时间是相对时间，是从系统启动后开始计时的,包括睡眠时 间，可以通过调用SystemClock.elapsedRealtime()获得。系统值是3    (0x00000003)。     
3.     
4. public   static   final   int  ELAPSED_REALTIME_WAKEUP    
5. //能唤醒系统，用法同ELAPSED_REALTIME，系统值是2 (0x00000002) 。     
6.     
7. public   static   final   int  RTC    
8. //当系统进入睡眠状态时，这种类型的闹铃不会唤醒系统。直到系统下次被唤醒才传递它，该闹铃所用的时间是绝对时间，所用时间是UTC时间，可以通过调用 System.currentTimeMillis()获得。系统值是1 (0x00000001) 。     
9.     
10. public   static   final   int  RTC_WAKEUP    
11. //能唤醒系统，用法同RTC类型，系统值为 0 (0x00000000) 。     
12.     
13. Public static   final   int  POWER_OFF_WAKEUP    
14. //能唤醒系统，它是一种关机闹铃，就是说设备在关机状态下也可以唤醒系统，所以我们把它称之为关机闹铃。使用方法同RTC类型，系统值为4(0x00000004)。     

当你的应用不在运行，而此时你仍然需要你的应用去执行一些操作（比如，短信拦截），只有这种时候才使用AlarmManager, 其他正常情况下的，推荐使用Handler。

AlarmManager 生命周期：

repeating AlarmManager一旦启动就会一直在后台运行(除非执行cancel方法)，可以在“应用管理”中看到这个应用状态是正在运行。 “强行停止”可以让Alarmmanager停掉。

尝试了几种任务管理器， 都只能重置计数器（确实释放内存了），但都无法关闭定时器，只有系统自带的“强行停止”奏效。

如果某个AlarmManager已经启动， 程序又再次去启动它，只要PendingIntent是一样，那么之前那个AlarmManager会被release掉。

如何使用AlarmManager？

使用AlarmManager共有三种方式， 都是通过PendingIntent。

[java]  view plain copy print ?

1. getActivity(Context, int, Intent, int)  
2.   
3. getBroadcast(Context, int, Intent, int)  
4.   
5. getService(Context, int, Intent, int)  

这边就举一个使用BroadCast的例子。

首先是创建一个BroadCast类，需要继承BroadCastReceiver， 如下：

[java]  view plain copy print ?

1. /* 
2.  *  Copyright (c) 2011, Yulong Information Technologies 
3.  *  All rights reserved. 
4.  *   
5.  *  @Project: AlarmTest 
6.  *  @author: Robot   
7.  */  
8. package com.yfz;  
9.   
10. import android.content.BroadcastReceiver;  
11. import android.content.Context;  
12. import android.content.Intent;  
13. import android.util.Log;  
14.   
15. /** 
16.  * @author Robot 
17.  * @weibo http://weibo.com/feng88724 
18.  * @date Nov 18, 2011    
19.  */  
20. public class ActionBroadCast extends BroadcastReceiver {  
21.       
22.     private static int num = 0;  
23.     /* (non-Javadoc) 
24.      * @see android.content.BroadcastReceiver#onReceive(android.content.Context, android.content.Intent) 
25.      */  
26.     @Override  
27.     public void onReceive(Context context, Intent intent) {  
28.         // TODO Auto-generated method stub  
29.         Log.e("ActionBroadCast", "New Message !" + num++);  
30.     }  
31.   
32. }  

下面就让我们启动AlarmManager, 这边就直接在Activity中启动了， 如下：

[java]  view plain copy print ?

1. package com.yfz;  
2.   
3. import android.app.Activity;  
4. import android.app.AlarmManager;  
5. import android.app.PendingIntent;  
6. import android.content.Intent;  
7. import android.os.Bundle;  
8.   
9. public class AlarmTestActivity extends Activity {  
10.     /** Called when the activity is first created. */  
11.     @Override  
12.     public void onCreate(Bundle savedInstanceState) {  
13.         super.onCreate(savedInstanceState);  
14.         setContentView(R.layout.main);  
15.           
16.         AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);  
17.           
18.         PendingIntent pi = PendingIntent.getBroadcast(this, 0, new Intent(this, ActionBroadCast.class), Intent.FLAG_ACTIVITY_NEW_TASK);  
19.         long now = System.currentTimeMillis();  
20.         am.setInexactRepeating(AlarmManager.RTC_WAKEUP, now, 3000, pi);  
21.     }  
22. }  

这边用Repeating的方式。 每隔3秒发一条广播消息过去。RTC_WAKEUP的方式，保证即使手机休眠了，也依然会发广播消息。

最后看一下AndroidManifest文件，主要是注册一下Activity和BroadCast。  （实际使用中最好再加个filter，自己定义一个Action比较好）

[html]  view plain copy print ?

1. xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
3.     package="com.yfz"  
4.     android:versionCode="1"  
5.     android:versionName="1.0" >  
6.   
7.     <uses-sdk android:minSdkVersion="7" />  
8.   
9.     <application  
10.         android:icon="@drawable/ic_launcher"  
11.         android:label="@string/app_name" >  
12.         <activity  
13.             android:label="@string/app_name"  
14.             android:name=".AlarmTestActivity" >  
15.             <intent-filter >  
16.                 <action android:name="android.intent.action.MAIN" />  
17.   
18.                 <category android:name="android.intent.category.LAUNCHER" />  
19.             intent-filter>  
20.         activity>  
21.         <receiver  
22.             android:name="ActionBroadCast">  
23.               
24.         receiver>  
25.     application>  
26.   
27. manifest>  

Service的其实也差不多，只要在OnStart()方法中写需要执行的操作即可。

做了一个例子，包含了使用AlarmManager的所有三种方式。已经上传至CSDN，下载地址： http://download.csdn.net/detail/feng88724/3812718 。 截图：

就写这么多把。

定时任务:Java中Timer和TimerTask的使用

Java Swing

java.util.Timer定时器，实际上是个线程，定时调度所拥有的TimerTasks。
一个TimerTask实际上就是一个拥有run方法的类，需要定时执行的代码放到run方法体内，TimerTask一般是以匿名类的方式创建。

一个完整的Timer：

Java代码

1. java.util.Timer timer = new java.util.Timer(true);
2. // true 说明这个timer以daemon方式运行（优先级低，
3. // 程序结束timer也自动结束），注意，javax.swing
4. // 包中也有一个Timer类，如果import中用到swing包，
5. // 要注意名字的冲突。
6. TimerTask task = new TimerTask() {
7. public void run() {
8. ... //每次需要执行的代码放到这里面。
9. }
10. };
11. //以下是几种调度task的方法：
12. timer.schedule(task, time);
13. // time为Date类型：在指定时间执行一次。
14. timer.schedule(task, firstTime, period);
15. // firstTime为Date类型,period为long
16. // 从firstTime时刻开始，每隔period毫秒执行一次。
17. timer.schedule(task, delay)
18. // delay 为long类型：从现在起过delay毫秒执行一次
19. timer.schedule(task, delay, period)
20. // delay为long,period为long：从现在起过delay毫秒以后，每隔period
21. // 毫秒执行一次。

下面是一个完整的例子,由两个类组成,一个定制任务,一个调用java.util.Timer

定制任务:

Java代码

1. import java.util.Timer;
2. public class TimerTaskTest extends java.util.TimerTask{
3. @Override
4. public void run() {
5. // TODO Auto-generated method stub
6. System.out.println("start");
7. }
8. }

2.调用java.util.Timer

Java代码

1. import java.util.Timer;
2. public class Test {
3. public static void main(String[] args){
4. Timer timer = new Timer();
5. timer.schedule(new TimerTaskTest(), 1000, 2000);
6. }
7. }

根据上面的介绍,便可以在1秒后,每隔2秒执行一次程序