您的位置: 首页  >  文章  >  Android中Activity、Service和线程之间的通信

Android中Activity、Service和线程之间的通信

分类: 文章 • 2024-10-21 19:55:16

原文地址：http://blog.****.net/wy819/article/details/51454769

Activity、Service和线程应该是Android编程中最常见的几种类了，几乎大多数应用程序都会涉及到这几个类的编程，自然而然的，也就会涉及到三者之间的相互通信，本文就试图简单地介绍一下这三者通信的方式。
想写这篇文章的起因是，笔者跟几个同学在做一个Android上的应用，起初代码写得很凌乱，因为我在Activity中直接创建了线程，去执行某些任务。但是我们知道线程可能需要运行的时间比较长，而Android在内存不足的时候，会将一些Activity销毁，这样线程就会失去了管理的对象，从而使程序发生意想不到的结果。此外，在Activity中创建线程，线程跟Activity的通信也比较麻烦，一般借助Handler类来进行通信（http://blog.sina.com.cn/s/blog_3fe961ae0100mvc5.html）。
与Activity相比，Service一般“默默”地运行在后台，生命周期比较长，所以它更合适去为主程序提供某些服务，创建线程并管理线程。因此，笔者将原程序改成三层架构，从高到低分别为：Activity层--Service层--Thread层。Activity将需要的服务“告诉”Service层，Service层创建Thread去完成服务。Thread将任务的进度、状态、错误信息反馈给Service，Service将这些消息反馈给相关的Activity，并且还可以利用Notification更新通知栏消息。大体的结构就是这样。

1 Activity和Service之间的通信
1.1 利用Handler通信：http://blog.sina.com.cn/s/blog_3fe961ae0100mvc5.html   ：
Android在子线程中更新Activity中UI的方法：
在Android平台下，进行多线程编程时，经常需要在主线程之外的一个单独的线程中进行某些处理，然后更新用户界面显示。但是，在主线线程之外的线程中直接更新页面显示的问题是：系统会报这个异常:ERROR/AndroidRuntime(1222):android.view.ViewRoot$CalledFromWrongThreadException: Only theoriginal thread that created a view hierarchy can touch itsviews.

或许编程人员会在线程中调用Toast.makeText()方法，试图在UI中显示某些提示信息，这样也会报如下的错误：

Can't create handler insidethread that has not called Looper.prepare()

解决方法：子线程中无法直接去更新Activity中的UI，一般的作法是子线程向Activity传递消息，然后Activity根据这些消息自己来更新UI。Android中有一个类叫android.os.Handler，就是用来做这件事的。

1. 在需要被线程更新UI的Activity 中声明一个android.os.Handler 类的变量，privateHandler handler;

2. onCreate函数中加入handler的初始化：

@Override

