导语

广播机制在Android系统中,也不算是什么创新的东西。如果读者了解J2EE或者COM,就会知道,在J2EE中,提供了消息驱动Bean(Message-Driven Bean),用来实现应用程序各个组件之间的消息传递;而在COM中,提供了连接点(Connection Point)的概念,也是用来在应用程序各个组间间进行消息传递。无论是J2EE中的消息驱动Bean,还是COM中的连接点,或者Android系统的广播机制,它们的实现机理都是消息发布/订阅模式的事件驱动模型,消息的生产者发布事件,而使用者订阅感兴趣的事件。

Android系统中,广播(Broadcast)是在组件之间传播数据(Intent)的一种机制;这些组件甚至是可以位于不同的进程中,这样它就像Binder机制一样,起到进程间通信的作用;本文通过一个简单的例子来学习Android系统的广播机制,为后续分析广播机制的源代码作准备。在Android系统中,为什么需要广播机制呢?广播机制,本质上它就是一种组件间的通信方式,如果是两个组件位于不同的进程当中,那么可以用Binder机制来实现,如果两个组件是在同一个进程中,那么它们之间可以用来通信的方式就更多了,这样看来,广播机制似乎是多余的。然而,广播机制却是不可替代的,它和Binder机制不一样的地方在于,广播的发送者和接收者事先是不需要知道对方的存在的,这样带来的好处便是,系统的各个组件可以松耦合地组织在一起,这样系统就具有高度的可扩展性,容易与其它系统进行集成。

在软件工程中,是非常强调模块之间的高内聚低耦合性的,不然的话,随着系统越来越庞大,就会面临着越来越难维护的风险,最后导致整个项目的失败。Android应用程序的组织方式,可以说是把这种高内聚低耦合性的思想贯彻得非常透彻,在任何一个Activity中,都可以使用一个简单的Intent,通过startActivity或者startService,就可以把另外一个Activity或者Service启动起来为它服务,而且它根本上不依赖这个Activity或者Service的实现,只需要知道它的字符串形式的名字即可,而广播机制更绝,它连接收者的名字都不需要知道。

分析案例:

我们通过具体的例子来介绍Android系统的广播机制。在这个例子中,有一个Service,它在另外一个线程中实现了一个计数器服务,每隔一秒钟就自动加1,然后将结果不断地反馈给应用程序中的界面线程,而界面线程中的Activity在得到这个反馈后,就会把结果显示在界面上。

为什么要把计数器服务放在另外一个线程中进行呢?

我们可以把这个计数器服务想象成是一个耗时的计算型逻辑,如果放在界面线程中去实现,那么势必就会导致应用程序不能响应界面事件,最后导致应用程序产生ANR(Application Not Responding)问题。计数器线程为了把加1后的数字源源不断地反馈给界面线程,这时候就可以考虑使用广播机制了。

首先在Android源代码工程中创建一个Android应用程序工程,名字就称为Broadcast吧。这个应用程序工程定义了一个名为shy.luo.broadcast的package,这个例子的源代码主要就是实现在这里了。下面,将会逐一介绍这个package里面的文件。

1. 计数器的服务接口ICounterServicce :src/shy/luo/broadcast/ICounterService.Java

  1. package shy.luo.broadcast;
  2. public interface ICounterService {
  3. public void startCounter(int initVal);
  4. public void stopCounter();
  5. }  co
这个接口很简单,它只有两个成员函数,分别用来启动和停止计数器;启动计数时,还可以指定计数器的初始值。

