播報：在Android系統中為什么需要廣播機制？

在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 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();                          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 mDispatcher;              ......                InnerReceiver(LoadedApk.ReceiverDispatcher rd, boolean strong) {mDispatcher = new WeakReference(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;                            ......          }            ......            IIntentReceiver getIIntentReceiver() {return mIIntentReceiver;          }        }        ......    }  

在LoadedApk.getReceiverDispatcher函數中，首先看一下參數r是不是已經有相應的ReceiverDispatcher存在了，如果有，就直接返回了，否則就新建一個ReceiverDispatcher，并且以r為Key值保在一個HashMap中，而這個HashMap以Context，這里即為MainActivity為Key值保存在LoadedApk的成員變量mReceivers中，這樣，只要給定一個Activity和BroadcastReceiver，就可以查看LoadedApk里面是否已經存在相應的廣播接收發布器ReceiverDispatcher了。

在新建廣播接收發布器ReceiverDispatcher時，會在構造函數里面創建一個InnerReceiver實例，這是一個Binder對象，實現了IIntentReceiver接口，可以通過ReceiverDispatcher.getIIntentReceiver函數來獲得，獲得后就會把它傳給ActivityManagerService，以便接收廣播。

在ReceiverDispatcher類的構造函數中，還會把傳進來的Handle類型的參數activityThread保存下來，以便后面在分發廣播的時候使用。

現在，再回到ContextImpl.registerReceiverInternal函數，在獲得了IIntentReceiver類型的Binder對象后，就開始要把它注冊到ActivityManagerService中去了。

Step 5. ActivityManagerProxy.registerReceiver

class ActivityManagerProxy implements IActivityManager  {......        public Intent registerReceiver(IApplicationThread caller,              IIntentReceiver receiver,              IntentFilter filter, String perm) throws RemoteException      {Parcel data = Parcel.obtain();          Parcel reply = Parcel.obtain();          data.writeInterfaceToken(IActivityManager.descriptor);          data.writeStrongBinder(caller != null ? caller.asBinder() : null);          data.writeStrongBinder(receiver != null ? receiver.asBinder() : null);          filter.writeToParcel(data, 0);          data.writeString(perm);          mRemote.transact(REGISTER_RECEIVER_TRANSACTION, data, reply, 0);          reply.readException();          Intent intent = null;          int haveIntent = reply.readInt();          if (haveIntent != 0) {intent = Intent.CREATOR.createFromParcel(reply);          }          reply.recycle();          data.recycle();          return intent;      }        ......    }  

這個函數通過Binder驅動程序就進入到ActivityManagerService中的registerReceiver函數中去了。

Step 6. ActivityManagerService.registerReceiver