public void onCreate(Bundle savedInstanceState) {

//其他代码……

//……

//……

handler=new Handler(){

public void handleMessage(Message msg){

    

String message=(String)msg.obj;//obj不一定是String类，可以是别的类，看用户具体的应用

  //根据message中的信息对主线程的UI进行改动

  //……                                                     }

}

 };


另外Activity中需要提供handler的get函数，这样线程才能得到handler，进而传递消息。

 

public HandlergetHandler(){

returnthis.handler;

}

3.子线程类中需要持有表示上下文的Context类对象，实际应用中这个引用就是指向要更新UI的Activity对象，一般声明为：

private Contextctx;

然后在子线程类构造函数或其它函数中初始化ctx,这一步是为了能够得到Activity对象中的Handler对象。（或者用别的方法也行，只要子线程能得到Activity中的这个handler对象就可以。）

4. 最后一步，在子线程运行到某个地方，需要向Activity传递消息的时候，创建一个android.os.Message 类的对象，将要传送的对象加入message ，通过Handler发布传送给主线程，代码示例如下：

String str_temp="要传给主线程的消息"

Message message = Message.obtain();

message.obj=str_temp;

//通过Handler发布传送消息，handler

handler.sendMessage(message);

记住，这里的handler跟Activity中的handler是同一个对象噢，这样才是把消息送到那个Activity中了。

另外，这种方法不但可以让子线程更新UI，还可以有别的用途。现在我们假设子线程可能抛出某些错误，这个应该是很正常的，那么如何让错误信息能够让用户知道呢？很简单，在catch语句块中，将catch到的错误对象，放入message.obj中，传递给Activity，Activity中用Toast.makeText()方法将错误信息显示出来就可以了。




1.2 Activity调用startService (Intentservice)方法，将消息添加到Intent对象中，这样Service对象可以在调用onStartCommand (Intentintent, int flags, intstartId)的时候可以得到这些消息。这种方法很简单，但如果有大量的信息要传递的话，就很麻烦了。因为Service端还要判断一下消息是什么，才能作进一步的动作。

1.3 Activity调用bindService (Intentservice, ServiceConnection conn, intflags)方法，得到Service对象的一个引用，这样Activity可以直接调用到Service中的方法。具体代码：
http://blog.****.net/liuhe688/article/details/6623924。

通过服务更新进度通知&在Activity中监听服务进度

上次我们讲到如何实现一个可更新的进度通知，实现的方式是启动一个线程模拟一个下载任务，然后根据任务进度向UI线程消息队列发送进度消息，UI线程根据进度消息更新通知的UI界面。可是在实际应用中，我们一般会将上传、下载等比较耗时的后台任务以服务的形式运行，更新进度通知也是交由后台服务来完成的。 不过有的时候，除了在通知里面显示进度信息，我们也要在Activity中显示当前进度，很多下载系统都有这样的功能，例如Android自带浏览器的下载系统、QQ浏览器的下载系统等等。那么如何实现这一功能呢？实现方式有很多，我们今天先来介绍其中的一种：在Activity中主动监听服务的进度。

具体的思路是：让Activity与后台服务绑定，通过中间对象Binder的实例操作后台服务，获取进度信息和服务的状态以及在必要的时候停止服务。

关于服务的生命周期，如果有些朋友们不太熟悉的话，可以去查阅相关资料；如果以后有时间，我可能也会总结一些与服务相关的知识。

为了让大家对这个过程更清晰一些，在上代码之前，我们先来看看几个截图：

 Android中Activity、Service和线程之间的通信Android中Activity、Service和线程之间的通信

Android中Activity、Service和线程之间的通信Android中Activity、Service和线程之间的通信

整个过程如上图所示：在我们点击开始按钮后，下载任务开始运行，同事更新通知上的进度，当前Activity也从后台服务获取进度信息，显示到按钮下方；当我们点击通知后，跳转到下载管理界面，在这里我们也从后台服务获取进度，还可以做取消任务等操作。

了解了整个过程的情况后，我们就来分析一下具体的代码实现。

首先是/res/main.xml布局文件：

[html] view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:orientation="vertical"  
  4.     android:layout_width="fill_parent"  
  5.     android:layout_height="fill_parent">  
  6.     <Button  
  7.         android:layout_width="fill_parent"  
  8.         android:layout_height="wrap_content"  
  9.         android:text="start"  
  10.         android:onClick="start"/>  
  11.     <TextView  
  12.         android:id="@+id/text"  
  13.         android:layout_width="fill_parent"  
  14.         android:layout_height="wrap_content"  
  15.         android:gravity="center"/>  
  16. </LinearLayout>  

其中Button是用来启动服务的，TextView是用来显示进度信息的。

然后再在看一下MainActivity.Java的代码：

[java] view plain copy
  1. package com.scott.notification;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.ComponentName;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.ServiceConnection;  
  8. import android.os.Bundle;  
  9. import android.os.Handler;  
  10. import android.os.IBinder;  
  11. import android.os.Message;  
  12. import android.view.View;  
  13. import android.widget.TextView;  
  14.   
  15. public class MainActivity extends Activity {  
  16.   
  17.     private DownloadService.DownloadBinder binder;  
  18.     private TextView text;  
  19.       
  20.     private boolean binded;  
  21.   
  22.     private Handler handler = new Handler() {  
  23.         public void handleMessage(android.os.Message msg) {  
  24.             int progress = msg.arg1;  
  25.             text.setText("downloading..." + progress + "%");  
  26.         };  
  27.     };  
  28.   
  29.     private ServiceConnection conn = new ServiceConnection() {  
  30.   
  31.         @Override  
  32.         public void onServiceConnected(ComponentName name, IBinder service) {  
  33.             binder = (DownloadService.DownloadBinder) service;  
  34.             binded = true;  
  35.             // 开始下载  
  36.             binder.start();  
  37.             // 监听进度信息  
  38.             listenProgress();  
  39.         }  
  40.   
  41.         @Override  
  42.         public void onServiceDisconnected(ComponentName name) {  
  43.         }  
  44.     };  
  45.   
  46.     @Override  
  47.     public void onCreate(Bundle savedInstanceState) {  
  48.         super.onCreate(savedInstanceState);  
  49.         setContentView(R.layout.main);  
  50.         text = (TextView) findViewById(R.id.text);  
  51.     }  
  52.   
  53.     @Override  
  54.     protected void onDestroy() {  
  55.         super.onDestroy();  
  56.         if (binded) {  
  57.             unbindService(conn);              
  58.         }  
  59.     }  
  60.   
  61.     public void start(View view) {  
  62.         if (binded) {  
  63.             binder.start();  
  64.             listenProgress();  
  65.             return;  
  66.         }  
  67.         Intent intent = new Intent(this, DownloadService.class);  
  68.         startService(intent);   //如果先调用startService,则在多个服务绑定对象调用unbindService后服务仍不会被销毁  
  69.         bindService(intent, conn, Context.BIND_AUTO_CREATE);  
  70.     }  
  71.   
  72.     /** 
  73.      * 监听进度 
  74.      */  
  75.     private void listenProgress() {  
  76.         new Thread() {  
  77.             public void run() {  
  78.                 while (!binder.isCancelled() && binder.getProgress() <= 100) {  
  79.                     int progress = binder.getProgress();  
  80.                     Message msg = handler.obtainMessage();  
  81.                     msg.arg1 = progress;  
  82.                     handler.sendMessage(msg);  
  83.                     if (progress == 100) {  
  84.                         break;  
  85.                     }  
  86.                     try {  
  87.                         Thread.sleep(200);  
  88.                     } catch (InterruptedException e) {  
  89.                         e.printStackTrace();  
  90.                     }  
  91.                 }  
  92.             };  
  93.         }.start();  
  94.     }  
  95. }  
我们可以看到，当点击开始按钮后，以bindService的方式绑定服务，用获取到的DownloadService.DownloadBinder实例启动服务，并在Activity中启动一个线程监听服务的进度信息，及时的显示到按钮下方。

服务类DownloadService.java代码如下：

[java] view plain copy
  1. package com.scott.notification;  
  2.   
  3. import android.app.Notification;  
  4. import android.app.NotificationManager;  
  5. import android.app.PendingIntent;  
  6. import android.app.Service;  
  7. import android.content.Context;  
  8. import android.content.Intent;  
  9. import android.os.Binder;  
  10. import android.os.Handler;  
  11. import android.os.IBinder;  
  12. import android.os.Message;  
  13. import android.widget.RemoteViews;  
  14.   
  15. public class DownloadService extends Service {  
  16.   
  17.     private static final int NOTIFY_ID = 0;  
  18.     private boolean cancelled;  
  19.     private int progress;  
  20.   
  21.     private Context mContext = this;  
  22.   
  23.     private NotificationManager mNotificationManager;  
  24.     private Notification mNotification;  
  25.   
  26.     private DownloadBinder binder = new DownloadBinder();  
  27.   
  28.     private Handler handler = new Handler() {  
  29.         public void handleMessage(android.os.Message msg) {  
  30.             switch (msg.what) {  
  31.             case 1:  
  32.                 int rate = msg.arg1;  
  33.                 if (rate < 100) {  
  34.                     // 更新进度  
  35.                     RemoteViews contentView = mNotification.contentView;  
  36.                     contentView.setTextViewText(R.id.rate, rate + "%");  
  37.                     contentView.setProgressBar(R.id.progress, 100, rate, false);  
  38.                 } else {  
  39.                     // 下载完毕后变换通知形式  
  40.                     mNotification.flags = Notification.FLAG_AUTO_CANCEL;  
  41.                     mNotification.contentView = null;  
  42.                     Intent intent = new Intent(mContext, FileMgrActivity.class);  
  43.                     // 告知已完成  
  44.                     intent.putExtra("completed", "yes");  
  45.                     //更新参数,注意flags要使用FLAG_UPDATE_CURRENT  
  46.                     PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);  
  47.                     mNotification.setLatestEventInfo(mContext, "下载完成", "文件已下载完毕", contentIntent);  
  48.                     stopSelf();//停掉服务自身  
  49.                 }  
  50.   
  51.                 // 最后别忘了通知一下,否则不会更新  
  52.                 mNotificationManager.notify(NOTIFY_ID, mNotification);  
  53.                 break;  
  54.             case 0:  
  55.                 // 取消通知  
  56.                 mNotificationManager.cancel(NOTIFY_ID);  
  57.                 break;  
  58.             }  
  59.         };  
  60.     };  
  61.   
  62.     @Override  
  63.     public void onCreate() {  
  64.         super.onCreate();  
  65.         mNotificationManager = (NotificationManager) getSystemService(android.content.Context.NOTIFICATION_SERVICE);  
  66.     }  
  67.   
  68.     @Override  
  69.     public IBinder onBind(Intent intent) {  
  70.         // 返回自定义的DownloadBinder实例  
  71.         return binder;  
  72.     }  
  73.   
  74.     @Override  
  75.     public void onDestroy() {  
  76.         super.onDestroy();  
  77.         cancelled = true; // 取消下载线程  
  78.     }  
  79.       
  80.     /** 
  81.      * 创建通知 
  82.      */  
  83.     private void setUpNotification() {  
  84.         int icon = R.drawable.down;  
  85.         CharSequence tickerText = "开始下载";  
  86.         long when = System.currentTimeMillis();  
  87.         mNotification = new Notification(icon, tickerText, when);  
  88.   
  89.         // 放置在"正在运行"栏目中  
  90.         mNotification.flags = Notification.FLAG_ONGOING_EVENT;  
  91.   
  92.         RemoteViews contentView = new RemoteViews(mContext.getPackageName(), R.layout.download_notification_layout);  
  93.         contentView.setTextViewText(R.id.fileName, "AngryBird.apk");  
  94.         // 指定个性化视图  
  95.         mNotification.contentView = contentView;  
  96.   
  97.         Intent intent = new Intent(this, FileMgrActivity.class);  
  98.         PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);  
  99.         // 指定内容意图  
  100.         mNotification.contentIntent = contentIntent;  
  101.         mNotificationManager.notify(NOTIFY_ID, mNotification);  
  102.     }  
  103.   
  104.     /** 
  105.      * 下载模块 
  106.      */  
  107.     private void startDownload() {  
  108.         cancelled = false;  
  109.         int rate = 0;  
  110.         while (!cancelled && rate < 100) {  
  111.             try {  
  112.                 // 模拟下载进度  
  113.                 Thread.sleep(500);  
  114.                 rate = rate + 5;  
  115.             } catch (InterruptedException e) {  
  116.                 e.printStackTrace();  
  117.             }  
  118.             Message msg = handler.obtainMessage();  
  119.             msg.what = 1;  
  120.             msg.arg1 = rate;  
  121.             handler.sendMessage(msg);  
  122.   
  123.             this.progress = rate;  
  124.         }  
  125.         if (cancelled) {  
  126.             Message msg = handler.obtainMessage();  
  127.             msg.what = 0;  
  128.             handler.sendMessage(msg);  
  129.         }  
  130.     }  
  131.   
  132.     /** 
  133.      * DownloadBinder中定义了一些实用的方法 
  134.      *  
  135.      * @author user 
  136.      *  
  137.      */  
  138.     public class DownloadBinder extends Binder {  
  139.   
  140.         /** 
  141.          * 开始下载 
  142.          */  
  143.         public void start() {  
  144.             //将进度归零  
  145.             progress = 0;  
  146.             //创建通知  
  147.             setUpNotification();  
  148.             new Thread() {  
  149.                 public void run() {  
  150.                     //下载  
  151.                     startDownload();  
  152.                 };  
  153.             }.start();  
  154.         }  
  155.   
  156.         /** 
  157.          * 获取进度 
  158.          *  
  159.          * @return 
  160.          */  
  161.         public int getProgress() {  
  162.             return progress;  
  163.         }  
  164.   
  165.         /** 
  166.          * 取消下载 
  167.          */  
  168.         public void cancel() {  
  169.             cancelled = true;  
  170.         }  
  171.   
  172.         /** 
  173.          * 是否已被取消 
  174.          *  
  175.          * @return 
  176.          */  
  177.         public boolean isCancelled() {  
  178.             return cancelled;  
  179.         }  
  180.     }  
  181. }  

