口腔医院东莞网站建设网站建设产品话术

在Android系统中，广播（Broadcast）是在组件之间传播数据（Intent）的一种机制；这些组件甚至是可以位于不同的进程中，这样它就像Binder机制一样，起到进程间通信的作用。

在Android系统中，为什么需要广播机制呢？如果是两个组件位于不同的进程当中，那么可以用Binder机制来实现，如果两个组件是在同一个进程中，那么它们之间可以用来通信的方式就更多了，这样看来，广播机制似乎是多余的。

然而，广播机制却是不可替代的，它和Binder机制不一样的地方在于，广播的发送者和接收者事先是不需要知道对方的存在的，这样带来的好处便是，系统的各个组件可以松耦合地组织在一起，这样系统就具有高度的可扩展性，容易与其它系统进行集成。

使用广播的两个步骤：
1、广播的接收者需要通过调用registerReceiver函数告诉系统，它对什么样的广播有兴趣，即指定IntentFilter，并且向系统注册广播接收器，即指定BroadcastReceiver：

IntentFilter counterActionFilter = new IntentFilter(CounterService.BROADCAST_COUNTER_ACTION);  
registerReceiver(counterActionReceiver, counterActionFilter);  

这里，指定感兴趣的广播就是CounterService.BROADCAST_COUNTER_ACTION了，而指定的广播接收器就是counterActonReceiver，它是一个BroadcastReceiver类型的实例。

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

Intent intent = new Intent(BROADCAST_COUNTER_ACTION);  
intent.putExtra(COUNTER_VALUE, counter);  
sendBroadcast(intent)  

这里，指定的广播为CounterService.BROADCAST_COUNTER_ACTION，并且附带的带参数当前的计数器值counter。调用了sendBroadcast函数之后，所有注册了CounterService.BROADCAST_COUNTER_ACTION广播的接收者便可以收到这个广播了。

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

在第2步的分发的过程，其实就是把这个广播转换成一个消息，然后放入到接收器所在的线程消息队列中去，最后就可以在消息循环中调用接收器的onReceive函数了。这里有一个要非常注意的地方是，由于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函数来最终处理这个广播。

注册广播接收器（registerReceiver）

在Android的广播机制中，ActivityManagerService扮演着广播中心的角色，负责系统中所有广播的注册和发布操作，因此，Android应用程序注册广播接收器的过程就把是广播接收器注册到ActivityManagerService的过程。Android应用程序是通过调用ContextWrapper类的registerReceiver函数来把广播接收器BroadcastReceiver注册到ActivityManagerService中去的，而ContextWrapper类本身又借助ContextImpl类来注册广播接收器。

在Android应用程序框架中，Activity和Service类都继承了ContextWrapper类，因此，我们可以在Activity或者Service的子类中调用registerReceiver函数来注册广播接收器。

我们先来看一下MainActivity是如何调用registerReceiver函数来注册广播接收器的：

public class MainActivity extends Activity implements OnClickListener {    ......  @Override     public void onResume() {    super.onResume();    IntentFilter counterActionFilter = new IntentFilter(CounterService.BROADCAST_COUNTER_ACTION);    registerReceiver(counterActionReceiver, counterActionFilter);    }   ......  }

Step 1. ContextWrapper.registerReceiver

public class ContextWrapper extends Context {  Context mBase;  ......  @Override  public Intent registerReceiver(  BroadcastReceiver receiver, IntentFilter filter) {  return mBase.registerReceiver(receiver, filter);  }  ......  }  

这里的成员变量mBase是一个ContextImpl实例。

Step 2. ContextImpl.registerReceiver

class ContextImpl extends Context {  ......  @Override  public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {  return registerReceiver(receiver, filter, null, null);  }  @Override  public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter,  String broadcastPermission, Handler scheduler) {  return registerReceiverInternal(receiver, filter, broadcastPermission,  scheduler, getOuterContext());  }  private Intent registerReceiverInternal(BroadcastReceiver receiver,  IntentFilter filter, String broadcastPermission,  Handler scheduler, Context context) {  IIntentReceiver rd = null;  if (receiver != null) {  if (mPackageInfo != null && context != null) {  if (scheduler == null) {  scheduler = mMainThread.getHandler();  }  rd = mPackageInfo.getReceiverDispatcher(  receiver, context, scheduler,  mMainThread.getInstrumentation(), true);  } else {  ......  }  }  try {  return ActivityManagerNative.getDefault().registerReceiver(  mMainThread.getApplicationThread(),  rd, filter, broadcastPermission);  } catch (RemoteException e) {  return null;  }  }  ......  }  

通过两个函数的中转，最终就进入到ContextImpl.registerReceiverInternal这个函数来了。这里的成员变量mPackageInfo是一个LoadedApk实例，它是用来负责处理广播的接收的。

参数broadcastPermission和scheduler都为null，而参数context是上面的函数通过调用函数getOuterContext得到的，这里它就是指向MainActivity了，因为MainActivity是继承于Context类的，因此，这里用Context类型来引用。

由于条件mPackageInfo != null和context != null都成立，而且条件scheduler == null也成立，于是就调用mMainThread.getHandler来获得一个Handler了，这个Hanlder是后面用来分发ActivityManagerService发送过的广播用的。这里的成员变量mMainThread是一个ActivityThread实例。

Step 3. ActivityThread.getHandler

public final class ActivityThread {  ......  final H mH = new H();  private final class H extends Handler {  ......  public void handleMessage(Message msg) {  ......  switch (msg.what) {  ......  }  ......  }  ......  }  ......  final Handler getHandler() {  return mH;  }  ......  }  

有了这个Handler之后，就可以分发消息给应用程序处理了。

再回到上一步的ContextImpl.registerReceiverInternal函数中，它通过mPackageInfo.getReceiverDispatcher函数获得一个IIntentReceiver接口对象rd，这是一个Binder对象，接下来会把它传给ActivityManagerService，ActivityManagerService在收到相应的广播时，就是通过这个Binder对象来通知MainActivity来接收的。

Step 4. LoadedApk.getReceiverDispatcher

final class LoadedApk {  ......  public IIntentReceiver getReceiverDispatcher(BroadcastReceiver r,  Context context, Handler handler,  Instrumentation instrumentation, boolean registered) {  synchronized (mReceivers) {  LoadedApk.ReceiverDispatcher rd = null;  HashMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher> map = null;  if (registered) {  map = mReceivers.get(context);  if (map != null) {  rd = map.get(r);  }  }  if (rd == null) {  rd = new ReceiverDispatcher(r, context, handler,  instrumentation, registered);  if (registered) {  if (map == null) {  map = new HashMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher>();  mReceivers.put(context, map);  }  map.put(r, rd);  }  } else {  rd.validate(context, handler);  }  return rd.getIIntentReceiver();  }  }  ......  static final class ReceiverDispatcher {  final static class InnerReceiver extends IIntentReceiver.Stub {  final WeakReference<LoadedApk.ReceiverDispatcher> mDispatcher;  ......  InnerReceiver(LoadedApk.ReceiverDispatcher rd, boolean strong) {  mDispatcher = new WeakReference<LoadedApk.ReceiverDispatcher>(rd);  ......  }  ......  }  ......  final IIntentReceiver.Stub mIIntentReceiver;  final Handler mActivityThread;  ......  ReceiverDispatcher(BroadcastReceiver receiver, Context context,  Handler activityThread, Instrumentation instrumentation,  boolean registered) {  ......  mIIntentReceiver = new InnerReceiver(this, !registered);  mActivityThread = activityThread;  ......  }  ....