该系列文章总纲链接：专题总纲目录 Android Framework 总纲
本章关键点总结 & 说明：
说明：本章节主要解读广播组件的广播发送过程。关注思维导图中左上侧部分即可。
有了前面广播组件 注册和注销程分析的基础，基于此，接下来我们来分析广播组件的发送广播流程。
我们先对广播组件的整体设计思路有一个了解，再详细分析其广播发送关键流程。
1 注册/注销/广播发送设计思路解读
1.1 设计思路概要解读
在解读这些关键流程前，我们从设计师的视角先来俯瞰下Android广播组件的几个关键流程，大概的设计思路整理如下（同上一章节，回顾下，有了上下文，我们之后继续分析）：
- 注册流程：注册receiver时，和AMS进行通信，将要注册的receiver和filter按照一定规则放入到AMS的一个表X中，方便查找和删除。
- 注销流程：注销receiver时，和AMS进行通信，找到对应的表X，从中将receiver从表X中删除。
- 广播发送流程：A进程 发送广播时，和AMS进行通信，查找表中是否有对应的recevier，如果存在就找到当时注册receiver的进程B，调用B中对应的recevier中的onReceiver方法。
1.2 设计思路详细解读
基于此，我们对这几个流程进行展开说明，进行更详细的解读，具体如下：
@1 注册流程：
- 应用层操作：应用通过
Context对象（如Activity或Service）调用registerReceiver()方法来注册一个BroadcastReceiver。 - 构建IntentFilter：应用传入一个
IntentFilter对象，该对象定义了BroadcastReceiver感兴趣的广播类型（如特定动作、数据类型等）。 - 与AMS通信：应用层的注册请求会通过Binder IPC（进程间通信）传递给
ActivityManagerService（AMS），AMS是Android系统中负责管理应用生命周期和广播的守护进程。 - 存储映射关系：AMS会将
BroadcastReceiver与IntentFilter的映射关系存储在一个内部的数据结构中，通常是哈希表或类似的数据结构。 - 返回Receiver对象：AMS返回一个
IIntentReceiver对象（Binder代理），用于后续的注销操作。
@2 注销流程：
- 应用层操作：应用调用
unregisterReceiver()方法，并传入之前注册的BroadcastReceiver实例。 - 与AMS通信：应用层的注销请求同样通过Binder IPC传递给AMS。
- 查找映射关系：AMS根据传入的
BroadcastReceiver实例查找之前存储的映射关系。 - 删除映射关系：如果找到对应的映射关系，AMS会将其从内部数据结构中删除，从而注销
BroadcastReceiver。 - 确认注销：注销操作完成后，AMS会向应用层确认注销成功。
@3 广播发送流程：
- 发送广播：当一个应用、系统组件或其他进程需要发送广播时，它会通过
Context或sendBroadcast()方法发送广播。 - 与AMS通信：发送请求同样通过Binder IPC传递给AMS。
- 查找匹配的Receiver：AMS会根据广播的
Intent（包含动作、数据等信息）查找内部数据结构中匹配的IntentFilter。 - 匹配Receiver：AMS会检查哪些注册的
BroadcastReceiver对当前广播感兴趣（即IntentFilter匹配）。 - 跨进程调用：对于匹配的
BroadcastReceiver，AMS会通过Binder代理调用其onReceive()方法。如果BroadcastReceiver位于不同的进程，AMS会负责进程间的通信。 - 执行Receiver：
BroadcastReceiver的onReceive()方法被调用，执行相应的逻辑。
注意：在广播发送流程中，AMS不仅仅是查找表中的BroadcastReceiver，还需要检查这些BroadcastReceiver的权限和安全性，确保只有合适的接收者能够接收到特定的广播。此外，广播的发送和接收过程还涉及到广播的优先级、发送方式（如有序广播或普通广播）等因素。但这些都不是设计的主干，因此我们可以暂时忽略。
本章节，我们关注发送广播发送和处理广播的流程。
2 广播发送流程解读
2.1 发送广播broadcastIntent关键代码解读
AMS.broadcastIntent的代码实现如下：
//AMS
public final int broadcastIntent(IApplicationThread caller,
Intent intent, String resolvedType, IIntentReceiver resultTo,
int resultCode, String resultData, Bundle map,
String requiredPermission, int appOp, boolean serialized, boolean sticky, int userId) {
enforceNotIsolatedCaller("broadcastIntent");
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, appOp, serialized, sticky,
callingPid, callingUid, userId);
Binder.restoreCallingIdentity(origId);
return res;
}
}这里主要是broadcastIntentLocked方法的实现，但该代码过长，因此这里拆分成3个部分进行分析。
2.1.1 broadcastIntentLocked第一部分代码解析
broadcastIntentLocked第一部分代码实现如下所示：
//AMS
private final int broadcastIntentLocked(ProcessRecord callerApp,
String callerPackage, Intent intent, String resolvedType,
IIntentReceiver resultTo, int resultCode, String resultData,
Bundle map, String requiredPermission, int appOp,
boolean ordered, boolean sticky, int callingPid, int callingUid,
int userId) {
//第一阶段：特殊广播处理阶段
intent = new Intent(intent);
intent.addFlags(Intent.FLAG_EXCLUDE_STOPPED_PACKAGES);
//...
userId = handleIncomingUser(callingPid, callingUid, userId,
true, ALLOW_NON_FULL, "broadcast", callerPackage);
if (userId != UserHandle.USER_ALL && !isUserRunningLocked(userId, false)) {
//...
}
int callingAppId = UserHandle.getAppId(callingUid);
if (callingAppId == Process.SYSTEM_UID || callingAppId == Process.PHONE_UID
|| callingAppId == Process.SHELL_UID || callingAppId == Process.BLUETOOTH_UID
|| callingAppId == Process.NFC_UID || callingUid == 0) {
// Always okay.
} else if (callerApp == null || !callerApp.persistent) {
try {
if (AppGlobals.getPackageManager().isProtectedBroadcast(
intent.getAction())) {
//...
} else if (AppWidgetManager.ACTION_APPWIDGET_CONFIGURE.equals(intent.getAction())) {
if (callerApp == null) {
//...
} else if (intent.getComponent() != null) {
//...
} else {
// Limit broadcast to their own package.
intent.setPackage(callerApp.info.packageName);
}
}
} catch (RemoteException e) {
//...
}
}
final String action = intent.getAction();
if (action != null) {
switch (action) {
case Intent.ACTION_UID_REMOVED:
case Intent.ACTION_PACKAGE_REMOVED:
//...
case Proxy.PROXY_CHANGE_ACTION:
ProxyInfo proxy = intent.getParcelableExtra(Proxy.EXTRA_PROXY_INFO);
mHandler.sendMessage(mHandler.obtainMessage(UPDATE_HTTP_PROXY_MSG, proxy));
break;
}
}
//...
第一阶段代码主要是对一些特出的广播进行处理，主要是和package相关。
2.1.2 broadcastIntentLocked第二部分代码解析
broadcastIntentLocked第二部分代码实现如下所示：
//AMS
private final int broadcastIntentLocked(ProcessRecord callerApp,
String callerPackage, Intent intent, String resolvedType,
IIntentReceiver resultTo, int resultCode, String resultData,
Bundle map, String requiredPermission, int appOp,
boolean ordered, boolean sticky, int callingPid, int callingUid,
int userId) {
//...
//第二阶段：处理发送stick广播。如果是粘性广播，则进行特殊处理
if (sticky) {
//...
// 获取特定用户ID的粘性广播存储
ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(userId);
if (stickies == null) {
stickies = new ArrayMap<String, ArrayList<Intent>>();
mStickyBroadcasts.put(userId, stickies);
}
// 获取该动作对应的粘性广播列表
ArrayList<Intent> list = stickies.get(intent.getAction());
if (list == null) {
list = new ArrayList<Intent>();
stickies.put(intent.getAction(), list);
}
// 查找是否存在相同的粘性广播，如果存在则替换它
int N = list.size();
for (i = 0; i < N; i++) {
if (intent.filterEquals(list.get(i))) {
list.set(i, new Intent(intent));
break;
}
}
// 如果没有找到相同的粘性广播，则添加新的粘性广播
if (i >= N) {
list.add(new Intent(intent));
}
}
// 根据用户ID确定要广播的用户列表
int[] users;
if (userId == UserHandle.USER_ALL) {
users = mStartedUserArray;
} else {
users = new int[] {userId};
}
// 收集可以接收此广播的组件
List receivers = null;
// 查询已注册的接收器
List<BroadcastFilter> registeredReceivers = null;
if ((intent.getFlags() & Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
receivers = collectReceiverComponents(intent, resolvedType, callingUid, users);
}
// 如果没有指定组件，查询所有可以接收此广播的接收器
if (intent.getComponent() == null) {
if (userId == UserHandle.USER_ALL && callingUid == Process.SHELL_UID) {
//...
} else {
registeredReceivers = mReceiverResolver.queryIntent(intent,
resolvedType, false, userId);
}
}
// 检查是否需要替换挂起的广播
final boolean replacePending =
(intent.getFlags() & Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;
// 计算已注册接收器的数量
int NR = registeredReceivers != null ? registeredReceivers.size() : 0;
// 如果不需要有序广播且有已注册接收器，则发送并行广播
if (!ordered && NR > 0) {
final BroadcastQueue queue = broadcastQueueForIntent(intent);
BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
callerPackage, callingPid, callingUid, resolvedType, requiredPermission,
appOp, registeredReceivers, resultTo, resultCode, resultData, map,
ordered, sticky, false, userId);
// 如果需要替换挂起的广播，则尝试替换
final boolean replaced = replacePending && queue.replaceParallelBroadcastLocked(r);
// 如果没有替换成功，则入队并调度广播
if (!replaced) {
queue.enqueueParallelBroadcastLocked(r);
queue.scheduleBroadcastsLocked();
}
registeredReceivers = null;
NR = 0;
}
//...
//...
}第二阶段代码主要处理与粘性广播相关的逻辑。粘性广播是一种特殊的广播，它可以被保存并在BroadcastReceiver注册后立即发送给它，即使广播在接收器注册前就已经发送。这个阶段会检查传入的广播是否为粘性广播（sticky），如果是，则在mStickyBroadcasts数据结构中更新或添加新的粘性广播。这个过程涉及到根据用户ID和Intent动作查找和替换现有的粘性广播，确保最新的广播被保存。
同时在这里我们着重分析下静态广播接收器的注册和识别过程，毕竟最开始不是动态注册的，我们需要理清楚静态注册的这些receiver是如何和动态注册的receivers合并在一起的。在查询已注册的静态广播接收器时，处理的关键方法为collectReceiverComponents。代码实现如下所示：
//AMS
private List<ResolveInfo> collectReceiverComponents(Intent intent, String resolvedType,
int callingUid, int[] users) {
List<ResolveInfo> receivers = null; // 用于存储所有匹配的广播接收器
try {
HashSet<ComponentName> singleUserReceivers = null; // 用于存储单用户模式的接收器
boolean scannedFirstReceivers = false; // 标记是否已经扫描过第一个用户的接收器
for (int user : users) { // 遍历所有用户
// 如果调用者是shell，并且用户有限制不允许调试特性，则跳过
if (callingUid == Process.SHELL_UID
&& getUserManagerLocked().hasUserRestriction(
UserManager.DISALLOW_DEBUGGING_FEATURES, user)) {
continue;
}
// 关键代码：查询每个用户可以处理给定Intent的广播接收器
List<ResolveInfo> newReceivers = AppGlobals.getPackageManager()
.queryIntentReceivers(intent, resolvedType, STOCK_PM_FLAGS, user);
// 如果用户不是默认用户，并且查询到的接收器不为空
if (user != 0 && newReceivers != null) {
for (int i=0; i<newReceivers.size(); i++) {
ResolveInfo ri = newReceivers.get(i);
// 移除仅属于主用户的接收器
if ((ri.activityInfo.flags&ActivityInfo.FLAG_PRIMARY_USER_ONLY) != 0) {
newReceivers.remove(i);
i--;
}
}
}
// 如果查询到的接收器列表不为空，并且大小为0，则设置为null
if (newReceivers != null && newReceivers.size() == 0) {
newReceivers = null;
}
// 合并接收器列表
if (receivers == null) {
receivers = newReceivers; // 如果receivers为空，则直接赋值
} else if (newReceivers != null) {
if (!scannedFirstReceivers) {
scannedFirstReceivers = true; // 标记已经扫描过第一个用户的接收器
// 扫描第一个用户的接收器，找出单用户模式的接收器
for (int i=0; i<receivers.size(); i++) {
ResolveInfo ri = receivers.get(i);
if ((ri.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) {
ComponentName cn = new ComponentName(
ri.activityInfo.packageName, ri.activityInfo.name);
if (singleUserReceivers == null) {
singleUserReceivers = new HashSet<ComponentName>();
}
singleUserReceivers.add(cn);
}
}
}
// 将新用户的接收器添加到receivers列表中，排除单用户模式的接收器
for (int i=0; i<newReceivers.size(); i++) {
ResolveInfo ri = newReceivers.get(i);
if ((ri.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) {
ComponentName cn = new ComponentName(
ri.activityInfo.packageName, ri.activityInfo.name);
if (singleUserReceivers == null) {
singleUserReceivers = new HashSet<ComponentName>();
}
if (!singleUserReceivers.contains(cn)) {
singleUserReceivers.add(cn);
receivers.add(ri);
}
} else {
receivers.add(ri);
}
}
}
}
} catch (RemoteException ex) {
// pm is in same process, this will never happen.
}
return receivers; // 返回收集到的广播接收器列表
}collectReceiverComponents方法负责收集所有可以处理给定Intent的广播接收器，考虑了用户限制、主用户接收器和单用户接收器。这个方法确保了广播可以被正确地分发到所有符合条件的接收器，无论它们属于哪个用户。这里我们主要关注调用的PMS代码queryIntentReceivers方法，代码实现如下：
//PMS
@Override
public List<ResolveInfo> queryIntentReceivers(Intent intent, String resolvedType, int flags,
int userId) {
// 检查用户是否存在，如果不存在返回空列表
if (!sUserManager.exists(userId)) return Collections.emptyList();
// 获取Intent中指定的组件名称
ComponentName comp = intent.getComponent();
// 如果Intent中没有指定组件，尝试从Selector中获取
if (comp == null) {
if (intent.getSelector() != null) {
intent = intent.getSelector();
comp = intent.getComponent();
}
}
// 如果Intent中指定了组件
if (comp != null) {
// 创建一个ResolveInfo列表，最多包含一个元素
List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
// 获取对应组件的ActivityInfo
ActivityInfo ai = getReceiverInfo(comp, flags, userId);
// 如果找到了对应的ActivityInfo
if (ai != null) {
// 创建一个ResolveInfo对象，并填充ActivityInfo
ResolveInfo ri = new ResolveInfo();
ri.activityInfo = ai;
// 将ResolveInfo添加到列表中
list.add(ri);
}
// 返回ResolveInfo列表
return list;
}
// 如果Intent中没有指定组件，使用mReceivers进行查询
synchronized (mPackages) {
// 获取Intent中指定的包名
String pkgName = intent.getPackage();
// 如果Intent中没有指定包名
if (pkgName == null) {
// 使用mReceivers查询所有匹配的广播接收器
return mReceivers.queryIntent(intent, resolvedType, flags, userId);
}
// 如果Intent中指定了包名
final PackageParser.Package pkg = mPackages.get(pkgName);
// 如果找到了对应的Package
if (pkg != null) {
// 使用mReceivers查询指定包中匹配的广播接收器
return mReceivers.queryIntentForPackage(intent, resolvedType, flags, pkg.receivers,userId);
}
// 如果没有找到对应的Package，返回null
return null;
}
}
queryIntentReceivers方法是PKMS中用于查询可以处理特定Intent的广播接收器的关键方法。它支持通过组件名称、包名或全局查询来找到匹配的广播接收器，并返回它们的ResolveInfo列表。
2.1.3 broadcastIntentLocked第三部分代码解析
broadcastIntentLocked第三部分代码实现如下所示：
//AMS
private final int broadcastIntentLocked(ProcessRecord callerApp,
String callerPackage, Intent intent, String resolvedType,
IIntentReceiver resultTo, int resultCode, String resultData,
Bundle map, String requiredPermission, int appOp,
boolean ordered, boolean sticky, int callingPid, int callingUid,
int userId) {
//...
// 第三阶段：处理接收者排序和广播分发
int ir = 0; // 初始化接收者计数器
// 如果有收集到的接收者
if (receivers != null) {
// 定义一个数组，用于存储需要跳过的包名
String skipPackages[] = null;
// 根据不同的Intent动作，确定需要跳过的包名
if (Intent.ACTION_PACKAGE_ADDED.equals(intent.getAction())
|| Intent.ACTION_PACKAGE_RESTARTED.equals(intent.getAction())
|| Intent.ACTION_PACKAGE_DATA_CLEARED.equals(intent.getAction())) {
Uri data = intent.getData();
if (data != null) {
String pkgName = data.getSchemeSpecificPart();
if (pkgName != null) {
skipPackages = new String[] { pkgName };
}
}
} else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(intent.getAction())) {
skipPackages = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
}
// 如果有需要跳过的包名
if (skipPackages != null && (skipPackages.length > 0)) {
// 遍历需要跳过的包名
for (String skipPackage : skipPackages) {
if (skipPackage != null) {
// 从接收者列表中移除对应的接收者
int NT = receivers.size();
for (int it=0; it<NT; it++) {
ResolveInfo curt = (ResolveInfo)receivers.get(it);
if (curt.activityInfo.packageName.equals(skipPackage)) {
receivers.remove(it);
it--;
NT--;
}
}
}
}
}
// 计算接收者的数量
int NT = receivers != null ? receivers.size() : 0;
int it = 0;
ResolveInfo curt = null;
BroadcastFilter curr = null;
// 合并已注册的接收者和收集到的接收者，并根据优先级排序
while (it < NT && ir < NR) {
if (curt == null) {
curt = (ResolveInfo)receivers.get(it);
}
if (curr == null) {
curr = registeredReceivers.get(ir);
}
if (curr.getPriority() >= curt.priority) {
// 如果已注册接收者的优先级更高或相等，将其插入最终列表
receivers.add(it, curr);
ir++;
curr = null;
it++;
NT++;
} else {
// 否则，跳过当前的ResolveInfo
it++;
curt = null;
}
}
}
// 如果还有剩余的已注册接收者，将它们添加到最终列表
while (ir < NR) {
if (receivers == null) {
receivers = new ArrayList();
}
receivers.add(registeredReceivers.get(ir));
ir++;
}
// 如果有接收者或结果接收者
if ((receivers != null && receivers.size() > 0)
|| resultTo != null) {
// 获取广播队列
BroadcastQueue queue = broadcastQueueForIntent(intent);
// 创建广播记录
BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
callerPackage, callingPid, callingUid, resolvedType,
requiredPermission, appOp, receivers, resultTo, resultCode,
resultData, map, ordered, sticky, false, userId);
//...
// 如果需要替换挂起的有序广播，则尝试替换
boolean replaced = replacePending && queue.replaceOrderedBroadcastLocked(r);
if (!replaced) {
// 如果没有替换成功，将广播加入队列并调度广播
queue.enqueueOrderedBroadcastLocked(r);
queue.scheduleBroadcastsLocked();
}
}
return ActivityManager.BROADCAST_SUCCESS;
}第三阶段代码负责将已注册的接收器BroadcastFilter和通过Intent解析得到的接收器ResolveInfo合并，并根据它们的优先级进行排序。此外，它还会处理特定情况下需要跳过某些包名的逻辑，例如在应用更新、重启或数据清除时。排序完成后，代码会创建一个BroadcastRecord，包含所有排序后的接收者，并将这个记录发送到相应的BroadcastQueue中，以便进行广播分发。
在AMS的broadcastIntentLocked方法中。第一阶段、二阶段和第三阶段共同构成了广播Intent处理的核心流程。具体解读如下：
- 第一阶段主要处理特殊广播。
- 第二阶段专注于处理粘性广播，确保即使在接收器注册前发送的广播也能被正确地保存和分发，同时这里对静态接收器也做了相关处理，这样在第三阶段就可以将动态和静态接收器合并在一起。
- 第三阶段则负责将所有潜在的接收者（包括已注册和通过Intent解析得到的）合并、排序，并根据它们的优先级进行分发。这三个阶段的设计和实现确保了Android系统中广播机制的灵活性和可靠性，允许应用在正确的时间接收到正确的广播，同时支持广播的持久化和优先级控制。
通过这种方式，Android系统能够高效地管理和分发大量的广播，满足不同应用场景的需求。我们接下来主要关注广播的发送流程中queue的部分实现，也就是broadcastIntentLocked中的如下代码：
//调度发送并行广播
queue.enqueueParallelBroadcastLocked(r);
queue.scheduleBroadcastsLocked();
//调度发送串行广播
queue.enqueueOrderedBroadcastLocked(r);
queue.scheduleBroadcastsLocked();enqueueParallelBroadcastLocked、enqueueOrderedBroadcastLocked的实现具体如下：
//BroadcastQueue
//并行广播队列
public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
mParallelBroadcasts.add(r);
}
//串行广播队列
public void enqueueOrderedBroadcastLocked(BroadcastRecord r) {
mOrderedBroadcasts.add(r);
}可以看到，对于串行和并行2类广播放在了不同的列表中。这也意味着，每次发送广播，针对并行和串行广播，是做了不同的处理的。
接下来看共同部分：scheduleBroadcastsLocked方法，它的代码如下：
public void scheduleBroadcastsLocked() {
if (mBroadcastsScheduled) {
return;
}
mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
mBroadcastsScheduled = true;
}
//handler消息处理
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: {
processNextBroadcast(true);
} break;
//...
}
}
};可以看到这里最终是调用到processNextBroadcast方法，接下来我们主要关注该方法的实现。
2.2 processNextBroadcast方法解读
2.2.1 processNextBroadcast第一部分代码解析
processNextBroadcast第一部分代码实现如下所示：
//BroadcastQueue
final void processNextBroadcast(boolean fromMsg) {
synchronized(mService) {
//第一阶段：派发广播给接收者
BroadcastRecord r;
mService.updateCpuStats();// 更新cpu使用情况
// 如果这个调用是由消息队列触发的，那么更新调度状态
if (fromMsg) {
mBroadcastsScheduled = false;
}
// 处理所有并行广播
while (mParallelBroadcasts.size() > 0) {
r = mParallelBroadcasts.remove(0); // 从并行广播队列中取出第一个广播记录
r.dispatchTime = SystemClock.uptimeMillis(); // 设置广播的分发时间为当前系统uptime毫秒数
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); // 分发广播给注册的接收器
}
addBroadcastToHistoryLocked(r); // 将广播记录添加到历史记录中，以便未来查询
}
//...
}
}这段代码是Android广播系统中处理并行广播的关键部分，它确保了当有并行广播待处理时，它们能够被及时取出并分发给所有注册的接收器。这个过程体现了Android广播机制的并行处理能力，允许多个广播同时被分发，提高了系统的响应速度和效率。
2.2.2 processNextBroadcast第二部分代码解析
processNextBroadcast第二部分代码实现如下所示：
//BroadcastQueue
final void processNextBroadcast(boolean fromMsg) {
synchronized(mService) {
//...
// 第二阶段：处理有序广播
if (mPendingBroadcast != null) {
boolean isDead;
synchronized (mService.mPidsSelfLocked) {
ProcessRecord proc = mService.mPidsSelfLocked.get(mPendingBroadcast.curApp.pid);
isDead = proc == null || proc.crashing;
}
if (!isDead) {
// 如果当前处理的广播对应的进程还活着，继续等待
return;
} else {
mPendingBroadcast.state = BroadcastRecord.IDLE;
mPendingBroadcast.nextReceiver = mPendingBroadcastRecvIndex;
mPendingBroadcast = null;
}
}
boolean looped = false;
do {
if (mOrderedBroadcasts.size() == 0) {
mService.scheduleAppGcsLocked(); // 调度应用的垃圾回收
if (looped) {
mService.updateOomAdjLocked(); // 更新OOM调整
}
return; // 如果有序广播队列为空，返回
}
BroadcastRecord r = mOrderedBroadcasts.get(0); // 获取队列中的第一个广播记录
boolean forceReceive = false; // 是否强制接收广播
int numReceivers = (r.receivers != null) ? r.receivers.size() : 0;
if (mService.mProcessesReady && r.dispatchTime > 0) {
long now = SystemClock.uptimeMillis();
if ((numReceivers > 0) &&
(now > r.dispatchTime + (2*mTimeoutPeriod*numReceivers))) {
broadcastTimeoutLocked(false); // 超时处理，强制完成广播
forceReceive = true;
r.state = BroadcastRecord.IDLE;
}
}
if (r.state != BroadcastRecord.IDLE) {
return; // 如果当前广播状态不是IDLE，返回
}
// 如果没有更多的接收器，或者接收器中止了广播，或者需要强制接收
if (r.receivers == null || r.nextReceiver >= numReceivers
|| r.resultAbort || forceReceive) {
if (r.resultTo != null) {
try {
// 执行结果接收器的回调
performReceiveLocked(r.callerApp, r.resultTo,
new Intent(r.intent), r.resultCode,
r.resultData, r.resultExtras, false, false, r.userId);
r.resultTo = null;
} catch (RemoteException e) {
//...
}
}
cancelBroadcastTimeoutLocked(); // 取消广播超时
// 将广播记录添加到历史记录，并继续处理下一个广播
addBroadcastToHistoryLocked(r);
mOrderedBroadcasts.remove(0);
r = null;
looped = true;
continue;
}
} while (r == null); // 如果当前广播记录为null，继续循环
//...
}
}这段代码是Android广播系统中处理有序广播的关键部分，它确保了有序广播按照正确的顺序被分发给接收器，并且在必要时处理超时和强制接收的情况。这个过程确保了广播的执行顺序和接收器之间的依赖关系得到正确处理。
2.2.3 processNextBroadcast第三部分代码解析
processNextBroadcast第三部分代码实现如下所示：
//BroadcastQueue
final void processNextBroadcast(boolean fromMsg) {
synchronized(mService) {
// ...
// 第三阶段：处理有序广播的下一个接收者
int recIdx = r.nextReceiver++; // 获取下一个接收者的索引并递增索引
r.receiverTime = SystemClock.uptimeMillis(); // 设置接收时间
if (recIdx == 0) {
r.dispatchTime = r.receiverTime; // 如果是第一个接收者，设置分发时间
r.dispatchClockTime = System.currentTimeMillis(); // 设置分发的系统时间
}
if (!mPendingBroadcastTimeoutMessage) {
long timeoutTime = r.receiverTime + mTimeoutPeriod; // 设置超时时间
setBroadcastTimeoutLocked(timeoutTime); // 设置广播超时
}
Object nextReceiver = r.receivers.get(recIdx); // 获取下一个接收者
if (nextReceiver instanceof BroadcastFilter) {
BroadcastFilter filter = (BroadcastFilter)nextReceiver; // 转换为BroadcastFilter
deliverToRegisteredReceiverLocked(r, filter, r.ordered); // 分发广播给注册的接收器
if (r.receiver == null || !r.ordered) {
scheduleBroadcastsLocked(); // 调度广播
}
return;
}
ResolveInfo info = (ResolveInfo)nextReceiver; // 转换为ResolveInfo
ComponentName component = new ComponentName(info.activityInfo.packageName, info.activityInfo.name); // 获取组件名称
// 检查权限和AppOps，如果不符合条件，则跳过当前接收者
boolean skip = checkReceiverPermission(r, info); // 检查接收者权限
if (skip) {
r.receiver = null;
r.curFilter = null;
r.state = BroadcastRecord.IDLE; // 设置状态为IDLE
scheduleBroadcastsLocked(); // 调度广播
return;
}
// 如果接收者是一个单例，并且调用者有权限，那么更新接收者的ActivityInfo
boolean isSingleton = false; // 标记是否为单例
try {
isSingleton = mService.isSingleton(info.activityInfo.processName, info.activityInfo.applicationInfo, info.activityInfo.name, info.activityInfo.flags);
} catch (SecurityException e) {
// ...
}
if ((info.activityInfo.flags & ActivityInfo.FLAG_SINGLE_USER) != 0) {
// 检查是否有跨用户交互权限
if (ActivityManager.checkUidPermission(android.Manifest.permission.INTERACT_ACROSS_USERS, info.activityInfo.applicationInfo.uid) != PackageManager.PERMISSION_GRANTED) {
skip = true;
}
}
if (r.curApp != null && r.curApp.crashing) {
// 如果当前应用正在崩溃，跳过
skip = true;
}
if (!skip) {
// 检查应用是否可用
boolean isAvailable = false;
try {
isAvailable = AppGlobals.getPackageManager().isPackageAvailable(info.activityInfo.packageName, UserHandle.getUserId(info.activityInfo.applicationInfo.uid));
} catch (Exception e) {
// ...
}
if (!isAvailable) {
skip = true;
}
}
if (skip) {
// 如果需要跳过，清理状态并调度下一个广播
r.receiver = null;
r.curFilter = null;
r.state = BroadcastRecord.IDLE;
scheduleBroadcastsLocked();
return;
}
// 如果接收者处理成功，更新状态并继续处理
r.state = BroadcastRecord.APP_RECEIVE; // 设置状态为APP_RECEIVE
// ...
// 启动进程并分发广播
// ...
}
}这段代码是Android广播系统中处理有序广播的下一个接收者的关键部分，它负责检查接收者的权限、AppOps、单例状态和应用可用性，如果所有检查通过，则更新广播记录的状态并继续分发广播。这个过程确保了只有符合条件的接收者才能接收到广播，维护了广播的安全性和正确性。
2.3 基于onReceive回调的分析
这里基于processNextBroadcast第一部分代码中关键方法deliverToRegisteredReceiverLocked的实现进行分析。该方法在processNextBroadcast中的上下文概要解读如下：
//BroadcastQueue
final void processNextBroadcast(boolean fromMsg) {
synchronized(mService) {
//第一阶段：派发广播给接收者
//...
// 处理所有并行广播
while (mParallelBroadcasts.size() > 0) {
//...
final int N = r.receivers.size(); // 获取广播接收器的数量
// 遍历所有广播接收器，并将广播分发给它们
for (int i = 0; i < N; i++) {
Object target = r.receivers.get(i);
deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false); // 分发广播给注册的接收器
}
addBroadcastToHistoryLocked(r); // 将广播记录添加到历史记录中，以便未来查询
}
//...
}
}该方法的目的是派发广播给接收者。代码实现如下：
//BroadcastQueue
private final void deliverToRegisteredReceiverLocked(BroadcastRecord r,
BroadcastFilter filter, boolean ordered) {
boolean skip = false; // 标记是否跳过当前接收器
//权限检查...
// 检查Intent Firewall是否允许广播
if (!skip) {
skip = !mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid,
r.callingPid, r.resolvedType, filter.receiverList.uid);
}
// 如果接收器所在的应用不存在或者正在崩溃，则跳过
if (filter.receiverList.app == null || filter.receiverList.app.crashing) {
skip = true;
}
// 如果所有检查都通过，则分发广播
if (!skip) {
if (ordered) {
// 对于有序广播，设置当前接收器和状态
r.receiver = filter.receiverList.receiver.asBinder();
r.curFilter = filter;
filter.receiverList.curBroadcast = r;
r.state = BroadcastRecord.CALL_IN_RECEIVE;
if (filter.receiverList.app != null) {
r.curApp = filter.receiverList.app;
filter.receiverList.app.curReceiver = r;
mService.updateOomAdjLocked(r.curApp); // 更新OOM调整
}
}
try {
// 这里会调用执行接收器的onReceive方法
performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
new Intent(r.intent), r.resultCode, r.resultData,
r.resultExtras, r.ordered, r.initialSticky, r.userId);
if (ordered) {
r.state = BroadcastRecord.CALL_DONE_RECEIVE; // 设置状态为CALL_DONE_RECEIVE
}
} catch (RemoteException e) {
//...
}
}
}这段代码负责将广播分发给已注册的接收器，但分发前，它会进行一系列的权限和状态检查，以确保只有符合条件的接收器才能处理广播。如果检查都通过，它会调用performReceiveLocked方法来执行接收器的onReceive方法，完成广播的分发。这个过程确保了广播的安全性和正确性，防止了不符合条件的接收器处理广播，从而保护了系统的稳定性和应用的数据安全。接下来就以onReceive的回调为目标继续分析。
2.3.1 从performReceiveLocked到onReceive方法调用的分析
performReceiveLocked的代码实现如下：
//BroadcastQueue
private static void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,
Intent intent, int resultCode, String data, Bundle extras,
boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
// 如果app不为空，说明接收器是注册在某个应用进程中的
if (app != null) {
// 如果app的线程不为空，说明应用进程是活跃的
if (app.thread != null) {
// 通过应用进程的线程代理，调度接收器的onReceive调用
app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
data, extras, ordered, sticky, sendingUser, app.repProcState);
} else {
// ...
}
} else {
// 如果app为空，说明接收器不是注册在某个应用进程中，直接调用接收器的performReceive方法
receiver.performReceive(intent, resultCode, data, extras, ordered,
sticky, sendingUser);
}
}如果分析过之前文章中的组件相关代码，这里的app.thread.scheduleRegisteredReceiver实际上就是调用的ActivityThread中的scheduleRegisteredReceiver方法，代码实现如下：
//ActivityThread
//ApplicationThread
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);
}这里的receiver实际上是LoadedApk.ReceiverDispatcher.InnerReceiver类型的，解读如下：
IIntentReceiver是一个接口，用于接收广播。当BroadcastReceiver是动态注册的，即在代码中通过Context.registerReceiver()方法注册的，那么IIntentReceiver的实现类是LoadedApk.ReceiverDispatcher.InnerReceiver。这个实现类持有一个对LoadedApk.ReceiverDispatcher的弱引用，而ReceiverDispatcher持有一个对BroadcastReceiver的强引用。
因此这里我们先看LoadedApk.ReceiverDispatcher.InnerReceiver的实现，代码如下：
//LoadedApk
//ReceiverDispatcher
final static class InnerReceiver extends IIntentReceiver.Stub {
// 弱引用，用于引用ReceiverDispatcher，防止内存泄漏
final WeakReference<LoadedApk.ReceiverDispatcher> mDispatcher;
// 强引用，用于在需要时保持ReceiverDispatcher的活跃状态
final LoadedApk.ReceiverDispatcher mStrongRef;
InnerReceiver(LoadedApk.ReceiverDispatcher rd, boolean strong) {
mDispatcher = new WeakReference<LoadedApk.ReceiverDispatcher>(rd); // 创建弱引用
mStrongRef = strong ? rd : null; // 如果strong为true，则创建强引用
}
// 实现IIntentReceiver接口的performReceive方法，该方法在收到广播时被调用
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
LoadedApk.ReceiverDispatcher rd = mDispatcher.get(); // 通过弱引用获取ReceiverDispatcher
if (rd != null) {
// 如果ReceiverDispatcher仍然存在，调用其performReceive方法处理广播
rd.performReceive(intent, resultCode, data, extras,
ordered, sticky, sendingUser);
} else {
// 如果ReceiverDispatcher不存在，说明它已经被垃圾回收
IActivityManager mgr = ActivityManagerNative.getDefault(); // 获取ActivityManager服务
try {
if (extras != null) {
extras.setAllowFds(false); // 确保Bundle中不包含文件描述符
}
// 通知ActivityManager广播已经处理完成
mgr.finishReceiver(this, resultCode, data, extras, false);
} catch (RemoteException e) {
//...
}
}
}
}这里的performReceive实际上是调用到LoadedApk.ReceiverDispatcher的performReceive方法，代码实现如下：
//LoadedApk
//ReceiverDispatcher
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
// 创建一个Args对象，封装了广播的所有参数
Args args = new Args(intent, resultCode, data, extras, ordered,
sticky, sendingUser);
// 尝试将Args对象投递到主线程的消息队列中
// 这个步骤是关键，因为它决定了是否在主线程中执行onReceive方法
if (!mActivityThread.post(args)) {
// 如果post失败，说明主线程（ActivityThread）无法处理这个Args对象
// 可能是因为主线程已经停止或者不存在了
if (mRegistered && ordered) {
// 获取ActivityManager服务的实例
IActivityManager mgr = ActivityManagerNative.getDefault();
// 通知ActivityManager广播接收已经完成
args.sendFinished(mgr);
}
}
}performReceive方法负责将广播分发给BroadcastReceiver的onReceive方法。如果BroadcastReceiver是动态注册的，那么它的onReceive方法将在应用的主线程中执行。如果主线程无法处理广播，那么对于有序广播，需要通知ActivityManager广播接收已经完成，以确保系统资源的正确释放和应用状态的更新。这个过程确保了广播的可靠性和应用响应的正确性。
这里我们关注mActivityThread.post(args)方法，这里直接调用了args.run方法，代码实现如下：
//LoadedApk
//ReceiverDispatcher
//Args
public void run() {
final BroadcastReceiver receiver = mReceiver; // 获取BroadcastReceiver实例
final boolean ordered = mOrdered; // 是否为有序广播
final IActivityManager mgr = ActivityManagerNative.getDefault(); // 获取ActivityManager服务
final Intent intent = mCurIntent; // 获取当前的Intent对象
mCurIntent = null; // 清空当前Intent对象，避免重复使用
// 如果receiver为null或者已经被遗忘（即BroadcastReceiver已经被unregister），则结束
if (receiver == null || mForgotten) {
if (mRegistered && ordered) {
sendFinished(mgr); // 通知ActivityManager广播接收完成
}
return;
}
try {
// 获取BroadcastReceiver的类加载器
ClassLoader cl = receiver.getClass().getClassLoader();
// 为Intent设置类加载器，以便正确解析其中的序列化对象
intent.setExtrasClassLoader(cl);
// 为Args对象设置类加载器
setExtrasClassLoader(cl);
// 设置BroadcastReceiver的PendingResult，以便它可以异步处理广播
receiver.setPendingResult(this);
// 调用BroadcastReceiver的onReceive方法
receiver.onReceive(mContext, intent);
} catch (Exception e) {
//...
}
// 如果BroadcastReceiver有PendingResult，调用finish方法处理结果
if (receiver.getPendingResult() != null) {
finish();
}
}run的这段代码它负责在主线程中执行BroadcastReceiver的onReceive方法。当然，这个过程包括获取BroadcastReceiver实例、设置类加载器、调用onReceive方法，并处理可能的异常。如果BroadcastReceiver有异步结果，它会在finish方法中被处理。这个过程确保了广播的可靠性和应用响应的正确性，同时也允许BroadcastReceiver异步处理广播。
2.3.2 onReceive后finish处理逻辑解读（额外解读）
最后，如果BroadcastReceiver有PendingResult，调用finish方法处理结果，finish的代码实现如下所示：
//BroadcastReceiver
//PendingResult
public final void finish() {
// 如果PendingResult的类型是TYPE_COMPONENT，即广播是通过组件（如Activity或Service）发送的
if (mType == TYPE_COMPONENT) {
final IActivityManager mgr = ActivityManagerNative.getDefault(); // 获取ActivityManager服务的实例
// 检查是否有其他挂起的工作（例如其他广播或任务）
if (QueuedWork.hasPendingWork()) {
// 如果有其他挂起的工作，使用单线程执行器来异步发送完成通知
QueuedWork.singleThreadExecutor().execute(new Runnable() {
@Override
public void run() {
sendFinished(mgr); // 通知ActivityManager广播处理完成
}
});
} else {
// 如果没有其他挂起的工作，直接发送完成通知
sendFinished(mgr);
}
} else if (mOrderedHint && mType != TYPE_UNREGISTERED) {
// 如果这是一个有序广播，并且类型不是未注册的
final IActivityManager mgr = ActivityManagerNative.getDefault(); // 获取ActivityManager服务的实例
sendFinished(mgr); // 通知ActivityManager广播处理完成
}
}PendingResult.finish方法确保了系统能够知道广播已经被接收器处理完毕。根据广播类型和系统状态，它可能会异步或同步地通知AMS。这里最后都会调用到sendFinished方法。该方法代码实现如下：
//BroadcastReceiver
//PendingResult
public void sendFinished(IActivityManager am) {
synchronized (this) {
//...
mFinished = true; // 标记广播为已处理完成
try {
// 如果有结果额外数据，并且包含了文件描述符，则不允许它们被传递
if (mResultExtras != null) {
mResultExtras.setAllowFds(false);
}
// 如果这是一个有序广播
if (mOrderedHint) {
// 通知ActivityManager广播接收完成，并传递结果码、数据、额外数据和是否中止广播
am.finishReceiver(mToken, mResultCode, mResultData, mResultExtras,
mAbortBroadcast);
} else {
// 如果不是有序广播，传递默认值
am.finishReceiver(mToken, 0, null, null, false);
}
} catch (RemoteException ex) {
//...
}
}
}sendFinished方法用于通知系统广播接收器已经完成处理。它确保了即使在多线程环境下也能安全地更新广播状态，主要是与AMS通信以完成广播的生命周期。这里am.finishReceiver最终调用的是AMS.finishReceiver，代码实现如下：
//AMS
public void finishReceiver(IBinder who, int resultCode, String resultData,
Bundle resultExtras, boolean resultAbort) {
final long origId = Binder.clearCallingIdentity();
try {
boolean doNext = false; // 标记是否需要处理下一个广播
BroadcastRecord r; // 用于存储当前广播记录
synchronized(this) {
// 根据传入的who（IBinder）找到对应的BroadcastRecord
r = broadcastRecordForReceiverLocked(who);
if (r != null) {
// 如果找到了对应的广播记录，调用finishReceiverLocked完成当前广播接收
// 并更新doNext标记是否需要处理下一个广播
doNext = r.queue.finishReceiverLocked(r, resultCode,
resultData, resultExtras, resultAbort, true);
}
}
// 如果需要处理下一个广播，调用processNextBroadcast处理
if (doNext) {
r.queue.processNextBroadcast(false);
}
// 修剪应用程序，优化内存使用
trimApplications();
} finally {
Binder.restoreCallingIdentity(origId);
}
}finishReceiver方法负责更新广播状态、如果需要则处理下一个广播，处理方式和之前的processNextBroadcast。