我们看到，在服务中有个DownloadBinder类，它继承自Binder，定义了一系列方法，获取服务状态以及操作当前服务，刚才我们在MainActivity中获取的就是这个类的实例。最后，不要忘了在AndroidManifest.xml中配置该服务。关于进度通知的布局文件/res/layout/download_notification_layout.xml，在这里就不需贴出了，朋友们可以参考一下Notification使用详解之二中进度通知布局的具体代码。

下面我们来介绍一下FileMgrActivity，它就是点击通知之后跳转到的界面，布局文件/res/filemgr.xml如下：

[html] view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:orientation="vertical"  
  4.     android:layout_width="fill_parent"  
  5.     android:layout_height="fill_parent">  
  6.     <ProgressBar   
  7.         android:id="@+id/progress"  
  8.         style="?android:attr/progressBarStyleHorizontal"  
  9.         android:layout_width="fill_parent"  
  10.         android:layout_height="wrap_content"  
  11.         android:max="100"  
  12.         android:progress="0"/>  
  13.     <Button  
  14.         android:id="@+id/cancel"  
  15.         android:layout_width="fill_parent"  
  16.         android:layout_height="wrap_content"  
  17.         android:text="cancel"  
  18.         android:onClick="cancel"/>  
  19. </LinearLayout>  