2. 接着,我们来看一个应用程序的默认Activity的实现 :src/shy/luo/broadcast/MainActivity.java
  1. package shy.luo.broadcast;
  2. import android.app.Activity;
  3. import android.content.BroadcastReceiver;
  4. import android.content.ComponentName;
  5. import android.content.Context;
  6. import android.content.Intent;
  7. import android.content.IntentFilter;
  8. import android.content.ServiceConnection;
  9. import android.os.Bundle;
  10. import android.os.IBinder;
  11. import android.util.Log;
  12. import android.view.View;
  13. import android.view.View.OnClickListener;
  14. import android.widget.Button;
  15. import android.widget.TextView;
  16. public class MainActivity extends Activity implements OnClickListener {
  17. private final static String LOG_TAG = "shy.luo.broadcast.MainActivity";
  18. private Button startButton = null;
  19. private Button stopButton = null;
  20. private TextView counterText = null;
  21. private ICounterService counterService = null;
  22. @Override
  23. public void onCreate(Bundle savedInstanceState) {
  24. super.onCreate(savedInstanceState);
  25. setContentView(R.layout.main);
  26. startButton = (Button)findViewById(R.id.button_start);
  27. stopButton = (Button)findViewById(R.id.button_stop);
  28. counterText = (TextView)findViewById(R.id.textview_counter);
  29. startButton.setOnClickListener(this);
  30. stopButton.setOnClickListener(this);
  31. startButton.setEnabled(true);
  32. stopButton.setEnabled(false);
  33. Intent bindIntent = new Intent(MainActivity.this, CounterService.class);
  34. bindService(bindIntent, serviceConnection, Context.BIND_AUTO_CREATE);
  35. Log.i(LOG_TAG, "Main Activity Created.");
  36. }
  37. @Override
  38. public void onResume() {
  39. super.onResume();
  40. IntentFilter counterActionFilter = new IntentFilter(CounterService.BROADCAST_COUNTER_ACTION);
  41.    registerReceiver(counterActionReceiver, counterActionFilter);
  42. }
  43. @Override
  44. public void onPause() {
  45. super.onPause();
  46. unregisterReceiver(counterActionReceiver);
  47. }
  48. @Override
  49. public void onDestroy() {
  50. super.onDestroy();
  51. unbindService(serviceConnection);
  52. }
  53. @Override
  54. public void onClick(View v) {
  55. if(v.equals(startButton)) {
  56. if(counterService != null) {
  57. counterService.startCounter(0);
  58. startButton.setEnabled(false);
  59. stopButton.setEnabled(true);
  60. }
  61. } else if(v.equals(stopButton)) {
  62. if(counterService != null) {
  63. counterService.stopCounter();
  64. startButton.setEnabled(true);
  65. stopButton.setEnabled(false);
  66. }
  67. }
  68. }
  69. private BroadcastReceiver counterActionReceiver = new BroadcastReceiver(){
  70. public void onReceive(Context context, Intent intent) {
  71. int counter = intent.getIntExtra(CounterService.COUNTER_VALUE, 0);
  72. String text = String.valueOf(counter);
  73. counterText.setText(text);
  74. Log.i(LOG_TAG, "Receive counter event");
  75. }
  76. };
  77. private ServiceConnection serviceConnection = new ServiceConnection() {
  78. public void onServiceConnected(ComponentName className, IBinder service) {
  79. counterService = ((CounterService.CounterBinder)service).getService();
  80. Log.i(LOG_TAG, "Counter Service Connected");
  81. }
  82. public void onServiceDisconnected(ComponentName className) {
  83. counterService = null;
  84. Log.i(LOG_TAG, "Counter Service Disconnected");
  85. }
  86. };
  87. }  cop

1. MainActivity的实现也很简单,它在创建(onCreate)的时候,会调用bindService函数来把计数器服务(CounterService)启动起来。

2. 它的第二个参数serviceConnection是一个ServiceConnection实例, 计数器服务启动起来后,系统会调用这个实例的onServiceConnected函数将一个Binder对象传回来.

3. 通过调用这个Binder对象的getService函数,就可以获得计数器服务接口。这里,把这个计数器服务接口保存在MainActivity的counterService成员变量中。

4. 当我们调用unbindService停止计数器服务时,系统会调用这个实例的onServiceDisconnected函数告诉MainActivity,它与计数器服务的连接断开了。

注意,这里通过调用bindService函数来启动Service时,这个Service与启动它的Activity是位于同一个进程中,它不像我们在前面一篇文章Android系统在新进程中启动自定义服务过程(startService)的原理分析中所描述那样在新的进程中启动服务,后面我们再写一篇文章来分析bindService启动服务的过程。

1. 在MainActivity的onResume函数中,通过调用registerReceiver函数注册了一个广播接收器counterActionReceiver,它是一个BroadcastReceiver实例,并且指定了这个广播接收器只对CounterService.BROADCAST_COUNTER_ACTION类型的广播感兴趣。

2. 当CounterService发出一个CounterService.BROADCAST_COUNTER_ACTION类型的广播时,系统就会把这个广播发送到counterActionReceiver实例的onReceiver函数中去。在onReceive函数中,从参数intent中取出计数器当前的值,显示在界面上。