public final class ActivityManagerService extends ActivityManagerNative          implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {......        public Intent registerReceiver(IApplicationThread caller,              IIntentReceiver receiver, IntentFilter filter, String permission) {synchronized(this) {ProcessRecord callerApp = null;              if (caller != null) {callerApp = getRecordForAppLocked(caller);                  if (callerApp == null) {......                  }              }                List allSticky = null;                // Look for any matching sticky broadcasts...              Iterator actions = filter.actionsIterator();              if (actions != null) {while (actions.hasNext()) {String action = (String)actions.next();                      allSticky = getStickiesLocked(action, filter, allSticky);                  }              } else {......              }                // The first sticky in the list is returned directly back to              // the client.              Intent sticky = allSticky != null ? (Intent)allSticky.get(0) : null;                ......                if (receiver == null) {return sticky;              }                ReceiverList rl                  = (ReceiverList)mRegisteredReceivers.get(receiver.asBinder());              if (rl == null) {rl = new ReceiverList(this, callerApp,                      Binder.getCallingPid(),                      Binder.getCallingUid(), receiver);                    if (rl.app != null) {rl.app.receivers.add(rl);                  } else {......                  }                  mRegisteredReceivers.put(receiver.asBinder(), rl);              }                BroadcastFilter bf = new BroadcastFilter(filter, rl, permission);              rl.add(bf);              ......              mReceiverResolver.addFilter(bf);                // Enqueue broadcasts for all existing stickies that match              // this filter.              if (allSticky != null) {......              }                return sticky;          }      }        ......    }  

函數首先是獲得調用registerReceiver函數的應用程序進程記錄塊：

ProcessRecord callerApp = null;     if (caller != null) {callerApp = getRecordForAppLocked(caller);  if (callerApp == null) {......         }     }  

這里得到的便是應用程序Broadcast的進程記錄塊了，MainActivity就是在里面啟動起來的。

List allSticky = null;       // Look for any matching sticky broadcasts...     Iterator actions = filter.actionsIterator();     if (actions != null) {while (actions.hasNext()) {String action = (String)actions.next();      allSticky = getStickiesLocked(action, filter, allSticky);  }     } else {......     }       // The first sticky in the list is returned directly back to     // the client.     Intent sticky = allSticky != null ? (Intent)allSticky.get(0) : null; 

這里傳進來的filter只有一個action，就是前面描述的CounterService.BROADCAST_COUNTER_ACTION了，這里先通過getStickiesLocked函數查找一下有沒有對應的sticky intent列表存在。什么是Sticky Intent呢？我們在最后一次調用sendStickyBroadcast函數來發送某個Action類型的廣播時，系統會把代表這個廣播的Intent保存下來，這樣，后來調用registerReceiver來注冊相同Action類型的廣播接收器，就會得到這個最后發出的廣播。這就是為什么叫做Sticky Intent了，這個最后發出的廣播雖然被處理完了，但是仍然被粘住在ActivityManagerService中，以便下一個注冊相應Action類型的廣播接收器還能繼承處理。

這里，假設我們不使用sendStickyBroadcast來發送CounterService.BROADCAST_COUNTER_ACTION類型的廣播，于是，這里得到的allSticky和sticky都為null了。

繼續往下看，這里傳進來的receiver不為null，于是，繼續往下執行：

ReceiverList rl  = (ReceiverList)mRegisteredReceivers.get(receiver.asBinder());     if (rl == null) {rl = new ReceiverList(this, callerApp,      Binder.getCallingPid(),      Binder.getCallingUid(), receiver);    if (rl.app != null) {rl.app.receivers.add(rl);  } else {......  }  mRegisteredReceivers.put(receiver.asBinder(), rl);     }  

這里其實就是把廣播接收器receiver保存一個ReceiverList列表中，這個列表的宿主進程是rl.app，這里就是MainActivity所在的進程了，在ActivityManagerService中，用一個進程記錄塊來表示這個應用程序進程，它里面有一個列表receivers，專門用來保存這個進程注冊的廣播接收器。接著，又把這個ReceiverList列表以receiver為Key值保存在ActivityManagerService的成員變量mRegisteredReceivers中，這些都是為了方便在收到廣播時，快速找到對應的廣播接收器的。

再往下看：

BroadcastFilter bf = new BroadcastFilter(filter, rl, permission);  rl.add(bf);  ......  mReceiverResolver.addFilter(bf); 

上面只是把廣播接收器receiver保存起來了，但是還沒有把它和filter關聯起來，這里就創建一個BroadcastFilter來把廣播接收器列表rl和filter關聯起來，然后保存在ActivityManagerService中的成員變量mReceiverResolver中去。

發送廣播（sendBroadcast）的過程分析

前面我們分析了Android應用程序注冊廣播接收器的過程，這個過程只完成了萬里長征的第一步，接下來它還要等待ActivityManagerService將廣播分發過來。

廣播的發送過程比廣播接收器的注冊過程要復雜得多了，不過這個過程仍然是以ActivityManagerService為中心。廣播的發送者將廣播發送到ActivityManagerService，ActivityManagerService接收到這個廣播以后，就會在自己的注冊中心查看有哪些廣播接收器訂閱了該廣播，然后把這個廣播逐一發送到這些廣播接收器中，但是ActivityManagerService并不等待廣播接收器處理這些廣播就返回了，因此，廣播的發送和處理是異步的。

在分析廣播的發送過程前，我們先來看一下廣播發送過程的序列圖，然后按照這個序圖中的步驟來一步一步分析整個過程。

Step 1. ContextWrapper.sendBroadcast

public class ContextWrapper extends Context {Context mBase;        ......        @Override      public void sendBroadcast(Intent intent) {mBase.sendBroadcast(intent);      }        ......    }  

Step 2. ContextImpl.sendBroadcast

class ContextImpl extends Context {......        @Override      public void sendBroadcast(Intent intent) {String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());          try {ActivityManagerNative.getDefault().broadcastIntent(                  mMainThread.getApplicationThread(), intent, resolvedType, null,                  Activity.RESULT_OK, null, null, null, false, false);          } catch (RemoteException e) {}      }        ......    }  

這里的resolvedType表示這個Intent的MIME類型，我們沒有設置這個Intent的MIME類型，因此，這里的resolvedType為null。接下來就調用ActivityManagerService的遠程接口ActivityManagerProxy把這個廣播發送給ActivityManagerService了。

Step 3. ActivityManagerProxy.broadcastIntent

class ActivityManagerProxy implements IActivityManager  {......        public int broadcastIntent(IApplicationThread caller,          Intent intent, String resolvedType,  IIntentReceiver resultTo,          int resultCode, String resultData, Bundle map,          String requiredPermission, boolean serialized,          boolean sticky) throws RemoteException      {Parcel data = Parcel.obtain();          Parcel reply = Parcel.obtain();          data.writeInterfaceToken(IActivityManager.descriptor);          data.writeStrongBinder(caller != null ? caller.asBinder() : null);          intent.writeToParcel(data, 0);          data.writeString(resolvedType);          data.writeStrongBinder(resultTo != null ? resultTo.asBinder() : null);          data.writeInt(resultCode);          data.writeString(resultData);          data.writeBundle(map);          data.writeString(requiredPermission);          data.writeInt(serialized ? 1 : 0);          data.writeInt(sticky ? 1 : 0);          mRemote.transact(BROADCAST_INTENT_TRANSACTION, data, reply, 0);          reply.readException();          int res = reply.readInt();          reply.recycle();          data.recycle();          return res;      }        ......    }  

Step 4. ActivityManagerService.broadcastIntent

public final class ActivityManagerService extends ActivityManagerNative          implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {......        public final int broadcastIntent(IApplicationThread caller,              Intent intent, String resolvedType, IIntentReceiver resultTo,              int resultCode, String resultData, Bundle map,              String requiredPermission, boolean serialized, boolean sticky) {synchronized(this) {intent = verifyBroadcastLocked(intent);                final ProcessRecord callerApp = getRecordForAppLocked(caller);              final int callingPid = Binder.getCallingPid();              final int callingUid = Binder.getCallingUid();              final long origId = Binder.clearCallingIdentity();              int res = broadcastIntentLocked(callerApp,                  callerApp != null ? callerApp.info.packageName : null,                  intent, resolvedType, resultTo,                  resultCode, resultData, map, requiredPermission, serialized,                  sticky, callingPid, callingUid);              Binder.restoreCallingIdentity(origId);              return res;          }      }        ......  }  

這里調用broadcastIntentLocked函數來進一步處理。

Step 5. ActivityManagerService.broadcastIntentLocked

public final class ActivityManagerService extends ActivityManagerNative          implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {......        private final int broadcastIntentLocked(ProcessRecord callerApp,              String callerPackage, Intent intent, String resolvedType,              IIntentReceiver resultTo, int resultCode, String resultData,              Bundle map, String requiredPermission,              boolean ordered, boolean sticky, int callingPid, int callingUid) {intent = new Intent(intent);            ......            // Figure out who all will receive this broadcast.          List receivers = null;          List registeredReceivers = null;          try {if (intent.getComponent() != null) {......              } else {......                  registeredReceivers = mReceiverResolver.queryIntent(intent, resolvedType, false);              }          } catch (RemoteException ex) {......          }            final boolean replacePending =              (intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;            int NR = registeredReceivers != null ? registeredReceivers.size() : 0;          if (!ordered && NR > 0) {// If we are not serializing this broadcast, then send the              // registered receivers separately so they don"t wait for the              // components to be launched.              BroadcastRecord r = new BroadcastRecord(intent, callerApp,                  callerPackage, callingPid, callingUid, requiredPermission,                  registeredReceivers, resultTo, resultCode, resultData, map,                  ordered, sticky, false);              ......              boolean replaced = false;              if (replacePending) {for (int i=mParallelBroadcasts.size()-1; i>=0; i--) {if (intent.filterEquals(mParallelBroadcasts.get(i).intent)) {......                          mParallelBroadcasts.set(i, r);                          replaced = true;                          break;                      }                  }              }                if (!replaced) {mParallelBroadcasts.add(r);                    scheduleBroadcastsLocked();              }                registeredReceivers = null;              NR = 0;          }            ......        }        ......  }  

這個函數首先是根據intent找出相應的廣播接收器：

// Figure out who all will receive this broadcast.     List receivers = null;     List registeredReceivers = null;     try {if (intent.getComponent() != null) {......  } else {......      registeredReceivers = mReceiverResolver.queryIntent(intent, resolvedType, false);  }     } catch (RemoteException ex) {......     }  

回憶一下前面過程分析中的Step 6（ActivityManagerService.registerReceiver）中，我們將一個filter類型為BROADCAST_COUNTER_ACTION類型的BroadcastFilter實例保存在了ActivityManagerService的成員變量mReceiverResolver中，這個BroadcastFilter實例包含了我們所注冊的廣播接收器，這里就通過mReceiverResolver.queryIntent函數將這個BroadcastFilter實例取回來。由于注冊一個廣播類型的接收器可能有多個，所以這里把所有符合條件的的BroadcastFilter實例放在一個List中，然后返回來。在我們這個場景中，這個List就只有一個BroadcastFilter實例了，就是MainActivity注冊的那個廣播接收器。

繼續往下看：

final boolean replacePending =  (intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;  

這里是查看一下這個intent的Intent.FLAG_RECEIVER_REPLACE_PENDING位有沒有設置，如果設置了的話，ActivityManagerService就會在當前的系統中查看有沒有相同的intent還未被處理，如果有的話，就有當前這個新的intent來替換舊的intent。這里，我們沒有設置intent的Intent.FLAG_RECEIVER_REPLACE_PENDING位，因此，這里的replacePending變量為false。

再接著往下看：

int NR = registeredReceivers != null ? registeredReceivers.size() : 0;    if (!ordered && NR > 0) {// If we are not serializing this broadcast, then send the  // registered receivers separately so they don"t wait for the  // components to be launched.  BroadcastRecord r = new BroadcastRecord(intent, callerApp,      callerPackage, callingPid, callingUid, requiredPermission,      registeredReceivers, resultTo, resultCode, resultData, map,      ordered, sticky, false);  ......  boolean replaced = false;  if (replacePending) {for (int i=mParallelBroadcasts.size()-1; i>=0; i--) {if (intent.filterEquals(mParallelBroadcasts.get(i).intent)) {......              mParallelBroadcasts.set(i, r);              replaced = true;              break;          }      }  }    if (!replaced) {mParallelBroadcasts.add(r);        scheduleBroadcastsLocked();  }    registeredReceivers = null;  NR = 0;     }  

前面我們說到，這里得到的列表registeredReceivers的大小為1，且傳進來的參數ordered為false，表示要將這個廣播發送給所有注冊了BROADCAST_COUNTER_ACTION類型廣播的接收器，因此，會執行下面的if語句。這個if語句首先創建一個廣播記錄塊BroadcastRecord，里面記錄了這個廣播是由誰發出的以及要發給誰等相關信息。由于前面得到的replacePending變量為false，因此，不會執行接下來的if語句，即不會檢查系統中是否有相同類型的未處理的廣播。

這樣，這里得到的replaced變量的值也為false，于是，就會把這個廣播記錄塊r放在ActivityManagerService的成員變量mParcelBroadcasts中，等待進一步處理；進一步處理的操作由函數scheduleBroadcastsLocked進行。

Step 6. ActivityManagerService.scheduleBroadcastsLocked

public final class ActivityManagerService extends ActivityManagerNative          implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {......        private final void scheduleBroadcastsLocked() {......            if (mBroadcastsScheduled) {return;          }            mHandler.sendEmptyMessage(BROADCAST_INTENT_MSG);          mBroadcastsScheduled = true;      }        ......  }  

這里的mBroadcastsScheduled表示ActivityManagerService當前是不是正在處理其它廣播，如果是的話，這里就先不處理直接返回了，保證所有廣播串行處理。

注意這里處理廣播的方式，它是通過消息循環來處理，每當ActivityManagerService接收到一個廣播時，它就把這個廣播放進自己的消息隊列去就完事了，根本不管這個廣播后續是處理的，因此，這里我們可以看出廣播的發送和處理是異步的。

這里的成員變量mHandler是一個在ActivityManagerService內部定義的Handler類變量，通過它的sendEmptyMessage函數把一個類型為BROADCAST_INTENT_MSG的空消息放進ActivityManagerService的消息隊列中去。這里的空消息是指這個消息除了有類型信息之外，沒有任何其它額外的信息，因為前面已經把要處理的廣播信息都保存在mParcelBroadcasts中了，等處理這個消息時，從mParcelBroadcasts就可以讀回相關的廣播信息了，因此，這里不需要把廣播信息再放在消息內容中。

Step 7. Handler.sendEmptyMessage

這個自定義的Handler類實現在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中，它是ActivityManagerService的內部類，調用了它的sendEmptyMessage函數來把一個消息放到消息隊列后，一會就會調用它的handleMessage函數來真正處理這個消息：

public final class ActivityManagerService extends ActivityManagerNative          implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {......        final Handler mHandler = new Handler() {public void handleMessage(Message msg) {switch (msg.what) {......              case BROADCAST_INTENT_MSG: {......                  processNextBroadcast(true);              } break;              ......              }          }      }        ......  }   

這里又調用了ActivityManagerService的processNextBroadcast函數來處理下一個未處理的廣播。

Step 8. ActivityManagerService.processNextBroadcast

public final class ActivityManagerService extends ActivityManagerNative          implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {......        private final void processNextBroadcast(boolean fromMsg) {synchronized(this) {BroadcastRecord r;                ......                if (fromMsg) {mBroadcastsScheduled = false;              }                // First, deliver any non-serialized broadcasts right away.              while (mParallelBroadcasts.size() > 0) {r = mParallelBroadcasts.remove(0);                  ......                  final int N = r.receivers.size();                  ......                  for (int i=0; iObject target = r.receivers.get(i);                      ......                        deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false);                  }                  addBroadcastToHistoryLocked(r);                  ......              }                ......            }      }        ......  }  

這里傳進來的參數fromMsg為true，于是把mBroadcastScheduled重新設為false，這樣，下一個廣播就能進入到消息隊列中進行處理了。前面我們在Step 5中，把一個廣播記錄塊BroadcastRecord放在了mParallelBroadcasts中，因此，這里就把它取出來進行處理了。廣播記錄塊BroadcastRecord的receivers列表中包含了要接收這個廣播的目標列表，即前面我們注冊的廣播接收器，用BroadcastFilter來表示，這里while循環中的for循環就是把這個廣播發送給每一個訂閱了該廣播的接收器了，通過deliverToRegisteredReceiverLocked函數執行。

Step 9. ActivityManagerService.deliverToRegisteredReceiverLocked

public final class ActivityManagerService extends ActivityManagerNative          implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {......        private final void deliverToRegisteredReceiverLocked(BroadcastRecord r,              BroadcastFilter filter, boolean ordered) {boolean skip = false;          if (filter.requiredPermission != null) {......          }          if (r.requiredPermission != null) {......          }            if (!skip) {// If this is not being sent as an ordered broadcast, then we              // don"t want to touch the fields that keep track of the current              // state of ordered broadcasts.              if (ordered) {......              }                try {......                  performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,                      new Intent(r.intent), r.resultCode,                      r.resultData, r.resultExtras, r.ordered, r.initialSticky);                  ......              } catch (RemoteException e) {......              }          }        }        ......  }  

函數首先是檢查一下廣播發送和接收的權限，在我們分析的這個場景中，沒有設置權限，因此，這個權限檢查就跳過了，這里得到的skip為false，于是進入下面的if語句中。由于上面傳時來的ordered參數為false，因此，直接就調用performReceiveLocked函數來進一步執行廣播發送的操作了。

Step 10. ActivityManagerService.performReceiveLocked

public final class ActivityManagerService extends ActivityManagerNative          implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {......        static void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,              Intent intent, int resultCode, String data, Bundle extras,              boolean ordered, boolean sticky) throws RemoteException {// Send the intent to the receiver asynchronously using one-way binder calls.          if (app != null && app.thread != null) {// If we have an app thread, do the call through that so it is              // correctly ordered with other one-way calls.              app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,                      data, extras, ordered, sticky);          } else {......          }      }        ......  }  

注意，這里傳進來的參數app是注冊廣播接收器的Activity所在的進程記錄塊，在我們分析的這個場景中，由于是MainActivity調用registerReceiver函數來注冊這個廣播接收器的，因此，參數app所代表的ProcessRecord就是MainActivity所在的進程記錄塊了；

而參數receiver也是注冊廣播接收器時傳給ActivityManagerService的一個Binder對象，它的類型是IIntentReceiver。

MainActivity在注冊廣播接收器時，已經把自己的ProcessRecord記錄下來了，所以這里的參數app和app.thread均不為null，于是，ActivityManagerService就調用app.thread.scheduleRegisteredReceiver函數來把這個廣播分發給MainActivity了。這里的app.thread是一個Binder遠程對象，它的類型是ApplicationThreadProxy。

Step 11. ApplicationThreadProxy.scheduleRegisteredReceiver

class ApplicationThreadProxy implements IApplicationThread {......        public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,              int resultCode, String dataStr, Bundle extras, boolean ordered, boolean sticky)              throws RemoteException {Parcel data = Parcel.obtain();          data.writeInterfaceToken(IApplicationThread.descriptor);          data.writeStrongBinder(receiver.asBinder());          intent.writeToParcel(data, 0);          data.writeInt(resultCode);          data.writeString(dataStr);          data.writeBundle(extras);          data.writeInt(ordered ? 1 : 0);          data.writeInt(sticky ? 1 : 0);          mRemote.transact(SCHEDULE_REGISTERED_RECEIVER_TRANSACTION, data, null,              IBinder.FLAG_ONEWAY);          data.recycle();      }        ......  }  

這里通過Binder驅動程序就進入到ApplicationThread.scheduleRegisteredReceiver函數去了。

Step 12. ApplicaitonThread.scheduleRegisteredReceiver

public final class ActivityThread {......        private final class ApplicationThread extends ApplicationThreadNative {......            // This function exists to make sure all receiver dispatching is          // correctly ordered, since these are one-way calls and the binder driver          // applies transaction ordering per object for such calls.          public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,                  int resultCode, String dataStr, Bundle extras, boolean ordered,                  boolean sticky) throws RemoteException {receiver.performReceive(intent, resultCode, dataStr, extras, ordered, sticky);          }            ......      }        ......    }  

這里的receiver是在前面過程分析中的Step 4中創建的，它的具體類型是LoadedApk.ReceiverDispatcher.InnerReceiver，即定義在LoadedApk類的內部類ReceiverDispatcher里面的一個內部類InnerReceiver，這里調用它的performReceive函數。

Step 13. InnerReceiver.performReceive

final class LoadedApk {......         static final class ReceiverDispatcher {final static class InnerReceiver extends IIntentReceiver.Stub {......                public void performReceive(Intent intent, int resultCode,                      String data, Bundle extras, boolean ordered, boolean sticky) {LoadedApk.ReceiverDispatcher rd = mDispatcher.get();                  ......                  if (rd != null) {rd.performReceive(intent, resultCode, data, extras,                              ordered, sticky);                  } else {......                  }              }          }            ......      }        ......  }  

這里，它只是簡單地調用ReceiverDispatcher的performReceive函數來進一步處理，這里的ReceiverDispatcher類是LoadedApk類里面的一個內部類。

Step 14. ReceiverDispatcher.performReceive

final class LoadedApk {......         static final class ReceiverDispatcher {......            public void performReceive(Intent intent, int resultCode,                  String data, Bundle extras, boolean ordered, boolean sticky) {......                Args args = new Args();              args.mCurIntent = intent;              args.mCurCode = resultCode;              args.mCurData = data;              args.mCurMap = extras;              args.mCurOrdered = ordered;              args.mCurSticky = sticky;              if (!mActivityThread.post(args)) {......              }           }            ......      }        ......  }  

這里mActivityThread成員變量的類型為Handler，它是前面MainActivity注冊廣播接收器時，從ActivityThread取得的。

這里ReceiverDispatcher借助這個Handler，把這個廣播以消息的形式放到MainActivity所在的這個ActivityThread的消息隊列中去，因此，ReceiverDispatcher不等這個廣播被MainActivity處理就返回了，這里也體現了廣播的發送和處理是異步進行的。

注意這里處理消息的方式是通過Handler.post函數進行的，post函數的參數是Runnable類型的，這個消息最終會調用這個這個參數的run成員函數來處理。這里的Args類是LoadedApk類的內部類ReceiverDispatcher的一個內部類，它繼承于Runnable類，因此，可以作為mActivityThread.post的參數傳進去，代表這個廣播的intent也保存在這個Args實例中。

Step 15. Hanlder.post

這個函數定義在frameworks/base/core/java/android/os/Handler.java文件中，它的作用就是把消息放在消息隊列中，然后就返回了，這個消息最終會在傳進來的Runnable類型的參數的run成員函數中進行處理。

Step 16. Args.run

final class LoadedApk {......         static final class ReceiverDispatcher {......            final class Args implements Runnable {......                public void run() {BroadcastReceiver receiver = mReceiver;                    ......                    Intent intent = mCurIntent;                                    ......                    try {ClassLoader cl =  mReceiver.getClass().getClassLoader();                      intent.setExtrasClassLoader(cl);                      if (mCurMap != null) {mCurMap.setClassLoader(cl);                      }                      receiver.setOrderedHint(true);                      receiver.setResult(mCurCode, mCurData, mCurMap);                      receiver.clearAbortBroadcast();                      receiver.setOrderedHint(mCurOrdered);                      receiver.setInitialStickyHint(mCurSticky);                      receiver.onReceive(mContext, intent);                  } catch (Exception e) {......                  }                    ......              }                ......          }            ......      }        ......  }  

這里的mReceiver是ReceiverDispatcher類的成員變量，它的類型是BroadcastReceiver，這里它就是MainActivity注冊廣播接收器時創建的BroadcastReceiver實例了。

有了這個ReceiverDispatcher實例之后，就可以調用它的onReceive函數把這個廣播分發給它處理了。

Step 17. BroadcastReceiver.onReceive

public class MainActivity extends Activity implements OnClickListener {......          private BroadcastReceiver counterActionReceiver = new BroadcastReceiver(){public void onReceive(Context context, Intent intent) {int counter = intent.getIntExtra(CounterService.COUNTER_VALUE, 0);                String text = String.valueOf(counter);                counterText.setText(text);                  Log.i(LOG_TAG, "Receive counter event");            }          }        ......      }  

這樣，MainActivity里面的定義的BroadcastReceiver實例counterActionReceiver就收到這個廣播并進行處理了。

至此，Android應用程序發送廣播的過程就分析完成了。

最后，我們總結一下這個Android應用程序發送廣播的過程：

Step 1 - Step 7，計數器服務CounterService通過sendBroadcast把一個廣播通過Binder進程間通信機制發送給ActivityManagerService，ActivityManagerService根據這個廣播的Action類型找到相應的廣播接收器，然后把這個廣播放進自己的消息隊列中去，就完成第一階段對這個廣播的異步分發了；Step 8 - Step 15，ActivityManagerService在消息循環中處理這個廣播，并通過Binder進程間通信機制把這個廣播分發給注冊的廣播接收分發器ReceiverDispatcher，ReceiverDispatcher把這個廣播放進MainActivity所在的線程的消息隊列中去，就完成第二階段對這個廣播的異步分發了；Step 16 - Step 17， ReceiverDispatcher的內部類Args在MainActivity所在的線程消息循環中處理這個廣播，最終是將這個廣播分發給所注冊的BroadcastReceiver實例的onReceive函數進行處理。