我们来看一下FileMgrActivity.java具体的代码：

[java] view plain copy
  1. package com.scott.notification;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.ComponentName;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.ServiceConnection;  
  8. import android.os.Bundle;  
  9. import android.os.Handler;  
  10. import android.os.IBinder;  
  11. import android.os.Message;  
  12. import android.view.View;  
  13. import android.widget.Button;  
  14. import android.widget.ProgressBar;  
  15.   
  16. public class FileMgrActivity extends Activity {  
  17.     private DownloadService.DownloadBinder binder;  
  18.     private ProgressBar progressBar;  
  19.     private Button cancel;  
  20.     private boolean binded;  
  21.       
  22.     private Handler handler = new Handler() {  
  23.         public void handleMessage(android.os.Message msg) {  
  24.             int progress = msg.arg1;  
  25.             progressBar.setProgress(progress);  
  26.             if (progress == 100) {  
  27.                 cancel.setEnabled(false);  
  28.             }  
  29.         };  
  30.     };  
  31.       
  32.     private ServiceConnection conn = new ServiceConnection() {  
  33.           
  34.         @Override  
  35.         public void onServiceConnected(ComponentName name, IBinder service) {  
  36.             binder = (DownloadService.DownloadBinder) service;  
  37.             //监听进度信息  
  38.             listenProgress();  
  39.         }  
  40.           
  41.         @Override  
  42.         public void onServiceDisconnected(ComponentName name) {  
  43.         }  
  44.     };  
  45.       
  46.     @Override  
  47.     public void onCreate(Bundle savedInstanceState) {  
  48.         super.onCreate(savedInstanceState);  
  49.         setContentView(R.layout.filemgr);  
  50.         progressBar = (ProgressBar) findViewById(R.id.progress);  
  51.         cancel = (Button) findViewById(R.id.cancel);  
  52.           
  53.         if ("yes".equals(getIntent().getStringExtra("completed"))) {  
  54.             //如果已完成,则不需再绑定service  
  55.             progressBar.setProgress(100);  
  56.               
  57.             cancel.setEnabled(false);  
  58.         } else {  
  59.             //绑定service  
  60.             Intent intent = new Intent(this, DownloadService.class);  
  61.             bindService(intent, conn, Context.BIND_AUTO_CREATE);  
  62.             binded = true;  
  63.         }  
  64.     }  
  65.       
  66.     @Override  
  67.     protected void onDestroy() {  
  68.         super.onDestroy();  
  69.         //如果是绑定状态,则取消绑定  
  70.         if (binded) {  
  71.             unbindService(conn);  
  72.         }  
  73.     }  
  74.       
  75.     public void cancel(View view) {  
  76.         //取消下载  
  77.         binder.cancel();  
  78.     }  
  79.   
  80.     /** 
  81.      * 监听进度信息 
  82.      */  
  83.     private void listenProgress() {  
  84.         new Thread() {  
  85.             public void run() {  
  86.                 while (!binder.isCancelled() && binder.getProgress() <= 100) {  
  87.                     int progress = binder.getProgress();  
  88.                     Message msg = handler.obtainMessage();  
  89.                     msg.arg1 = progress;  
  90.                     handler.sendMessage(msg);  
  91.                     try {  
  92.                         Thread.sleep(200);  
  93.                     } catch (InterruptedException e) {  
  94.                         e.printStackTrace();  
  95.                     }  
  96.                 }  
  97.             };  
  98.         }.start();  
  99.     }  
  100. }  

