注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

东东的博客

江南烟雨,同大家一起分享

 
 
 

日志

 
 

PendingInent 与 AlarmManager  

2009-09-22 11:53:39|  分类: android相关 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

概要:本文通过对OPhone内置闹铃功能的简单介绍,来让开发者朋友们了解基于OPhone平台下客户/服务 模式的编程模型,以及如何使用OPhone系统提供的闹铃唤醒功能。与此同时,本文还对PendingIntent做一些简单的介绍,并通过实例程序来演 示如何通过PendingIntent将闹钟应用程序和系统闹铃服务联系起来。(作者:Yang Ai'in)

一、闹铃功能

        闹钟应用程序作为人们日常常用的基本应用程序之一,其重要性不言而喻。在OPhone系统中闹铃服务功能不仅仅对闹钟应用程序服务,最重要的是可以利用该 闹铃服务功能提供的唤醒能力来做定时器。这样即便应用程序没有运行或者是没有启动的情况下,只要其注册过闹铃,那么该闹铃到时间后,OPhone系统可以 自动将该应用程序启动,这就是所谓的闹铃“唤醒“功能。

        在OPhone系统中,底层系统提供了两种类型的时钟,软时钟与硬时钟,软时钟就是我们常说的Timer,硬时钟就是RTC。系统在正常运行的情况 下,Timer工作提供时间服务和闹铃提醒,而在系统进入睡眠状态后,时间服务和闹铃提醒由RTC来负责。对于上层应用来说,我们并不需要关心是 timer还是RTC为我们提供服务,因为OPhone系统的Framework层把底层细节做了封装并统一提供API。这个API他的名字就叫 AlarmManager。在OPhone系统中有意思的是对应AlarmManage有一个AlarmManagerServie服务程序,该服务程序 才是正真提供闹铃服务的,它主要维护应用程序注册下来的各类闹铃并适时的设置即将触发的闹铃给闹铃设备(在OPhone系统中,linux实现的设备名为 ”/dev/alarm”),并且一直监听闹铃设备,一旦有闹铃触发或者是闹铃事件发生,AlarmManagerServie服务程序就会遍历闹铃列表 找到相应的注册闹铃并发出广播。该服务程序在系统启动时被系统服务程序system_service启动并初始化闹铃设备(/dev/alarm)。当 然,在JAVA层的AlarmManagerService与Linux Alarm驱动程序接口之间还有一层封装,那就是JNI。

         AlarmManager将应用与服务分割开来后,使得应用程序开发者不用关心具体的服务,而是直接通过AlarmManager来使用这种服务。这也许 就是客户/服务模式的好处吧。AlarmManager与AlarmManagerServie之间是通过Binder来通信的,他们之间是多对一的关 系。在OPhone系统中,AlarmManage提供了3个接口5种类型的闹铃服务:

  •         3API调用接口:

   

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


  • 5种闹铃类型:

       

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

        开发者可以通过OPhone SDK来获取更多AlarmManager的相关细节,他所在的包是:Android.app.AlarmManager

        随着OPhone系统版本的不断的升级,这些接口和闹铃类型也许会有些调整,但其基本使用方法将不会改变

 

二、闹钟设置与提醒

        我们首先通过一个直观的UI来感受一下OPhone系统内嵌的闹钟程序是如何响应用户设置和自动提醒的的:(如下4个图所示)

(图一)(图二)

 

(图三) (图四)

 

         上面4图直观的告诉了开发者如何使用OPhone内嵌的闹钟应用程序,但开发者可能更关心的是通过代码如何实现这些功能。比如说怎么设置一个闹铃,该设置 哪种类型的闹铃,以及如何获得闹铃时间已到并提醒用户。依据这几个问题,我们在下面的章节中逐步来介绍。

2.1 设置闹铃

        在第一小节中,我们已经提到过OPhone系统AlarmManagerService提供了两个设置闹铃的API,他们分别是:

 

  1. void      set(int type, long triggerAtTime, PendingIntent operation)  
  2. void      setRepeating(int type, long triggerAtTime, long interval, PendingIntent operation)  
        void      set(int type, long triggerAtTime, PendingIntent operation)          void      setRepeating(int type, long triggerAtTime, long interval, PendingIntent operation)  

        在OPhone 1.5版本中又增加了一个API。
        下面的程序演示了如何设置一个闹铃。

 

  1. /当设置的闹铃触发时,Ophone系统会广播一个Intent,当然我们需要在创建一个新的闹铃  
  2.     //时注册一个闹铃事件接收对象AlarmReceiver ,该接收对象也可以通过在//AndroidManifest.xml中发布,也可以在代码中动态注册。  
  3.   
  4. import android.app.AlarmManager;  
  5. import android.app.PendingIntent;  
  6. import android.content.Intent;  
  7. import android.os.SystemClock;  
  8. import android.os.Bundle;  
  9. import java.util.Calendar;  
  10.   
  11. //创建一个PendingIntent  
  12. Intent intent = new Intent(ALARM_ALERT_ACTION);  
  13. intent.putExtra(ID, id);  
  14. intent.putExtra(TIME, atTimeInMillis);  
  15. PendingIntent sender = PendingIntent.getBroadcast(  
  16.                 context, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT);  
  17. //获得AlarmMnager并注册一个新闹铃,  
  18. //一次性闹铃的设置  
  19.   
  20. AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);  
  21. am.set(AlarmManager.POWER_OFF_WAKEUP, atTimeInMillis, sender);  
  22.   
  23. //重复性闹铃的设置  
  24. // We want the alarm to go off 30 seconds from now.  
  25. long firstTime = SystemClock.elapsedRealtime();  
  26.  firstTime += 15*1000;  
  27.   
  28. // Schedule the alarm!  
  29. AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);  
  30. am.setRepeating(AlarmManager.POWER_OFF_WAKEUP,  
  31.                             firstTime, 15*1000, sender);  
