一，写在前面
本篇文章会从源码角度分析广播的工作流程，具体来说是分为两部分：广播的注册，发送广播。在阅读本篇文章前，建议先了解Activity，Service相关的工作流程。本篇文章将不再分析工作流程中的重复细节，参考文章：
Android Activity的启动流程源码解析(8.0)
Android Service的启动流程源码分析(8.0)
二，广播的注册，交给ContextImpl
广播的注册分为静态注册，以及动态注册。静态注册是在xml中配置<receiver>节点，在应用程序启动后会解析xml文件，具体的注册流程是交给PackagerManagerService来处理。本篇文章主要分析广播的动态注册，也就是在Java代码中调用registerReceiver方法来注册广播，开发中具体的使用这里不再介绍。 不管是在Activity，还是Service中注册广播，都是调用ContextWrapper$registerReceiver方法。其中，ContextWrapper是Context的一个子类，在抽象类Context中定义了抽象方法registerReceiver，具体实现在子类ContextWrapper中。 查看ContextWrapper$registerReceiver源码：
@Override
public Intent registerReceiver(
BroadcastReceiver receiver, IntentFilter filter) {
return mBase.registerReceiver(receiver, filter);
} 第4行，变量mBase是Context类型，而Context是一个抽象类，其实mBase的具体实现类是ContextImpl。至于具体原因，可以查看文章
Android Activity的启动流程源码解析(8.0) ，这里不再重复阐述。
查看ContextImpl相关源码：
@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, getUserId(),
filter, broadcastPermission, scheduler, getOuterContext(), 0);
}
//继续查看...
private Intent registerReceiverInternal(BroadcastReceiver receiver, int userId,
IntentFilter filter, String broadcastPermission,
Handler scheduler, Context context, int flags) {
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 {
if (scheduler == null) {
scheduler = mMainThread.getHandler();
}
rd = new LoadedApk.ReceiverDispatcher(
receiver, context, scheduler, null, true).getIIntentReceiver();
}
}
//...code
final Intent intent = ActivityManager.getService().registerReceiver(
mMainThread.getApplicationThread(), mBasePackageName, rd, filter,
broadcastPermission, userId, flags);
//...code
}第17行，ContextImpl$registerReceiver有多个重载方法，但最终都会调用ContextImpl$registerReceiverInternal方法。
第24行，mMainThread是一个ActivityThread类型的变量，它的实例化在ContextImpl的构造方法中。mMainThread.getHandler()返回一个H类型的对象，H是ActivityThread的内部类，继承了Handler。值得一提的是，在启动Activity，Service的工作流程中，都会创建一个上下文环境，也就是会创建ContextImpl对象。具体分析，见文章
Android Activity的启动流程源码解析(8.0) ，这里不再重复阐述。 第26行，变量mPackageInfo是一个LoadedApk的变量，这里是将BroadcastReceiver对象封装到ReceiverDispatcher中，并最终返回IIntentReceiver类型的对象。有意思的是，ReceiverDispatcher与绑定服务中的ServiceDispatcher比较类似，都是将组件对象进行封装，并返回一个Binder对象，用于实现组件对象在进程间的通信。 由于逻辑与绑定服务流程中的LoadedApk$ServiceDispacher类似，具体分析可参考文章
Android Service的绑定流程源码分析(8.0) 。这里rd返回IIntentReceiver类型的对象，它的具体实现类是LoadedApk$ReceiverDispatcher$InnerReceiver，其具体结构：final static class InnerReceiver extends IIntentReceiver.Stub 。 第33行，当mPackageInfo为null时，给rd赋值，做的事情与前面讲到的第26行一样。
第40行，ActivityManager.getService()返回一个IActivityManager的代理对象，调用其registerReceiver方法会向系统服务发送一个请求，基于Binder机制，会调用ActivityManagerService$ActivityManage方法。具体分析，见文章
Android Activity的启动流程源码解析(8.0) ，这里不再重复阐述。
三，广播的注册，交给ActivityManagerService处理
查看ActivityManagerService$ActivityManage方法源码：
public Intent registerReceiver(IApplicationThread caller, String callerPackage,
IIntentReceiver receiver, IntentFilter filter, String permission, int userId,
int flags) {
//...code
if (callerApp != null && (callerApp.thread == null
|| callerApp.thread.asBinder() != caller.asBinder())) {
// Original caller already died
return null;
}
ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder());
if (rl == null) {
rl = new ReceiverList(this, callerApp, callingPid, callingUid,
userId, receiver);
if (rl.app != null) {
rl.app.receivers.add(rl);
} else {
try {
receiver.asBinder().linkToDeath(rl, 0);
} catch (RemoteException e) {
return sticky;
}
rl.linkedToDeath = true;
}
mRegisteredReceivers.put(receiver.asBinder(), rl);
}
//...code
BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,
permission, callingUid, userId, instantApp, visibleToInstantApps);
rl.add(bf);
if (!bf.debugCheck()) {
Slog.w(TAG, "==> For Dynamic broadcast");
}
mReceiverResolver.addFilter(bf);
//...code
} 第8行，caller是一个IApplicationThread类型的变量，是一个Binder对象，具体源码见文章
Android Activity的启动流程源码解析(8.0) ，这里会检查它的对应的Binder对象。 第12行，变量mRegisteredReceivers的定义： HashMap<IBinder, ReceiverList> mRegisteredReceivers = new HashMap<>()。 key：receiver.asBinder()返回的是IIntentReceiver对象对应的Binder对象。IIntentReceiver前面已经分析过了，它封装了BroadcastReceiver对象，且是一个Binder对象。 value：ReceiverList类型的对象，它是一个存储BroadcastFilter对象的List集合。结构：class ReceiverList extends ArrayList<BroadcastFilter> implements IBinder.DeathRecipient。
第14行，创建ReceiverList对象，注意最后一个参数receiver，说明ReceiverList封装了InnerReceiver对象。 第31行，BroadcastFilter结构：class BroadcastFilter extends IntentFilter 。BroadcastFilter对象中封装了ReceiverList对象，IntentFilter对象。 第37行，mReceiverResolver是一个IntentResolver类型的变量，该类里面维护了集合，并调用addFilter方法将bf存储起来。 也就是说，注册广播的就是将InnerReceiver对象，IntentFilter对象封装在类BroadcastFilter中，并最终将BroadcastFilter对象存储在变量mReceiverResolver中。值得一提的是，在发送广播的流程中，会取出变量mReceiverResolver中存储的广播接受者相关的数据。动态注册广播的分析，到此就结束了~
四，发送广播，交给ContextImpl处理
与动态注册广播一样，发送广播实际上调用的ContextWrapper$sendBroadcast方法； 查看ContextWrapper$sendBroadcast方法源码：
@Override
public void sendBroadcast(Intent intent) {
mBase.sendBroadcast(intent);
}第3行，变量mBase实现类是ContextImpl，与动态注册广播一样的。 查看ContextImpl$sendBroadcast方法源码：
public void sendBroadcast(Intent intent) {
//...
ActivityManager.getService().broadcastIntent(
mMainThread.getApplicationThread(), intent, resolvedType, null,
Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, null, false, false,
getUserId());
//...
}ActivityManager.getService()返回一个IActivityManager接口的代理对象，向系统服务AMS发起一个请求，会调用ActivityManagerService$broadcastIntent方法。具体细节不再分析，动态注册广播时已经提到。
五，发送广播，交给ActivityManagerService处理
查看ActivityManagerService$broadcastIntent方法源码：
public final int broadcastIntent(IApplicationThread caller,
Intent intent, String resolvedType, IIntentReceiver resultTo,
int resultCode, String resultData, Bundle resultExtras,
String[] requiredPermissions, int appOp, Bundle bOptions,
boolean serialized, boolean sticky, int userId) {
//...
synchronized(this) {
intent = verifyBroadcastLocked(intent);
//...
int res = broadcastIntentLocked(callerApp,
callerApp != null ? callerApp.info.packageName : null,
intent, resolvedType, resultTo, resultCode, resultData, resultExtras,
requiredPermissions, appOp, bOptions, serialized, sticky,
callingPid, callingUid, userId);
//...
return res;
}
}第9行，主要对intent的flag进行检查； 第13行，查看ActivityManagerService$broadcastIntentLocked方法源码：
final int broadcastIntentLocked(ProcessRecord callerApp,
String callerPackage, Intent intent, String resolvedType,
IIntentReceiver resultTo, int resultCode, String resultData,
Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle bOptions,
boolean ordered, boolean sticky, int callingPid, int callingUid, int userId) {
//...
// By default broadcasts do not go to stopped apps.
intent.addFlags(Intent.FLAG_EXCLUDE_STOPPED_PACKAGES);
//...
registeredReceivers = mReceiverResolver.queryIntent(intent,
resolvedType, false /*defaultOnly*/, userId);
//...
BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
callerPackage, callingPid, callingUid, callerInstantApp, resolvedType,
requiredPermissions, appOp, brOptions, registeredReceivers, resultTo,
resultCode, resultData, resultExtras, ordered, sticky, false, userId);
//...
queue.enqueueParallelBroadcastLocked(r);
queue.scheduleBroadcastsLocked();
//...
}第10行，设置flag为FLAG_EXCLUDE_STOPPED_PACKAGES时，广播不会发送给已经停止的应用。本篇文章是基于8.0的源码，其实从Android3.1开始，发送广播会默认添加flag为FLAG_EXCLUDE_STOPPED_PACKAGES，禁止向停止应用发送广播，为了避免调用已经停止的应用。另外，若想将广播发送给已经停止的应用，也可以设置flag为FLAG_INCLUDE_STOPPED_PACKAGES。值得一提的是，应用处于停止状态意思是：应用安装后没有启动，或被手动，其他应用强行停止了。
第14行，前面分析广播注册流程，最后有提到变量mReceiverResolver，它存储了BroadcastFilter对象，也就是存放了广播接受者相关的信息。调用IntentResolver$queryIntent方法用于获取与该intent相匹配的广播接受者，返回的是一个List集合，因此变量registeredReceivers是一个List类型变量。
第21行，将变量registeredReceivers封装在BroadcastRecord对象中。 第26行，变量queue是一个BroadcastQueue类型的对象，BroadcastQueue queue = broadcastQueueForIntent(intent)。 查看BroadcastQueue$enqueueParallelBroadcastLocked方法源码：
public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
mParallelBroadcasts.add(r);
enqueueBroadcastHelper(r);
}第2行，变量mParallelBroadcasts是一个ArrayList类型的对象，用于存放BroadcastRecord对象。ArrayList<BroadcastRecord> mParallelBroadcasts = new ArrayList<>()。后面，会取出mParallelBroadcasts集合中的数据，完成广播的接受。
继续回到ActivityManagerService$broadcastIntentLocked的第27行，调用了queue.scheduleBroadcastsLocked()，这个是重点入口。
六，广播的接收
查看BroadcastQueue相关方法源码：
public void scheduleBroadcastsLocked() {
//...code
mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
//...code
}
//继续查看...
private final class BroadcastHandler extends Handler {
public BroadcastHandler(Looper looper) {
super(looper, null, true);
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case BROADCAST_INTENT_MSG: {
if (DEBUG_BROADCAST) Slog.v(
TAG_BROADCAST, "Received BROADCAST_INTENT_MSG");
processNextBroadcast(true);
} break;
//...code
}
}
}
//继续查看...
final void processNextBroadcast(boolean fromMsg) {
synchronized(mService) {
BroadcastRecord r;
//...=
if (fromMsg) {
mBroadcastsScheduled = false;
}
// First, deliver any non-serialized broadcasts right away.
while (mParallelBroadcasts.size() > 0) {
r = mParallelBroadcasts.remove(0);
r.dispatchTime = SystemClock.uptimeMillis();
r.dispatchClockTime = System.currentTimeMillis();
//...
final int N = r.receivers.size();
//...
for (int i=0; i<N; i++) {
Object target = r.receivers.get(i);
//...
deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);
}
//...
}
//...
}
}第4行，发送一个what为BROADCAST_INTENT_MSG的消息； 第19行，处理what为BROADCAST_INTENT_MSG的消息； 第22行，继续调用processNextBroadcast方法；
第44行，变量mParallelBroadcasts前面已经讲过，是一个ArrayList集合，存储了BroadcastRecord对象，而BroadcastRecord对象封装了广播接受者相关的信息； 第45行，取出index为0的BroadcastRecord对象，并将该对象删除； 第51行，r.receivers返回一个List集合，里面存放了BroadcastFilter对象。注册广播流程中已经分析过BroadcastFilter对象，它封装了广播接受者相关的信息。 第55行，对r.receivers对应的集合进行遍历，完成所有匹配的BroadcastReceiver对广播的接受。然后会调用deliverToRegisteredReceiverLocked方法，这个是一个重要入口。
查看BroadcastQueue$deliverToRegisteredReceiverLocked方法源码：
private void deliverToRegisteredReceiverLocked(BroadcastRecord r,
BroadcastFilter filter, boolean ordered, int index) {
//...code
performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
new Intent(r.intent), r.resultCode, r.resultData,
r.resultExtras, r.ordered, r.initialSticky, r.userId);
//...code
}
//继续查看...
void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,
Intent intent, int resultCode, String data, Bundle extras,
boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
//...
if (app != null) {
if (app.thread != null) {
// If we have an app thread, do the call through that so it is
// correctly ordered with other one-way calls.
try {
app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
data, extras, ordered, sticky, sendingUser, app.repProcState);
//...
}
//...
}
//...
} 第21,22行，对app，app.thread进行判空检查； 第26行，app.thread返回IApplicationThread接口的代理对象，最终会调用ApplicationThread$scheduleRegisteredReceiver方法。关于ApplicationThread的描述，这里不能理解的，请参考文章
Android Activity的启动流程源码解析(8.0) ，这里不再重复阐述。
查看ActivityThread$ApplicationThread$scheduleRegisteredReceiver方法源码：
public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,
int resultCode, String dataStr, Bundle extras, boolean ordered,
boolean sticky, int sendingUser, int processState) throws RemoteException {
updateProcessState(processState, false);
receiver.performReceive(intent, resultCode, dataStr, extras, ordered,
sticky, sendingUser);
}第5行，变量receiver是一个IIntentReceiver类型的对象，在注册广播的流程中提到过IIntentReceiver，它的具体实现类是LoadedApk$ReceiverDispatcher$InnerReceiver。其实InnerReceiver是一个Binder接口，封装BroadcastReceiver对象后，使组件对象可以在进程间传递。 查看LoadedApk$ReceiverDispatcher$InnerReceiver$performReceive方法源码：
@Override
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
//...
final LoadedApk.ReceiverDispatcher rd;
//...
rd.performReceive(intent, resultCode, data, extras,
ordered, sticky, sendingUser);
//...
}第10行，调用LoadedApk$ReceiverDispatcher$performReceive方法；
查看LoadedApk$ReceiverDispatcher$performReceive方法源码：
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
//...
final Args args = new Args(intent, resultCode, data, extras, ordered,
sticky, sendingUser);
//...
if (intent == null || !mActivityThread.post(args.getRunnable())) {
//...
}
}第10行，变量mActivityThread是ActivityThread$H类型的对象，它继承了Handler，接受广播的操作是在Handler所在的线程中执行，也就是在ActivityThread主线程中执行。 args.getRunnable()返回一个Runnable接口； 查看LoadedApk$ReceiverDispatcher$Args源码如下：
final class Args extends BroadcastReceiver.PendingResult {
//...
public final Runnable getRunnable() {
return () -> {
final BroadcastReceiver receiver = mReceiver;
//...
receiver.onReceive(mContext, intent);
//...
};
}
} 第10行，回调BroadcastReceiver$onReceive方法，于是前面注册的广播接受者，就接收到发送的广播了~
七，最后
本篇文章，从动态注册广播，发送广播，接收广播来分析BroadcastReceiver的工作机制。 阅读本篇文章前，建议先阅读如下文章：
Android Activity的启动流程源码解析(8.0)
Android Service的启动流程源码分析(8.0)