MainActivity界面上有两个按钮,分别是Start Counter和Stop Counter按钮,点击前者开始计数,而点击后者则停止计数。

计数器服务CounterService实现在src/shy/luo/broadcast/CounterService.java文件中:

  1. package shy.luo.broadcast;
  2. import android.app.Service;
  3. import android.content.Intent;
  4. import android.os.AsyncTask;
  5. import android.os.Binder;
  6. import android.os.IBinder;
  7. import android.util.Log;
  8. public class CounterService extends Service implements ICounterService {
  9. private final static String LOG_TAG = "shy.luo.broadcast.CounterService";
  10. public final static String BROADCAST_COUNTER_ACTION = "shy.luo.broadcast.COUNTER_ACTION";
  11. public final static String COUNTER_VALUE = "shy.luo.broadcast.counter.value";
  12. private boolean stop = false;
  13. private final IBinder binder = new CounterBinder();
  14. public class CounterBinder extends Binder {
  15. public CounterService getService() {
  16. return CounterService.this;
  17. }
  18. }
  19. @Override
  20. public IBinder onBind(Intent intent) {
  21. return binder;
  22. }
  23. @Override
  24. public void onCreate() {
  25. super.onCreate();
  26. Log.i(LOG_TAG, "Counter Service Created.");
  27. }
  28. @Override
  29. public void onDestroy() {
  30. Log.i(LOG_TAG, "Counter Service Destroyed.");
  31. }
  32. public void startCounter(int initVal) {
  33.  
  34. AsyncTask<Integer, Integer, Integer> task = new AsyncTask<Integer, Integer, Integer>() {
  35. @Override
  36. protected Integer doInBackground(Integer... vals) {
  37. Integer initCounter = vals[0];
  38. stop = false;
  39. while(!stop) {
  40. publishProgress(initCounter);
  41. try {
  42. Thread.sleep(1000);
  43. } catch (InterruptedException e) {
  44. e.printStackTrace();
  45. }
  46. initCounter++;
  47. }
  48. return initCounter;
  49. }
  50. @Override
  51. protected void onProgressUpdate(Integer... values) {
  52. super.onProgressUpdate(values);
  53. int counter = values[0];
  54. Intent intent = new Intent(BROADCAST_COUNTER_ACTION);
  55. intent.putExtra(COUNTER_VALUE, counter);
  56. sendBroadcast(intent);
  57. }
  58. @Override
  59. protected void onPostExecute(Integer val) {
  60. int counter = val;
  61. Intent intent = new Intent(BROADCAST_COUNTER_ACTION);
  62. intent.putExtra(COUNTER_VALUE, counter);
  63. sendBroadcast(intent);
  64. }
  65.  
  66. };
  67. task.execute(0);
  68. }
  69. public void stopCounter() {
  70. stop = true;
  71. }
  72. }
这个计数器服务实现了ICounterService接口。当这个服务被binderService函数启动时,系统会调用它的onBind函数,这个函数返回一个Binder对象给系统。上面我们说到,当MainActivity调用bindService函数来启动计数器服务器时,系统会调用MainActivity的ServiceConnection实例serviceConnection的onServiceConnected函数通知MainActivity,这个服务已经连接上了,并且会通过这个函数传进来一个Binder远程对象,这个Binder远程对象就是来源于这里的onBind的返回值了。

函数onBind返回的Binder对象是一个自定义的CounterBinder实例,它实现了一个getService成员函数。当系统通知MainActivity,计数器服务已经启动起来并且连接成功后,并且将这个Binder对象传给MainActivity时,MainActivity就会把这个Binder对象强制转换为CounterBinder实例,然后调用它的getService函数获得服务接口。这样,MainActivity就通过这个Binder对象和CounterService关联起来了。

当MainActivity调用计数器服务接口的startCounter函数时,计数器服务并不是直接进入计数状态,而是通过使用异步任务(AsyncTask)在后台线程中进行计数。这里为什么要使用异步任务来在后台线程中进行计数呢?前面我们说过,这个计数过程是一个耗时的计算型逻辑,不能把它放在界面线程中进行,因为这里的CounterService启动时,并没有在新的进程中启动,它与MainActivity一样,运行在应用程序的界面线程中,因此,这里需要使用异步任务在在后台线程中进行计数。