我们发现，它和MainActivity实现方式很相似，恩，他们都是通过和服务绑定后获取到的Binder对象来跟服务通信的，都是主动和服务打招呼来获取信息和控制服务的。

这两个Activity和一个Service似乎像是复杂的男女关系，两个男人同时喜欢一个女人，都通过自己的手段试图从那个女人获取爱情，两个男人都很主动，那个女人显得很被动。

以上就是今天的全部内容，也许朋友们会有疑问，能不能让Service主动告知Activity当前的进度信息呢？答案是可以。下一次，我就会和大家分享一下，如何变Service为主动方，让一个女人脚踏两只船的方式。



1.4Service向Activity发送消息，除了可以利用Handler外，还可以使用广播，当然Activity要注册相应的接收器。比如Service要向多个Activity发送同样的消息的话，用这种方法就更好。具体方法可以看一下这篇文章：
http://blog.****.net/liuhe688/article/details/6641806。

Notification使用详解之四：由后台服务向Activity发送进度信息

上次讲到了如何在Activity中监听后台服务的进度信息，实现的方式是让Activity与后台服务绑定，通过中间对象Binder的实例操作后台服务。从效果上来讲，这种方式是可行的，不过这种实现有个缺点，那就是Activity的任务太重了，为了监听服务的状态，我们不得不绑定服务，然后还需不断地定时的获取最新的进度，我们为何不换一下形式呢，让Service主动将进度发送给Activity，我们在Activity中只需拿到进度数据，然后更新UI界面。这种新形式就像上次结尾提到的，就像两个男人同时喜欢一个女人，都通过自己的手段试图从那个女人那里获取爱情，现在我们要让那个女人变为主动方，将爱情同时传递给那两个男人。