/当设置的闹铃触发时,Ophone系统会广播一个Intent,当然我们需要在创建一个新的闹铃   //时注册一个闹铃事件接收对象AlarmReceiver ,该接收对象也可以通过在//AndroidManifest.xml中发布,也可以在代码中动态注册。    import android.app.AlarmManager;  import android.app.PendingIntent;  import android.content.Intent;  import android.os.SystemClock;  import android.os.Bundle;  import java.util.Calendar;    //创建一个PendingIntent  Intent intent = new Intent(ALARM_ALERT_ACTION);  intent.putExtra(ID, id);  intent.putExtra(TIME, atTimeInMillis);  PendingIntent sender = PendingIntent.getBroadcast(                  context, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT);  //获得AlarmMnager并注册一个新闹铃,  //一次性闹铃的设置    AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);  am.set(AlarmManager.POWER_OFF_WAKEUP, atTimeInMillis, sender);    //重复性闹铃的设置  // We want the alarm to go off 30 seconds from now.  long firstTime = SystemClock.elapsedRealtime();   firstTime += 15*1000;    // Schedule the alarm!  AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);  am.setRepeating(AlarmManager.POWER_OFF_WAKEUP,                              firstTime, 15*1000, sender);

 

 

  1. //在AndroidManifest.xml中注册  
  2. <receiver android:name="AlarmReceiver">  
  3.             <intent-filter>  
  4.                <action android:name="com.android.alarmclock.ALARM_ALERT" />  
  5.             </intent-filter>  
  6.  </receiver>  
//在AndroidManifest.xml中注册  <receiver android:name="AlarmReceiver">              <intent-filter>                 <action android:name="com.android.alarmclock.ALARM_ALERT" />              </intent-filter>   </receiver>

 

 

  1. //在应用程序执行过程中注册  
  2.   
  3. AlarmReceiver mAlarmReceiver;  
  4. IntentFilter filter = new IntentFilter();  
  5. filter.addAction(“com.android.alarmclock.ALARM_ALERT”);  
  6. context.registerReceiver(mAlarmReceiver, filter);  
  7.   
  8. public class AlarmReceiver extends BroadcastReceiver {  
  9.     @Override  
  10.     public void onReceive(Context context, Intent intent) {  
  11.        
  12.    }  
  13. }  
//在应用程序执行过程中注册    AlarmReceiver mAlarmReceiver;  IntentFilter filter = new IntentFilter();  filter.addAction(“com.android.alarmclock.ALARM_ALERT”);  context.registerReceiver(mAlarmReceiver, filter);    public class AlarmReceiver extends BroadcastReceiver {      @Override      public void onReceive(Context context, Intent intent) {            }  }

 

2.2 闹铃提醒

        在OPhone系统中,当应用程序所设置的闹铃时间到了后,OPhone系统中的AlarmManagerService就会从系统底层获取一个闹铃事件 并从自己维护的队列中取出其匹配的闹铃,然后通过其应用注册的PendingIntent把该闹铃事件发送回给应用。

 

  1. PendingIntent.send();  
   PendingIntent.send();

        当我们的应用收到该Intent后就会启动相应的Activity来提醒用户闹铃时间到。
        程序代码如下:

 

  1. package com.android.alarmclock;  
  2. import android.content.Context;  
  3. import android.content.Intent;  
  4. import android.content.BroadcastReceiver;  
  5. import android.os.Handler;  
  6. import android.os.PowerManager;  
  7. import android.os.SystemClock;  
  8.   
  9. public class AlarmReceiver extends BroadcastReceiver {  
  10.     @Override  
  11.     public void onReceive(Context context, Intent intent) {  
  12.         long now = System.currentTimeMillis();  
  13.         int id = intent.getIntExtra(Alarms.ID, 0);  
  14.         long setFor = intent.getLongExtra(Alarms.TIME, 0);  
  15.         Intent fireAlarm = new Intent(context, AlarmAlert.class);  
  16.         fireAlarm.putExtra(Alarms.ID, id);  
  17.         fireAlarm.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
  18.         //启动一个新的UI对象来提醒  
  19.         context.startActivity(fireAlarm);  
  20.    }  
  21. }  