异步任务AsyncTask的具体用法可以参考官方文档http://developer.android.com/reference/android/os/AsyncTask.html。它的大概用法是:

1. 当我们调用异步任务实例的execute(task.execute)方法时,当前调用线程就返回了,系统启动一个后台线程来执行这个异步任务实例的doInBackground函数

2. 这个函数就是我们用来执行耗时计算的地方了,它会进入到一个循环中,每隔1秒钟就把计数器加1,然后进入休眠(Thread.sleep),醒过来,再重新这个计算过程。

2. 在计算的过程中,可以通过调用publishProgress函数来通知调用者当前计算的进度,好让调用者来更新界面,调用publishProgress函数的效果最终就是直入到这个异步任务实例的onProgressUpdate函数中,这里就可以把这个进度值以广播的形式(sendBroadcast)发送出去了,这里的进度值就定义为当前计数服务的计数值。

当MainActivity调用计数器服务接口的stopCounter函数时,会告诉函数doInBackground停止执行计数(stop = true),于是,函数doInBackground就退出计数循环,然后将最终计数结果返回了,返回的结果最后进入到onPostExecute函数中,这个函数同样通过广播的形式(sendBroadcast)把这个计数结果广播出去。

计算器服务就介绍到这里了,下面我们看看应用程序的配置文件AndroidManifest.xml:

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3. package="shy.luo.broadcast"
  4. android:versionCode="1"
  5. android:versionName="1.0">
  6. <application android:icon="@drawable/icon" android:label="@string/app_name">
  7. <activity android:name=".MainActivity"
  8. android:label="@string/app_name">
  9. <intent-filter>
  10. <action android:name="android.intent.action.MAIN" />
  11. <category android:name="android.intent.category.LAUNCHER" />
  12. </intent-filter>
  13. </activity>
  14. <service android:name=".CounterService"
  15. android:enabled="true">
  16. </service>
  17. </application>
  18. </manifest>
这个配置文件很简单,只是告诉系统,它有一个Activity和一个Service。

案例:

这样,使用广播的例子就介绍完了。回顾一下,使用广播的两个步骤:

1. 广播的接收者需要通过调用registerReceiver函数告诉系统,它对什么样的广播有兴趣,即指定IntentFilter,并且向系统注册广播接收器,即指定BroadcastReceiver:

  1. IntentFilter counterActionFilter = new IntentFilter(CounterService.BROADCAST_COUNTER_ACTION);
  2. registerReceiver(counterActionReceiver, counterActionFilter);
这里,指定感兴趣的广播就是CounterService.BROADCAST_COUNTER_ACTION了,而指定的广播接收器就是counterActonReceiver,它是一个c类型的实例。

这里注册就是IntentFilter 和 BroadcastReceiver 注册到AMS 中

2. 广播的发送者通过调用sendBroadcast函数来发送一个指定的广播,并且可以指定广播的相关参数:

  1. Intent intent = new Intent(BROADCAST_COUNTER_ACTION);
  2. intent.putExtra(COUNTER_VALUE, counter);
  3. sendBroadcast(intent)
这里,指定的广播为CounterService.BROADCAST_COUNTER_ACTION,并且附带的带参数当前的计数器值counter。调用了sendBroadcast函数之后,所有注册了CounterService.BROADCAST_COUNTER_ACTION广播的接收者便可以收到这个广播了。   






1. 在第1步中,广播的接收者把广播接收器注册到AMS中;

2. 在第2步中,广播的发送者同样是把广播发送到AMS中,由AMS去查找注册了这个广播的接收者,然后把广播分发给它们。

3. 在第2步的分发的过程,其实就是把这个广播转换成一个消息,然后放入到接收器所在的线程消息队列中去,最后就可以在消息循环中调用接收器的onReceive函数了。

4. 由于ActivityManagerService把这个广播放进接收器所在的线程消息队列后,就返回了,它不关心这个消息什么时候会被处理,因此,对广播的处理是异步的,即调用sendBroadcast时,这个函数不会等待这个广播被处理完后才返回。

下面,我们以一个序列图来总结一下,广播的注册和发送的过程:

虚线上面Step 1到Step 4步是注册广播接收器的过程,

其中Step 2通过LoadedApk.getReceiverDispatcher在LoadedApk内部创建了一个IIntentReceiver接口,并且传递给ActivityManagerService;

虚线下面的Step 5到Step 11是发送广播的过程,