要实现以上方式，我们需要用到BroadcastReceiver，如果不太了解的朋友们，可以查阅相关资料补充一下。

关于整个流程的的截图，我在这里就不在贴出了，大家可以参看Notification详解之三的流程截图。布局文件也没有变化，所以这里也不在贴出。

我们主要看一下MainActivity、DownloadService、FileMgrActivity这几个组件的实现形式。

首先是MainActivity：

[java] view plain copy
  1. package com.scott.notification;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.BroadcastReceiver;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.IntentFilter;  
  8. import android.os.Bundle;  
  9. import android.view.View;  
  10. import android.widget.TextView;  
  11.   
  12. public class MainActivity extends Activity {  
  13.   
  14.     private MyReceiver receiver;  
  15.     private TextView text;  
  16.   
  17.     @Override  
  18.     public void onCreate(Bundle savedInstanceState) {  
  19.         super.onCreate(savedInstanceState);  
  20.         setContentView(R.layout.main);  
  21.         text = (TextView) findViewById(R.id.text);  
  22.           
  23.         receiver = new MyReceiver();  
  24.         IntentFilter filter = new IntentFilter();  
  25.         filter.addAction("android.intent.action.MY_RECEIVER");  
  26.         //注册  
  27.         registerReceiver(receiver, filter);  
  28.     }  
  29.       
  30.     @Override  
  31.     protected void onDestroy() {  
  32.         super.onDestroy();  
  33.         //不要忘了这一步  
  34.         unregisterReceiver(receiver);  
  35.     }  
  36.   
  37.     public void start(View view) {  
  38.         Intent intent = new Intent(this, DownloadService.class);  
  39.         //这里不再使用bindService,而使用startService  
  40.         startService(intent);  
  41.     }  
  42.   
  43.     /** 
  44.      * 广播接收器 
  45.      * @author user 
  46.      * 
  47.      */  
  48.     private class MyReceiver extends BroadcastReceiver {  
  49.   
  50.         @Override  
  51.         public void onReceive(Context context, Intent intent) {  
  52.             Bundle bundle = intent.getExtras();  
  53.             int progress = bundle.getInt("progress");  
  54.             text.setText("downloading..." + progress + "%");  
  55.         }  
  56.     }  
  57. }  

上面的代码中，我们的MyReceiver类是继承了BroadcastReceiver，在onReceive方法中，定义了收到进度信息并更新UI的逻辑，在onCreate中，我们注册了这个接受者，并指定action为Android.intent.action.MY_RECEIVER，如此一来，如果其他组件向这个指定的action发送消息，我们就能够接收到；另外要注意的是，不要忘了在Activity被摧毁的时候调用unregisterReceiver取消注册。

然后再来看一下DownloadService有什么变化：