package com.android.alarmclock;  import android.content.Context;  import android.content.Intent;  import android.content.BroadcastReceiver;  import android.os.Handler;  import android.os.PowerManager;  import android.os.SystemClock;    public class AlarmReceiver extends BroadcastReceiver {      @Override      public void onReceive(Context context, Intent intent) {          long now = System.currentTimeMillis();          int id = intent.getIntExtra(Alarms.ID, 0);          long setFor = intent.getLongExtra(Alarms.TIME, 0);          Intent fireAlarm = new Intent(context, AlarmAlert.class);          fireAlarm.putExtra(Alarms.ID, id);          fireAlarm.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);          //启动一个新的UI对象来提醒          context.startActivity(fireAlarm);     }  }

 

三、PendingIntent

        在前面的章节中,我们在注册闹铃﹑发送闹铃事件的时候,有过一个重要的参数PendingIntent。这个PendingIntent可以说是 Intent的进一步封装,他既包含了Intent的描述又是Intent行为的执行(这种定义也许不太严格),如果将Intent比作成一个订单的 话,PendingIntent更像是一个下订单的人,因为它既要负责将订单发出去,也要负责订单发送后的处理,比如发送成功后要准备验收订单货物,发送 失败后要重发还是取消订单等操作。开发者可以通过调用getActivity(Context, int, Intent, int), getBroadcast(Context, int, Intent, int), getService(Context, int, Intent, int)函数来得到一个PendingIntent实例。

  1. public static PendingIntent getBroadcast(Context context, int requestCode, Intent intent, int flags)   
public static PendingIntent getBroadcast(Context context, int requestCode, Intent intent, int flags) 

        通过该函数获得的PendingIntent将会扮演一个广播的功能,就像调用 Context.sendBroadcast()函数一样。当系统通过它要发送一个intent时要采用广播的形式,并且在该intent中会包含相应的 intent接收对象,当然这个对象我们可以在创建PendingIntent的时候指定,也可以通过ACTION 和CATEGORY等描述让OPhone系统自动找到该行为处理对象。

        实例代码如下:

  1. Intent intent = new Intent(AlarmController.this, OneShotAlarm.class);  
  2. PendingIntent sender = PendingIntent.getBroadcast(AlarmController.this,  
  3.                     0, intent, 0);  
Intent intent = new Intent(AlarmController.this, OneShotAlarm.class);  PendingIntent sender = PendingIntent.getBroadcast(AlarmController.this,                      0, intent, 0);

 

  1. Public static PendingIntent getActivity(Context, int, Intent, int)  
Public static PendingIntent getActivity(Context, int, Intent, int)

        通过该函数获得的PendingIntent可以直接启动新的activity, 就像调用 Context.startActivity(Intent)一样.不过值得注意的是要想这个新的Activity不再是当前进程存在的Activity 时。我们在intent中必须使用Intent.FLAG_ACTIVITY_NEW_TASK.
         实例代码如下:

  1. // The PendingIntent to launch our activity if the user selects this notification  
  2.  PendingIntent contentIntent = PendingIntent.getActivity(this0,  
  3.                              new Intent(this, AlarmService.class), 0);  
// The PendingIntent to launch our activity if the user selects this notification   PendingIntent contentIntent = PendingIntent.getActivity(this, 0,                               new Intent(this, AlarmService.class), 0);

 

  1. public static PendingIntent getService(Context context, int requestCode, Intent intent, int flags)   
public static PendingIntent getService(Context context, int requestCode, Intent intent, int flags) 

        通过该函数获得的PengdingIntent可以直接启动新的Service,就像调用Context.startService()一样。
        实例代码如下:

  1. // Create an IntentSender that will launch our service, to be scheduled  
  2.   // with the alarm manager.  
  3.   mAlarmSender = PendingIntent.getService(AlarmService.this,  
  4.               0new Intent(AlarmService.this, AlarmService_Service.class), 0);  
  // Create an IntentSender that will launch our service, to be scheduled      // with the alarm manager.      mAlarmSender = PendingIntent.getService(AlarmService.this,                  0, new Intent(AlarmService.this, AlarmService_Service.class), 0);

四、PendingInent与 service

        在OPhone系统编程中,一个完整OPhone应用程序可以有4个需要创建的模块,他们分别是:
        Activity ,Broadcast intent Receiver,Service,Content Provider。Service作为一个OPhone应用程序组成部分,通常运行在系统后台,他与用户之间没有交互。像其他应用程序对象一样运行在所属 进程的主线程中。那么这就意味着它有可能进入长时间的运行等待而导致应用得不到用户的相应。所以在开发者设计程序的时候就要考虑,如果一个Service 要做一些长时间的数据处理时(比如播放MP3,或者是网络下载),就需要把该工作切换到自己的线程空间来执行。
       实例代码如下:

 

  1. import android.app.Notification;  
  2. import android.app.NotificationManager;  
  3. import android.app.PendingIntent;  
  4. import android.app.Service;  
  5. import android.content.Intent;  
  6. import android.os.Binder;  
  7. import android.os.IBinder;  
  8. import android.os.Parcel;  
  9. import android.os.RemoteException;  
  10. import android.widget.Toast;  
  11.   
  12. //定义一个 Service 对象  
  13. public class AlarmService_Service extends Service {  
  14.     NotificationManager mNM;  
  15.     public void onCreate() {  
  16.          //创建一个线程来运行Runnable  
  17.         Thread thr = new Thread(null, mTask, "AlarmService_Service");  
  18.         thr.start();  
  19.     }  
  20.     public void onDestroy() {  
  21.     }  
  22.     Runnable mTask = new Runnable() {  
  23.         public void run() {  
  24.             // 通常我们就可以在这里设计长时间运行的功能,  
  25.             long endTime = System.currentTimeMillis() + 15*1000;  
  26.             while (System.currentTimeMillis() < endTime) {  
  27.                 synchronized (mBinder) {  
  28.                     try {  
  29.                         mBinder.wait(endTime - System.currentTimeMillis());  
  30.                     } catch (Exception e) {  
  31.                     }  
  32.                 }  
  33.             }  
  34.   
  35.             // 停止Service  
  36.             AlarmService_Service.this.stopSelf();  
  37.         }  
  38.     };  
  39.   
  40.     //在编写Service代码时,可以不实现onStart,onStop等函数,但一定要实现onBind函数  
  41.     public IBinder onBind(Intent intent) {  
  42.         return mBinder;  
  43.     }  
  44.      /*  通过该对象可以与客户端通信 
  45.      */  
  46.     private final IBinder mBinder = new Binder() {  
  47.         @Override  
  48.         protected boolean onTransact(int code, Parcel data, Parcel reply,  
  49.                 int flags) throws RemoteException {  
  50.             return super.onTransact(code, data, reply, flags);  
  51.         }  
  52.     };  
  53. }  
import android.app.Notification;  import android.app.NotificationManager;  import android.app.PendingIntent;  import android.app.Service;  import android.content.Intent;  import android.os.Binder;  import android.os.IBinder;  import android.os.Parcel;  import android.os.RemoteException;  import android.widget.Toast;    //定义一个 Service 对象  public class AlarmService_Service extends Service {      NotificationManager mNM;      public void onCreate() {           //创建一个线程来运行Runnable          Thread thr = new Thread(null, mTask, "AlarmService_Service");          thr.start();      }      public void onDestroy() {      }      Runnable mTask = new Runnable() {          public void run() {              // 通常我们就可以在这里设计长时间运行的功能,              long endTime = System.currentTimeMillis() + 15*1000;              while (System.currentTimeMillis() < endTime) {                  synchronized (mBinder) {                      try {                          mBinder.wait(endTime - System.currentTimeMillis());                      } catch (Exception e) {                      }                  }              }                // 停止Service              AlarmService_Service.this.stopSelf();          }      };        //在编写Service代码时,可以不实现onStart,onStop等函数,但一定要实现onBind函数      public IBinder onBind(Intent intent) {          return mBinder;      }       /*  通过该对象可以与客户端通信       */      private final IBinder mBinder = new Binder() {          @Override    protected boolean onTransact(int code, Parcel data, Parcel reply,            int flags) throws RemoteException {              return super.onTransact(code, data, reply, flags);          }      };  }

 

小结:本篇文章主要介绍了如何使用AlarmManager的定时唤醒功能,以及各种闹铃的含义与API使用实 例,希望对读者朋友们在OPhone应用编程中,对AlarmManager的正确使用起到抛砖引玉的作用。同时我们还引入了一个重要的概念 PendingIntent,通过对PendingIntent参数的解析,相信读者朋友们对PendingIntent的使用有了一个基本的认识。

转自 http://ophonesdn.com/article/show/30

  评论这张
 
阅读(677)| 评论(0)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017