在Step 8中,ActivityManagerService利用上面得到的IIntentReceiver远程接口,调用LoadedApk.performReceiver接口,LoadedApk.performReceiver接口通过ActivityThread.H接口的post函数将这个广播消息放入到ActivityThread的消息队列中去

最后这个消息在LoadedApk的Args.run函数中处理,LoadedApk.Args.run函数接着调用MainActivity.BroadcastReceiver的onReceive函数来最终处理这个广播。


0-Broadcast机制原理简要介绍的更多相关文章

  1. Android进程间通信(IPC)机制Binder简要介绍和学习计划

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/6618363 在Android系统中,每一个应用 ...

  2. Android进程间通信(IPC)机制Binder简要介绍和学习计划【转】

    本文转载自:http://blog.csdn.net/luoshengyang/article/details/6618363 在Android系统中,每一个应用程序都是由一些Activity和Ser ...

  3. python LEGB原理简要介绍

  4. [转]Android系统Surface机制的SurfaceFlinger服务简要介绍和学习计划

    转自:Android系统Surface机制的SurfaceFlinger服务简要介绍和学习计划 前面我们从Android应用程序与SurfaceFlinger服务的关系出发,从侧面简单学习了Surfa ...

  5. Android系统Surface机制的SurfaceFlinger服务简要介绍和学习计划

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/8010977 前面我们从Android应用程序与 ...

  6. Android应用程序组件Content Provider简要介绍和学习计划

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/6946067 在Android系统中,Conte ...

  7. Android应用程序的Activity启动过程简要介绍和学习计划

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/6685853 在Android系统中,Activ ...

  8. OAuth的机制原理讲解及开发流程

    本想前段时间就把自己通过QQ OAuth1.0.OAuth2.0协议进行验证而实现QQ登录的心得及Demo实例分享给大家,可一直很忙,今天抽点时间说下OAuth1.0协议原理,及讲解下QQ对于Oaut ...

  9. OAuth的机制原理讲解及开发流程(转)

    1.OAuth的简述 OAuth(Open Authorization,开放授权)是为用户资源的授权定义了一个安全.开放及简单的标准,第三方无需知道用户的账号及密码,就可获取到用户的授权信息,并且这是 ...

随机推荐

  1. package.json字段分析

    分析1.必须在包的顶层目录下2.二进制文件应该在bin目录下3.javascipt在lib目录下4.文档在doc目录下 package.json字段分析 name:包的名称,必须是唯一的,由小写英文字 ...

  2. php 获取 今天、昨天、这周、上周、这月、上月、近30天

    <?php //今天 $today = date("Y-m-d"); //昨天 $yesterday = date("Y-m-d", strtotime( ...

  3. Flask学习笔记:数据库迁移操作flask-script+alembic/flask-migrate

    数据库迁移是将代码中模型类(即表)的修改同步到数据库中, flask-sqlalchemy的模型类一旦使用create_all()映射到数据库中后,对这个模型类的修改(例如添加了一个新的字段)就不会再 ...

  4. Louis Armstrong【路易斯·阿姆斯特朗】

    Louis Armstrong Louis Armstrong had two famous nicknames. 路易斯·阿姆斯特朗有两个著名的绰号. Some people called him ...

  5. Disharmony Trees HDU - 3015

    Disharmony Trees HDU - 3015 One day Sophia finds a very big square. There are n trees in the square. ...

  6. 图论:HDU2544-最短路(最全、最经典的最短路入门及小结)

    最短路 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submis ...

  7. hdu 5667

    Sequence Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Su ...

  8. 牛客第四次多校Maximum Mode

    链接:https://www.nowcoder.com/acm/contest/142/G来源:牛客网 题目描述 The mode of an integer sequence is the valu ...

  9. Android广告页循环播放

    摘要:项目要求做一个广告页,实现几秒更换一次广告页,下方还有指示第几张广告页,同样也支持手动左滑或右滑. 1.准备好粘贴5个有关广告页的类. ①BaseViewPager==>自定义高度的Vie ...

  10. 图学java基础篇之并发

    概述 并发处理本身就是编程开发重点之一,同时内容也很繁杂,从底层指令处理到上层应用开发都要涉及,也是最容易出问题的地方.这块知识也是评价一个开发人员水平的重要指标,本人自认为现在也只是学其皮毛,因此本 ...