[java] view plain copy
  1. package com.scott.notification;  
  2.   
  3. import android.app.Notification;  
  4. import android.app.NotificationManager;  
  5. import android.app.PendingIntent;  
  6. import android.app.Service;  
  7. import android.content.Context;  
  8. import android.content.Intent;  
  9. import android.os.Handler;  
  10. import android.os.IBinder;  
  11. import android.os.Message;  
  12. import android.widget.RemoteViews;  
  13.   
  14. public class DownloadService extends Service {  
  15.   
  16.     private static final int NOTIFY_ID = 0;  
  17.     private boolean cancelled;  
  18.       
  19.     private Context mContext = this;  
  20.     private NotificationManager mNotificationManager;  
  21.     private Notification mNotification;  
  22.       
  23.     private Handler handler = new Handler() {  
  24.         public void handleMessage(android.os.Message msg) {  
  25.             switch (msg.what) {  
  26.             case 1:  
  27.                 int rate = msg.arg1;  
  28.                 if (rate < 100) {  
  29.                     //更新进度  
  30.                     RemoteViews contentView = mNotification.contentView;  
  31.                     contentView.setTextViewText(R.id.rate, rate + "%");  
  32.                     contentView.setProgressBar(R.id.progress, 100, rate, false);  
  33.                 } else {  
  34.                     //下载完毕后变换通知形式  
  35.                     mNotification.flags = Notification.FLAG_AUTO_CANCEL;  
  36.                     mNotification.contentView = null;  
  37.                     Intent intent = new Intent(mContext, FileMgrActivity.class);  
  38.                     // 告知已完成  
  39.                     intent.putExtra("completed", "yes");  
  40.                     //更新参数,注意flags要使用FLAG_UPDATE_CURRENT  
  41.                     PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);  
  42.                     mNotification.setLatestEventInfo(mContext, "下载完成", "文件已下载完毕", contentIntent);  
  43.                 }  
  44.   
  45.                 // 最后别忘了通知一下,否则不会更新  
  46.                 mNotificationManager.notify(NOTIFY_ID, mNotification);  
  47.                   
  48.                 if (rate >= 100) {  
  49.                     stopSelf(); //停止服务  
  50.                 }  
  51.                   
  52.                 break;  
  53.             case 0:  
  54.                 // 取消通知  
  55.                 mNotificationManager.cancel(NOTIFY_ID);  
  56.                 break;  
  57.             }  
  58.         };  
  59.     };  
  60.       
  61.     @Override  
  62.     public void onCreate() {  
  63.         super.onCreate();  
  64.         mNotificationManager = (NotificationManager) getSystemService(android.content.Context.NOTIFICATION_SERVICE);  
  65.     }  
  66.       
  67.     @Override  
  68.     public void onStart(Intent intent, int startId) {  
  69.         super.onStart(intent, startId);  
  70.           
  71.         int icon = R.drawable.down;  
  72.         CharSequence tickerText = "开始下载";  
  73.         long when = System.currentTimeMillis();  
  74.         mNotification = new Notification(icon, tickerText, when);  
  75.   
  76.         // 放置在"正在运行"栏目中  
  77.         mNotification.flags = Notification.FLAG_ONGOING_EVENT;  
  78.   
  79.         RemoteViews contentView = new RemoteViews(mContext.getPackageName(), R.layout.download_notification_layout);  
  80.         contentView.setTextViewText(R.id.fileName, "AngryBird.apk");  
  81.         // 指定个性化视图  
  82.         mNotification.contentView = contentView;  
  83.   
  84.         Intent intnt = new Intent(this, FileMgrActivity.class);  
  85.         PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intnt, PendingIntent.FLAG_UPDATE_CURRENT);  
  86.         // 指定内容意图  
  87.         mNotification.contentIntent = contentIntent;  
  88.   
  89.         mNotificationManager.notify(NOTIFY_ID, mNotification);  
  90.           
  91.         new Thread() {  
  92.             public void run() {  
  93.                 startDownload();  
  94.             };  
  95.         }.start();  
  96.     }  
  97.       
  98.     @Override  
  99.     public void onDestroy() {  
  100.         super.onDestroy();  
  101.         cancelled = true;   //停止下载线程  
  102.     }  
  103.       
  104.     private void startDownload() {  
  105.         cancelled = false;  
  106.         int rate = 0;  
  107.         while (!cancelled && rate < 100) {  
  108.             try {  
  109.                 //模拟下载进度  
  110.                 Thread.sleep(500);  
  111.                 rate = rate + 5;  
  112.             } catch (InterruptedException e) {  
  113.                 e.printStackTrace();  
  114.             }  
  115.             Message msg = handler.obtainMessage();  
  116.             msg.what = 1;  
  117.             msg.arg1 = rate;  
  118.             handler.sendMessage(msg);  
  119.               
  120.             //发送特定action的广播  
  121.             Intent intent = new Intent();  
  122.             intent.setAction("android.intent.action.MY_RECEIVER");  
  123.             intent.putExtra("progress", rate);  
  124.             sendBroadcast(intent);  
  125.         }  
  126.         if (cancelled) {  
  127.             Message msg = handler.obtainMessage();  
  128.             msg.what = 0;  
  129.             handler.sendMessage(msg);  
  130.         }  
  131.     }  
  132.       
  133.     @Override  
  134.     public IBinder onBind(Intent intent) {  
  135.         return null;  
  136.     }  
  137. }  

