深刻Android系统（十一）AMS-4-广播管理
BroadcastReceiver 管理
Broadcast实质上是提供了一种更灵活的使用Intent的方式。java
不管是启动Activity，仍是Service，其实都是经过Intent的发送和过滤来调用应用中的功能，可是Activity、Service、ContentProvider所完成的功能是固定的android
而对于BroadcastReceiver能够作任意的事情，同时广播的发送和接收方式也更加丰富灵活shell
理解BroadcastReceiver
BroadcastReceiver是一种很简单的组件，甚至在ActivityThread中都没有管理它的数据结构。数组
BroadcastReceiver的本质就是经过Intent来执行应用中的一个方法，在应用中并不须要一个长期存在的对象安全
虽然应用中没有专门的数据结构来管理BroadcastReceiver，可是在AMS中仍是须要的，由于BroadcastReceiver能够在运行时动态向AMS注册，AMS中须要有数据结构来管理动态接收者markdown
BroadcastReceiver能够经过两种方式接收广播数据结构
- 经过
AndroidManifest中的<receiver/>标签注册 - 经过
AMS的registerReceiver()接口注册
关于广播使用上的知识你们能够在官网学习：广播基础知识app
咱们看下BroadcastReceiver类相关的重要定义：async
public abstract class BroadcastReceiver {
private PendingResult mPendingResult;
public abstract void onReceive(Context context, Intent intent);
public final PendingResult goAsync() {
PendingResult res = mPendingResult;
mPendingResult = null;
return res;
}
}
复制代码
实现一个广播接收器只须要继承BroadcastReceiver，而后实现它的抽象方法onReceive()就能够了。这也是最简单的广播的用法。ide
不过从BroadcastReceiver的类定义中还有一个mPendingResult变量和goAsync()方法，它们有什么做用呢？
它们主要是针对当接收到广播后须要作一些耗时操做，并且还有可能须要返回处理结果的状况
- 咱们知道
BroadcastReceiver对象的onReceive()若是长时间不返回，会引起ANR - 所以若是要执行耗时的操做，必须在其余线程中完成
mPendingResult变量的存在就是为了上述需求。而goAsync()方法提供了获取mPendingResult变量的接口。
从goAsync()方法的实现能够看到
- 方法在将
mPendingResult对象的指针返回后。同时也会将mPendingResult的值置为null
按照官方说法：
一旦执行了
goAsync()方法，在onReceive()结束前，须要将mPendingResult对象的指针传递到新线程中去，在新线程处理完成后必须调用mPendingResult对象的finish()方法来通知AMS。
咱们看下PendingResult的finish()方法：
public final void finish() {
if (mType == TYPE_COMPONENT) {
final IActivityManager mgr = ActivityManager.getService();
if (QueuedWork.hasPendingWork()) {
QueuedWork.queue(new Runnable() {
@Override public void run() {
if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
"Finishing broadcast after work to component " + mToken);
sendFinished(mgr);
}
}, false);
} else {
if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
"Finishing broadcast to component " + mToken);
sendFinished(mgr);
}
} else if (mOrderedHint && mType != TYPE_UNREGISTERED) {
if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
"Finishing broadcast to " + mToken);
final IActivityManager mgr = ActivityManager.getService();
sendFinished(mgr);
}
}
public void sendFinished(IActivityManager am) {
synchronized (this) {
...
try {
...
if (mOrderedHint) {
am.finishReceiver(mToken, mResultCode, mResultData, mResultExtras,
mAbortBroadcast, mFlags);
} else {
am.finishReceiver(mToken, 0, null, null, false, mFlags);
}
} catch (RemoteException ex) {
}
}
}
复制代码
核心操做就是调用AMS的finishReceiver()方法，这才是当前广播接收器的结束的标志。
正常状况下（没有执行过goAsync()）当onReceive()调用完成后，AMS检测到mPendingResult不为空，便会自动执行finish()方法，而对于执行过goAsync()的广播接收器，AMS便不会主动执行finish()了
这个
finish()方法很重要，本章最后也有它的身影
广播的分类
从广播的发送方式来划分，有4类广播。
- 普通广播：经过
Context中的方法sendBroadcast()和sendBroadcastAsUser()发送的广播属于普通广播。- 普通广播的特色是发送给系统当前的全部注册的接收者
- 接收者接收到广播的顺序也是不肯定的
- 有序广播：经过
Context中的方法sendOrderedBroadcast()和sendOrderedBroadcastAsUser()发送的广播属于有序广播。- 有序广播的发送顺序是按照接收者的优先级来决定的，系统默认范围是
-1000-1000，但实际上没有明确的数值限定，能够到int最大值 - 接收器的优先级经过匹配的
intent-filter的android:priority属性来控制 - 具备相同优先级的接收器将按随机顺序运行（这部分书中和官网的描述并不一致，看完源码再说啦）
- 当接收器逐个顺序执行时，接收器能够向下传递结果，也能够彻底停止广播，使其再也不传递给其余接收器
- 有序广播的发送顺序是按照接收者的优先级来决定的，系统默认范围是
- 粘性广播：经过
Context中的方法sendStickyBroadcast()和sendOrderedBroadcastAsUser()发送的广播属于粘性广播。- 和前两个广播不一样，粘性广播能将广播发送给系统中之后注册的接收者，甚至是新安装应用中的接收者
- 官网解释出于安全因素，在
Android 9上，这两个接口被标记为了Deprecated - 不过这并不影响它在
Framework中的使用，咱们看个官网的例子：
IntentFilter ifilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED); // 对于一个粘性广播来讲，注册监听时即可以获得当前电池状态的 Intent Intent batteryStatus = context.registerReceiver(null, ifilter); 复制代码 - 本地广播：经过
LocalBroadcastManager.sendBroadcast发送的广播属于本地广播- 本地广播会将广播发送给与发送者位于同一应用中的接收者
- 当不须要跨应用发送广播时，建议使用本地广播
- 这种实现方法的效率更高（无需进行进程间通讯）
- 并且无需担忧其余应用在收发广播时带来的任何安全问题
广播的数据结构
在AMS中，全部注册的广播接收者都放在成员变量mRegisteredReceivers中，定义以下：
final HashMap<IBinder, ReceiverList> mRegisteredReceivers = new HashMap<>();
复制代码
mRegisteredReceivers是一个HashMap，其中
-
key为接收者的IBinder对象 -
value为接收者的对象ReceiverList- 由于一个接收者中可能包含多个
IntentFilter，因此ReceiverList是一个数组
final class ReceiverList extends ArrayList<BroadcastFilter> 复制代码- 而
BroadcastFilter则是继承了IntentFilter，定义以下：
final class BroadcastFilter extends IntentFilter { final ReceiverList receiverList; // 所属 receiver 的引用 final String packageName; // 所在应用的包名 final String requiredPermission; // 发送广播时须要声明的权限字符串 final int owningUid; // 所在应用的 uid final int owningUserId; // 所在应用的 userid ... } 复制代码 - 由于一个接收者中可能包含多个
ReceiverList的关键定义以下：
final class ReceiverList extends ArrayList<BroadcastFilter> implements IBinder.DeathRecipient {
final ActivityManagerService owner;
public final IIntentReceiver receiver; // 用户进程中定义的 IntentReceiver
public final ProcessRecord app; // 所属用户进程的 ProcessRecord 对象
public final int pid; // 所属用户进程的pid
public final int uid; // 所属用户进程的uid
public final int userId; // 用户id
BroadcastRecord curBroadcast = null; //
boolean linkedToDeath = false; // 是否注册了 binder 死亡监听
}
复制代码
发送广播时，AMS中收到的广播消息首先会保存在mBroadcastQueues对象中，而后再发送给用户进程中的接收者。mBroadcastQueues是一个只有两个元素的数组，定义以下：
final BroadcastQueue[] mBroadcastQueues = new BroadcastQueue[2];
复制代码
此外，AMS中还定义了两个变量：
BroadcastQueue mFgBroadcastQueue;
BroadcastQueue mBgBroadcastQueue;
复制代码
AMS在构造方法中将这两个变量和mBroadcastQueues集合进行了关联：
public ActivityManagerService(Context systemContext) {
...
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
"foreground", BROADCAST_FG_TIMEOUT, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
"background", BROADCAST_BG_TIMEOUT, true);
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;
...
}
复制代码
mFgBroadcastQueue用来保存带有FLAG_RECEIVER_FOREGROUND标志的广播，它要求接收者进程以foreground的优先级运行，这样执行的更快。- 若是不特别指定，通常的广播都会保存在
mBgBroadcastQueue中
咱们看下BroadcastQueue类的主要结构：
public final class BroadcastQueue {
final ArrayList<BroadcastRecord> mParallelBroadcasts = new ArrayList<>();
final ArrayList<BroadcastRecord> mOrderedBroadcasts = new ArrayList<>();
}
复制代码
mParallelBroadcasts用来保存全部的普通广播mOrderedBroadcasts用来保存全部的有序广播
粘性广播在哪里呢？
系统中全部的粘性广播都保存在AMS的成员变量mStickyBroadcasts中，定义以下：
final SparseArray<ArrayMap<String, ArrayList<Intent>>> mStickyBroadcasts =
new SparseArray<ArrayMap<String, ArrayList<Intent>>>();
复制代码
mStickyBroadcasts是一个SparseArray类型的数组，使用用户Id做为索引，保存的是ArrayMap对象ArrayMap对象储存的是某个用户发送的全部的粘性广播，每条记录以Intent的action字符串做为索引，保存的内容是一个ArrayList对象ArrayList对象其中储存了包含该action的Intent
广播的注册过程
动态注册是经过接口registerReceiver()完成的。应用注册receiver时，并非直接调用AMS的接口来完成的，而是经过Context类中的方法，由于AMS的接口须要提供应用的ApplicationThread类的IBinder对象来做为参数，应用中获得这个对象比较麻烦。
Context中的registerReceiver()最终调用的是ContextImpl的registerReceiverInternal()方法，代码以下：
class ContextImpl{
private Intent registerReceiverInternal(BroadcastReceiver receiver, int userId, IntentFilter filter, String broadcastPermission, Handler scheduler, Context context, int flags) {
...
try {
final Intent intent = ActivityManager.getService().registerReceiver(
mMainThread.getApplicationThread(), mBasePackageName, rd, filter,
broadcastPermission, userId, flags);
if (intent != null) {
intent.setExtrasClassLoader(getClassLoader());
intent.prepareToEnterProcess();
}
return intent;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
复制代码
registerReceiverInternal()方法最终调用的是AMS的registerReceiver()方法，代码以下：
public Intent registerReceiver(IApplicationThread caller, String callerPackage, IIntentReceiver receiver, IntentFilter filter, String permission, int userId, int flags) {
// 确保不是 isolated 进程
enforceNotIsolatedCaller("registerReceiver");
ArrayList<Intent> stickyIntents = null;
ProcessRecord callerApp = null;
final boolean visibleToInstantApps
= (flags & Context.RECEIVER_VISIBLE_TO_INSTANT_APPS) != 0;
int callingUid;
int callingPid;
boolean instantApp;
synchronized(this) {
...
// 从注册信息中获取 action 信息
Iterator<String> actions = filter.actionsIterator();
if (actions == null) {
ArrayList<String> noAction = new ArrayList<String>(1);
noAction.add(null);
actions = noAction.iterator();
}
// 获取 user ID
int[] userIds = { UserHandle.USER_ALL, UserHandle.getUserId(callingUid) };
// 循环遍历 action
while (actions.hasNext()) {
String action = actions.next();
// 遍历每一个userID下的粘性广播Map
for (int id : userIds) {
// 获取特定userID下的粘性广播Map
ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(id);
if (stickies != null) {
// 从Map中查找集合中符合当前action信息的Intent集合
ArrayList<Intent> intents = stickies.get(action);
if (intents != null) {
if (stickyIntents == null) {
stickyIntents = new ArrayList<Intent>();
}
// 添加到 stickyIntents 集合中
stickyIntents.addAll(intents);
}
}
}
}
}
ArrayList<Intent> allSticky = null;
if (stickyIntents != null) {
// 粘性广播不为空
final ContentResolver resolver = mContext.getContentResolver();
// 查找全部符合符合当前请求的Intent
for (int i = 0, N = stickyIntents.size(); i < N; i++) {
Intent intent = stickyIntents.get(i);
...
if (filter.match(resolver, intent, true, TAG) >= 0) {
if (allSticky == null) {
allSticky = new ArrayList<Intent>();
}
allSticky.add(intent);
}
}
}
// The first sticky in the list is returned directly back to the client.
Intent sticky = allSticky != null ? allSticky.get(0) : null;
// 若是注册时传入的 receiver 为空
// 此处直接返回 sticky 对象
if (receiver == null) {
return sticky;
}
synchronized (this) {
if (callerApp != null && (callerApp.thread == null
|| callerApp.thread.asBinder() != caller.asBinder())) {
// Original caller already died
return null;
}
// 检查注册的 receiver 是否已经注册过了
ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder());
if (rl == null) {
// rl为空说明没有注册过
// 新建对象
rl = new ReceiverList(this, callerApp, callingPid, callingUid,
userId, receiver);
if (rl.app != null) {
// 若是指定了进程对象，则把receiver保存在进程对象中
// 方便进程销毁时能及时释放该对象
final int totalReceiversForApp = rl.app.receivers.size();
if (totalReceiversForApp >= MAX_RECEIVERS_ALLOWED_PER_APP) {
throw new IllegalStateException(...);
}
rl.app.receivers.add(rl);
} else {
// 若是没有指定进程对象，则注册receiver的死亡通知
try {
receiver.asBinder().linkToDeath(rl, 0);
} catch (RemoteException e) {
return sticky;
}
rl.linkedToDeath = true;
}
mRegisteredReceivers.put(receiver.asBinder(), rl);// 保存新建的 rl
}
...
// 下面主要是针对 receiver 重复注册的状况
BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,
permission, callingUid, userId, instantApp, visibleToInstantApps);
if (rl.containsFilter(filter)) {
// 已经包含了本次提交filter，简单打印，不作其余处理
Slog.w(TAG, "Receiver with filter " + filter
+ " already registered for pid " + rl.pid
+ ", callerPackage is " + callerPackage);
} else {
// 未包含本次提交的filter，添加到集合中
rl.add(bf);
if (!bf.debugCheck()) {
Slog.w(TAG, "==> For Dynamic broadcast");
}
mReceiverResolver.addFilter(bf);
}
// 继续处理粘性广播部分
if (allSticky != null) {
ArrayList receivers = new ArrayList();
receivers.add(bf);
final int stickyCount = allSticky.size();
for (int i = 0; i < stickyCount; i++) {
Intent intent = allSticky.get(i);
// 根据 intent 中的标志获取发送队列（bg仍是fg）
BroadcastQueue queue = broadcastQueueForIntent(intent);
// 建立新的广播对象
BroadcastRecord r = new BroadcastRecord(queue, intent, null,
null, -1, -1, false, null, null, OP_NONE, null, receivers,
null, 0, null, null, false, true, true, -1);
// 将广播加入队列
queue.enqueueParallelBroadcastLocked(r);
// 发送 Intent 到指定进程
queue.scheduleBroadcastsLocked();
}
}
return sticky;
}
}
复制代码
registerReceiver()方法看上去比较复杂，其实不少都是针对粘性（sticky）广播的：
-
若是没有处理粘性（
sticky）广播，只须要检查receiver是否已经注册- 没有注册过，就能够建立用来保存
receiver的对象ReceiverList，并把它添加到mRegisteredReceivers集合中 - 注册过的
receiver能够重复注册，只要pid、``uid和userid相同就能够- 重复注册用于向某个
receiver增长新的IntentFilter
- 重复注册用于向某个
- 没有注册过，就能够建立用来保存
-
而对于粘性（
sticky）广播- 若是调用
registerReceiver()时参数receiver为null，则马上返回找到的第一个粘性广播的Intent - 不然，将查找系统中全部和注册时传入的
Intent匹配的粘性广播，并经过BroadcastQueue来发送
- 若是调用
咱们再来看下广播的发送过程
广播的发送过程
应用发送广播调用的是Context类中的方法，发送广播的方法虽然不少，最后都是调用AMS的broadcastIntent()方法。
broadcastIntent()方法简单检查了调用者的权限后，转调内部方法broadcastIntentLocked()来完成广播发送。
broadcastIntentLocked()方法会
-
先检查要广播的
Intent- 若是是一些系统
Intent，则调用相应的方法处理 - 若是是粘性广播，则把广播的
Intent加入AMS的粘性广播列表中
- 若是是一些系统
-
最后查找全部的接收者，逐个调用它们
广播发送的时序图以下：
AMS.broadcastIntentLocked
咱们看下具体实现：
final int broadcastIntentLocked(...) {
intent = new Intent(intent);
...
userId = mUserController.handleIncomingUser(callingPid, callingUid, userId, true,
ALLOW_NON_FULL, "broadcast", callerPackage);
// 检查发送广播的用户是否正在运行
if (userId != UserHandle.USER_ALL && !mUserController.isUserOrItsParentRunning(userId)) {
if ((callingUid != SYSTEM_UID
|| (intent.getFlags() & Intent.FLAG_RECEIVER_BOOT_UPGRADE) == 0)
&& !Intent.ACTION_SHUTDOWN.equals(intent.getAction())) {
return ActivityManager.BROADCAST_FAILED_USER_STOPPED;
}
}
final String action = intent.getAction();
...
// 检查广播是否为 protected
final boolean isProtectedBroadcast;
try {
isProtectedBroadcast = AppGlobals.getPackageManager().isProtectedBroadcast(action);
} catch (RemoteException e) {
Slog.w(TAG, "Remote exception", e);
return ActivityManager.BROADCAST_SUCCESS;
}
// 确认发送广播的进程是否为 system
final boolean isCallerSystem;
switch (UserHandle.getAppId(callingUid)) {
case ROOT_UID:
case SYSTEM_UID:
case PHONE_UID:
case BLUETOOTH_UID:
case NFC_UID:
case SE_UID:
isCallerSystem = true;
break;
default:
isCallerSystem = (callerApp != null) && callerApp.persistent;
break;
}
if (!isCallerSystem) {
if (isProtectedBroadcast) {
// 不是system进程，可是发送的广播倒是 protected 的状况
// 抛出安全异常
...
throw new SecurityException(msg);
} else if (AppWidgetManager.ACTION_APPWIDGET_CONFIGURE.equals(action)
|| AppWidgetManager.ACTION_APPWIDGET_UPDATE.equals(action)) {
// 不是 system 进程，也不是 protected 广播
// 可是，有一些特殊的广播仍是不能发送，这里作一些限制
if (callerPackage == null) {
...
throw new SecurityException(msg);
} else if (intent.getComponent() != null) {
if (!intent.getComponent().getPackageName().equals(
callerPackage)) {
String msg = "Permission Denial: not allowed to send broadcast "
+ action + " to "
+ intent.getComponent().getPackageName() + " from "
+ callerPackage;
...
throw new SecurityException(msg);
}
} else {
// Limit broadcast to their own package.
intent.setPackage(callerPackage);
}
}
}
if (action != null) {
// 从 SystemConfig 中查询当前 action 是否在 allow-implicit-broadcast 标签中
// 就是查查当前 action 是否支持隐式广播
if (getBackgroundLaunchBroadcasts().contains(action)) {
...
// 若是是，增长一个Flag标记
// 这个标记就代表这个广播能够做为隐式广播发送
intent.addFlags(Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND);
}
switch (action) {
// 检查处理一些特殊的 action
// 这部分主要是检查和 PMS 有关的一些操做
case Intent.ACTION_UID_REMOVED:
case Intent.ACTION_PACKAGE_REMOVED:
case Intent.ACTION_PACKAGE_CHANGED:
...
// 若是这个广播时从 PMS 来的，并且是关于应用删除或应用变化
// 须要从 task 中移除全部和该应用管理的 Activity
break;
...
case "com.android.launcher.action.INSTALL_SHORTCUT":
// As of O, we no longer support this broadcasts, even for pre-O apps.
// Apps should now be using ShortcutManager.pinRequestShortcut().
Log.w(TAG, "Broadcast " + action
+ " no longer supported. It will not be delivered.");
return ActivityManager.BROADCAST_SUCCESS;
}
...
}
// 对于粘性广播
if (sticky) {
// 检查广播发送方是否声明了 android.permission.BROADCAST_STICKY 权限
if (checkPermission(android.Manifest.permission.BROADCAST_STICKY,
callingPid, callingUid)
!= PackageManager.PERMISSION_GRANTED) {
...
throw new SecurityException(msg);
}
if (requiredPermissions != null && requiredPermissions.length > 0) {
// 发送粘性广播不能指定 permission
return ActivityManager.BROADCAST_STICKY_CANT_HAVE_PERMISSION;
}
if (intent.getComponent() != null) {
// 粘性广播不能指定特定组件名
throw new SecurityException(
"Sticky broadcasts can't target a specific component");
}
if (userId != UserHandle.USER_ALL) {
// 若是广播不是发给全部用户，先检查是否存在一个发给全部用户的相同的广播
ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(UserHandle.USER_ALL);
if (stickies != null) {
ArrayList<Intent> list = stickies.get(intent.getAction());
if (list != null) {
int N = list.size();
int i;
for (i=0; i<N; i++) {
if (intent.filterEquals(list.get(i))) {
// 检测到存在相同的广播，抛出异常
throw new IllegalArgumentException(
"Sticky broadcast " + intent + " for user "
+ userId + " conflicts with existing global broadcast");
}
}
}
}
}
// 将广播保存到 mStickyBroadcasts 中
ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(userId);
if (stickies == null) {
stickies = new ArrayMap<>();
mStickyBroadcasts.put(userId, stickies);
}
// 添加 Intent 信息列表
ArrayList<Intent> list = stickies.get(intent.getAction());
if (list == null) {
list = new ArrayList<>();
stickies.put(intent.getAction(), list);
}
final int stickiesCount = list.size();
int i;
for (i = 0; i < stickiesCount; i++) {
if (intent.filterEquals(list.get(i))) {
// 若是 Intent 已经存在，覆盖
list.set(i, new Intent(intent));
break;
}
}
if (i >= stickiesCount) {
list.add(new Intent(intent));
}
}
int[] users;
if (userId == UserHandle.USER_ALL) {
// 广播给全部用户的状况，获取全部的用户id
users = mUserController.getStartedUserArray();
} else {
// 广播给特定用户
users = new int[] {userId};
}
// 计算全部接收该 Intent 的 receiver
List receivers = null;
List<BroadcastFilter> registeredReceivers = null;
if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
// 若是 Intent 中没有指定 FLAG_RECEIVER_REGISTERED_ONLY
// 收集静态接收者
receivers = collectReceiverComponents(intent, resolvedType, callingUid, users);
}
if (intent.getComponent() == null) {
// 若是没有指定 Component，则查找匹配该 Intent 的全部 receiver
if (userId == UserHandle.USER_ALL && callingUid == SHELL_UID) {
// 针对发送给全部用户的广播，而且发送广播的 user 是 shell
for (int i = 0; i < users.length; i++) {
// 遍历 userID
...
// 从 mReceiverResolver 中查找，动态注册的广播接收者都在这里
List<BroadcastFilter> registeredReceiversForUser = mReceiverResolver.queryIntent(intent, resolvedType, false /*defaultOnly*/, users[i]);
if (registeredReceivers == null) {
registeredReceivers = registeredReceiversForUser;
} else if (registeredReceiversForUser != null) {
registeredReceivers.addAll(registeredReceiversForUser);
}
}
} else {
registeredReceivers = mReceiverResolver.queryIntent(intent, resolvedType, false /*defaultOnly*/, userId);
}
}
final boolean replacePending =
(intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;
int NR = registeredReceivers != null ? registeredReceivers.size() : 0;
if (!ordered && NR > 0) {
// 若是不是有序广播，也就是普通广播的状况
if (isCallerSystem) {
checkBroadcastFromSystem(intent, callerApp, callerPackage, callingUid,
isProtectedBroadcast, registeredReceivers);
}
// 获取发送队列
final BroadcastQueue queue = broadcastQueueForIntent(intent);
// 建立 BroadcastRecord 对象
BroadcastRecord r = new BroadcastRecord(...);
...
if (!replaced) {
queue.enqueueParallelBroadcastLocked(r); // 加入到并行队列中
queue.scheduleBroadcastsLocked(); // 发送广播
}
registeredReceivers = null;
NR = 0;
}
int ir = 0;
if (receivers != null) {
// 说明存在静态注册的接收者
...
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 {
// Skip to the next ResolveInfo in the final list.
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(...);
...
final BroadcastRecord oldRecord =
replacePending ? queue.replaceOrderedBroadcastLocked(r) : null;
if (oldRecord != null) {
// 若是存在旧的广播，调用 performReceiveLocked 执行广播
if (oldRecord.resultTo != null) {
final BroadcastQueue oldQueue = broadcastQueueForIntent(oldRecord.intent);
try {
// 这个方法就会调用到 onReceived()
oldQueue.performReceiveLocked(...);
} catch (RemoteException e) {
...
}
}
} else {
queue.enqueueOrderedBroadcastLocked(r); // 将广播加入到order队列
queue.scheduleBroadcastsLocked(); // 发送广播
}
}
...
return ActivityManager.BROADCAST_SUCCESS;
}
复制代码
broadcastIntentLocked()方法比较长，咱们再简单梳理下：
- 首先是检查发送的广播是否为一些特殊的广播
- 尤为是从
PMS中发出的有关应用安装变化相关的广播
- 尤为是从
- 接下来是判断是否为粘性广播，若是是
- 先是检查一些相关的权限，好比粘性广播不能带有
permission，并且Intent必须指定Component - 而后建立对应的数据结构，并添加到
mStickyBroadcasts集合中
- 先是检查一些相关的权限，好比粘性广播不能带有
- 而后查找该广播对应的广播接收者
- 若是是普通广播，会优先发给动态接收者
- 若是是有序广播，会将动态接收者和静态接收者一块儿根据优先级排序，而后再建立
BroadcastRecord对象并添加到有序广播队列中
- 最后，经过
scheduleBroadcastsLocked()发送广播
从上面的代码实现上能够看到，不管哪一种广播，静态接收者之间必定会排序，并且相同优先级下，静态接收者会排在动态接收者以前。
为何静态接收者必定要放到有序队列呢？
对于静态接收者来讲，它所属的进程可能已经在运行，也可能没有。若是进程没有运行，就须要先启动它。首先进程的启动是一个耗时过程，并且启动有可能失败，这个过程只能逐一处理，不能简单的群发消息。
到这里，广播接收者和广播内容都已经检查准备好了，咱们继续学习scheduleBroadcastsLocked()广播发送的过程
BroadcastQueue.scheduleBroadcastsLocked
scheduleBroadcastsLocked()方法只是发送了一个BROADCAST_INTENT_MSG消息，代码以下：
public void scheduleBroadcastsLocked() {
...
mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
mBroadcastsScheduled = true;
}
复制代码
BROADCAST_INTENT_MSG消息的处理是调用processNextBroadcast()方法
case BROADCAST_INTENT_MSG: {
...
processNextBroadcast(true);
} break;
final void processNextBroadcast(boolean fromMsg) {
synchronized (mService) {
processNextBroadcastLocked(fromMsg, false);
}
}
复制代码
调用到了processNextBroadcastLocked()方法。这个方法比较长，咱们简要分析：
final void processNextBroadcastLocked(boolean fromMsg, boolean skipOomAdj) {
BroadcastRecord r;
...
// 循环处理 mParallelBroadcasts 集合中的消息
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);
...
// 调用通知 receiver
deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);
}
addBroadcastToHistoryLocked(r);
}
// 接下来处理 mPendingBroadcast 集合
// 这个集合存放的是等待进程启动的广播
if (mPendingBroadcast != null) {
...
boolean isDead;
if (mPendingBroadcast.curApp.pid > 0) {
synchronized (mService.mPidsSelfLocked) {
ProcessRecord proc = mService.mPidsSelfLocked.get(
mPendingBroadcast.curApp.pid);
isDead = proc == null || proc.crashing;
}
} else {
final ProcessRecord proc = mService.mProcessNames.get(
mPendingBroadcast.curApp.processName, mPendingBroadcast.curApp.uid);
isDead = proc == null || !proc.pendingStart;
}
if (!isDead) {
// It's still alive, so keep waiting
return;
} else {
Slog.w(TAG, "pending app ["
+ mQueueName + "]" + mPendingBroadcast.curApp
+ " died before responding to broadcast");
mPendingBroadcast.state = BroadcastRecord.IDLE;
mPendingBroadcast.nextReceiver = mPendingBroadcastRecvIndex;
mPendingBroadcast = null;
}
}
// 处理 mOrderedBroadcasts 中的广播
boolean looped = false;
do {
...
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();
// forground 的 mTimeoutPeriod 超时是 10*1000
// bgground 的 mTimeoutPeriod 超时是 60*1000
if ((numReceivers > 0) && (now > r.dispatchTime + (2*mTimeoutPeriod*numReceivers))) {
// 若是超时则终止广播
...
broadcastTimeoutLocked(false); // forcibly finish this broadcast
forceReceive = true;
r.state = BroadcastRecord.IDLE;
}
}
...
if (r.receivers == null || r.nextReceiver >= numReceivers
|| r.resultAbort || forceReceive) {
// 没有多余的 receiver 了
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) {
r.resultTo = null;
...
}
}
...
}
} while (r == null);
...
if (nextReceiver instanceof BroadcastFilter) {
BroadcastFilter filter = (BroadcastFilter)nextReceiver;
...
// 发送给接收者进程
deliverToRegisteredReceiverLocked(r, filter, r.ordered, recIdx);
if (r.receiver == null || !r.ordered) {
...
// 已经处理完成的状况
r.state = BroadcastRecord.IDLE;
// 处理下一条广播
scheduleBroadcastsLocked();
} else {
if (brOptions != null && brOptions.getTemporaryAppWhitelistDuration() > 0) {
scheduleTempWhitelistLocked(filter.owningUid,
brOptions.getTemporaryAppWhitelistDuration(), r);
}
}
return;
}
...
ProcessRecord app = mService.getProcessRecordLocked(targetProcess,
info.activityInfo.applicationInfo.uid, false);
...
if (app != null && app.thread != null && !app.killed) {
// 若是是静态接收者，而且接收者对应的进程已经启动的状况
try {
app.addPackage(info.activityInfo.packageName,
info.activityInfo.applicationInfo.versionCode, mService.mProcessStats);
// 调用 processCurBroadcastLocked 通知 receiver
processCurBroadcastLocked(r, app, skipOomAdj);
// 直接返回
return;
}
...
}
...
// 走到这里说明进程没有启动，先调用 startProcessLocked 启动进程
if ((r.curApp=mService.startProcessLocked(...)) == null) {
....
// 若是进程启动失败，处理下一条广播
scheduleBroadcastsLocked();
r.state = BroadcastRecord.IDLE;
return;
}
mPendingBroadcast = r;
mPendingBroadcastRecvIndex = recIdx;
}
复制代码
processNextBroadcastLocked()方法也只是对要发送的广播接收者的集合进行的遍历发送处理，真正通知到应用的部分是在deliverToRegisteredReceiverLocked()方法中，咱们具体看下。
BroadcastQueue.deliverToRegisteredReceiverLocked
方法以下：
private void deliverToRegisteredReceiverLocked(BroadcastRecord r, BroadcastFilter filter, boolean ordered, int index) {
...
performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
new Intent(r.intent), r.resultCode, r.resultData,
r.resultExtras, r.ordered, r.initialSticky, r.userId);
...
}
void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver, Intent intent, int resultCode, String data, Bundle extras, boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
// Send the intent to the receiver asynchronously using one-way binder calls.
if (app != null) {
if (app.thread != null) {
...
app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
data, extras, ordered, sticky, sendingUser, app.repProcState);
...
}
} else {
receiver.performReceive(intent, resultCode, data, extras, ordered,
sticky, sendingUser);
}
}
复制代码
咱们已经在performReceiveLocked方法中明显看到app.thread字样了，这也就意味着开始去调用应用进程中的接口了，也就是ActivityThread中的scheduleRegisteredReceiver()接口，以下：
public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent, int resultCode, String dataStr, Bundle extras, boolean ordered, boolean sticky, int sendingUser, int processState) throws RemoteException {
...
receiver.performReceive(intent, resultCode, dataStr, extras, ordered,
sticky, sendingUser);
}
复制代码
ActivityThread调用的是IIntentReceiver的performReceive()方法
IIntentReceiver是一个AIDL，跟踪实现是在LoadedApk中，具体的装配过程是在ContextImpl初始化时完成的
咱们看下在LoadedApk中的关键定义
LoadedApk.performReceive
代码以下：
class LoadedApk{
static final class ReceiverDispatcher {
final static class InnerReceiver extends IIntentReceiver.Stub {
...
@Override
public void performReceive(...) {
final LoadedApk.ReceiverDispatcher rd;
...
// 调用内部的 performReceive() 方法
rd.performReceive(...);
...
}
}
...
public void performReceive(...) {
final Args args = new Args(...);
...
// 此处重点是执行经过 Args.getRunnable() 获取的 Runnable 对象
// Runnable 对象中执行了 onReceive() 方法回调
if (intent == null || !mActivityThread.post(args.getRunnable())) {
if (mRegistered && ordered) {
IActivityManager mgr = ActivityManager.getService();
...
args.sendFinished(mgr);
}
}
}
final class Args extends BroadcastReceiver.PendingResult {
...
public final Runnable getRunnable() {
return () -> {
final BroadcastReceiver receiver = mReceiver;
...
try {
...
// onReceive 回调
receiver.onReceive(mContext, intent);
}
...
if (receiver.getPendingResult() != null) {
// mPendingResult 不为空，自动执行 finish()
finish();
}
};
}
}
}
}
复制代码
这样一个广播的发送就结束了。。。
AMS的章节终因而磕磕绊绊的学完了，不少细节没有掌握，好在总体流程上暂时还留有印象。留此笔记方便复习
下一篇学习Android的图形显示系统，加油💪
相关文章
- 1. 深刻Android系统（十一）AMS-2-Activity生命周期管理
- 2. 深刻Android系统（十一）AMS-3-Service和ContentProvider管理
- 3. [Android] Android系统广播Action
- 4. 《Android深刻透析》之广播(Broadcast)
- 5. 深刻Android系统（一）Build系统
- 6. Android系统广播处理机制
- 7. android 系统广播大全
- 8. Android 系统广播大全
- 9. Android系统广播(3)–客户端广播处理流程
- 10. 深刻Android系统（八）Android的资源管理
- 更多相关文章...
- • Swarm 集群管理 - Docker教程
- • Maven 依赖管理 - Maven教程
- • Docker容器实战(七) - 容器眼光下的文件系统
- • 算法总结-广度优先算法
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. vs2019运行opencv图片显示代码时，窗口乱码
- 2. app自动化 - 元素定位不到？别慌，看完你就能解决
- 3. 在Win8下用cisco ××× Client连接时报Reason 422错误的解决方法
- 4. eclipse快速补全代码
- 5. Eclipse中Java/Html/Css/Jsp/JavaScript等代码的格式化
- 6. idea+spring boot +mabitys(wanglezapin)+mysql (1)
- 7. 勒索病毒发生变种 新文件名将带有“.UIWIX”后缀
- 8. 【原创】Python 源文件编码解读
- 9. iOS9企业部署分发问题深入了解与解决
- 10. 安装pytorch报错CondaHTTPError：******
欢迎关注本站公众号,获取更多信息
相关文章