android-BroadcastReceiver后台处理广播消息

aliounian

我们有时会遇到这样的情况，当手机处于睡眠状态时，到了某个时间点，我们需要做一些必要的事情。这是如何做到的呢？我们首先会想到闹钟，设置一个闹钟，到了设置的时间点，闹钟就会响。当然，还有很多其他的应用...
下面给出一个例子，方便学习和查阅

BroadcastReceiver

1. package com.android.test;
   
2. 
   
3. import android.app.Service;
   
4. import android.content.BroadcastReceiver;
   
5. import android.content.Context;
   
6. import android.content.Intent;
   
7. import android.os.PowerManager;
   
8. import android.util.Log;
   
9. 
   
10. public class TestUpdateReceiver extends BroadcastReceiver{
    
11.     private static final String TAG = "TestUpdateReceiver";
    
12.     private static final boolean DEBUG = true;
    
13.     
    
14.     static final Object mStartingServiceSync = new Object();
    
15.     static PowerManager.WakeLock mStartingService;
    
16.     
    
17.     private Context mContext = null;
    
18.     
    
19.     @SuppressWarnings("deprecation")
    
20.     @Override
    
21.     public void onReceive(Context context, Intent intent) {
    
22.         if(mContext == null) mContext = context;
    
23.         
    
24.         if(DEBUG){
    
25.             Log.v(TAG, "====================action=" + intent.getAction());
    
26.         }
    
27.             
    
28.         Intent i = new Intent();
    
29.         i.setClass(mContext, TestUpdateService.class);
    
30.         i.putExtras(intent);
    
31.         i.putExtra("action", intent.getAction());
    
32.         beginStartingService(mContext, i);
    
33.     }
    
34.     
    
35.     public static void beginStartingService(Context context, Intent intent) {
    
36.         synchronized (mStartingServiceSync) {
    
37.             if (mStartingService == null) {
    
38.                 PowerManager pm =
    
39.                     (PowerManager)context.getSystemService(Context.POWER_SERVICE);
    
40.                 mStartingService = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
    
41.                         "StartingAlertService");
    
42.                 mStartingService.setReferenceCounted(false);
    
43.             }
    
44.             mStartingService.acquire();
    
45.             context.startService(intent);
    
46.         }
    
47.     }
    
48. 
    
49.     /**
    
50.      * Called back by the service when it has finished processing notifications,
    
51.      * releasing the wake lock if the service is now stopping.
    
52.      */
    
53.     public static void finishStartingService(Service service, int startId) {
    
54.         synchronized (mStartingServiceSync) {
    
55.             if (mStartingService != null) {
    
56.                 if (service.stopSelfResult(startId)) {
    
57.                     mStartingService.release();
    
58.                 }
    
59.             }
    
60.         }
    
61.     }
    
62.     
    
63. }

同时启动一个服务

1. package com.android.test;
   
3. 
   
4. public class TestUpdateService extends Service{
   
5.     private static final String TAG = "TestUpdateService";
   
6.     private static final boolean DEBUG = true;
   
7.     
   
8.     @Override
   
9.     public IBinder onBind(Intent intent) {
   
10.         // TODO Auto-generated method stub
    
11.         return null;
    
12.     }
    
13. 
    
14.     private volatile Looper mServiceLooper = null;
    
15.     private volatile Handler mUpdateHandler;
    
16.     
    
17.     private class UpdateHandler extends Handler{
    
18.         
    
19.         public UpdateHandler(Looper looper) {
    
20.             super(looper);
    
21.         }
    
22.         @Override
    
23.         public void handleMessage(Message msg) {
    
24.             // TODO Auto-generated method stub
    
25.             processMessage(msg);
    
26.             
    
27.             TestUpdateReceiver.finishStartingService(TestUpdateService.this, msg.arg1);
    
28.         }
    
29.     }
    
30.     
    
31.     @Override
    
32.     public void onCreate() {
    
33.         // TODO Auto-generated method stub
    
34.         super.onCreate();
    
35.         mContext = this;
    
36.         
    
37.         HandlerThread thread = new HandlerThread("TestUpdateService");
    
38.         thread.start();
    
39.         mServiceLooper = thread.getLooper();
    
40.         mUpdateHandler = new UpdateHandler(mServiceLooper);
    
41.     }
42. 
    
43.     @Override
    
44.     public int onStartCommand(Intent intent, int flags, int startId) {
    
45.         // TODO Auto-generated method stub
    
46.         if(intent != null){
    
47.             Message msg = mUpdateHandler.obtainMessage();
    
48.             msg.obj = intent.getExtras();
    
49.             msg.arg1 = startId;
    
50.             mUpdateHandler.sendMessage(msg);
    
51.         }
    
52.         return START_REDELIVER_INTENT;
    
53.     }
    
54.   
55.     private void processMessage(Message msg){
    
56.         
    
57.         Bundle bundle = (Bundle) msg.obj;
    
58.         
    
59.         String action = bundle.getString("action");
    
60.         if(DEBUG){
    
61.             Log.v(TAG, "processMessage(Message msg)=================action=" + action);
    
62.         }
63. 
    
64.         /*在这里做你要做的事情*/
65.         /*在这里做你要做的事情*/
66.         /*在这里做你要做的事情*/
67.         
68.     }
69. 
    
70. }

原理是先设一个闹钟，等待闹钟发送广播，TestUpdateReceiver接收该广播，并获得PowerManager.WakeLock的一个实例mStartingService，并执行 mStartingService.acquire()，然后去做你想做的事情，最后执行mStartingService.release()把获得的lock释放掉。关于电源管理的知识，请查阅其他资料。

最后，不要忘了在配置文件里加相应的权限