可以看到，我们在onBind方法里不在返回自定义的Binder实例了，因为现在的Service和Activitys之间并没有绑定关系了，他们是独立的；在下载过程中，我们会调用sendBroadcast方法，向指定的action发送一个附带有进度信息的intent，这样的话，所有注册过action为android.intent.action.MY_RECEIVER的Activity都能收到这条进度消息了。

最后再来看一下FileMgrActivity：

[java] view plain copy
  1. package com.scott.notification;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.BroadcastReceiver;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.IntentFilter;  
  8. import android.os.Bundle;  
  9. import android.view.View;  
  10. import android.widget.ProgressBar;  
  11.   
  12. public class FileMgrActivity extends Activity {  
  13.       
  14.     private MyReceiver receiver;  
  15.     private ProgressBar progressBar;  
  16.       
  17.     @Override  
  18.     public void onCreate(Bundle savedInstanceState) {  
  19.         super.onCreate(savedInstanceState);  
  20.         setContentView(R.layout.filemgr);  
  21.         progressBar = (ProgressBar) findViewById(R.id.progress);  
  22.           
  23.         if ("yes".equals(getIntent().getStringExtra("completed"))) {  
  24.             progressBar.setProgress(100);  
  25.         }  
  26.           
  27.         receiver = new MyReceiver();  
  28.         IntentFilter filter = new IntentFilter();  
  29.         filter.addAction("android.intent.action.MY_RECEIVER");  
  30.         //注册  
  31.         registerReceiver(receiver, filter);  
  32.     }  
  33.       
  34.     public void cancel(View view) {  
  35.         Intent intent = new Intent(this, DownloadService.class);  
  36.         stopService(intent);  
  37.     }  
  38.       
  39.     @Override  
  40.     protected void onDestroy() {  
  41.         super.onDestroy();  
  42.         //不要忘了这一步  
  43.         unregisterReceiver(receiver);  
  44.     }  
  45.       
  46.     /** 
  47.      * 广播接收器 
  48.      * @author user 
  49.      * 
  50.      */  
  51.     private class MyReceiver extends BroadcastReceiver {  
  52.   
  53.         @Override  
  54.         public void onReceive(Context context, Intent intent) {  
  55.             Bundle bundle = intent.getExtras();  
  56.             int progress = bundle.getInt("progress");  
  57.             progressBar.setProgress(progress);  
  58.         }  
  59.     }  
  60.       
  61. }  

我们发现，FileMgrActivity的模式和MainActivity差不多，也是注册了相同的广播接收者，对于DownloadService来说自己是广播基站，MainActivity和FileMgrActivity就是听众，信号能够同时到达多个听众，对于代码而言，与之前的代码比较一下，发现简洁了许多，显然这种方式更好一些。

对于我们上面提到的男女关系，DownloadService就是那个女人，然后两个男人将自己的手机号告知了女人，等于注册了接收器，然后女人将短信群发给两个男人。不过在这种情况下，两个男人互相都不知道对方的存在，以为女人深深的爱着自己，等到发现一切的时候，就是痛苦的时候。相信大家如果遇到这种情况都会很痛苦吧，至于你们信不信，我反正是信的。哈哈。

其实关于Notification的讲解最后两篇涉及到Notification的不多，主要是围绕Notification做一些实际的应用示例，希望对于朋友们平时遇到的问题会有所帮助，如果这方面有了新的研究总结，我会再及时更新的，谢谢大家。


2 Service跟Thread之间的通信
2.1Service创建Thread后，如果要对线程进行控制（启动，暂停，停止等），那么Service中应该保留线程的引用，这不用多说。那么有了这个引用，Service就可以直接调用Thread的其它方法了。运行的线程要向Service发送消息的话，通常使用Handler就可以了：


3 Activity和Thread之间的通信
不用多想了，直接使用Handler吧。不推荐Activity直接去创建线程，因为不好管理线程。

相关推荐