hi，粉丝朋友大家好！
今天是2-8号，也是我春节第一天正式开工的日子，在这里首先祝大家新的一年技术进步，与千里马共同学习共同进步，共同升职加薪。今天要给大家分享的一个课题是大家都很熟悉的广播。
这里将要分为2个部分来对广播进行分析：
入门课，实战课，跨进程专题
ps需要学习深入framework课程和课程优惠
（可以加我qq：2102309716 优惠购买）
1、广播发送部分
一般我们正常使用发送广播都会有调用一个context的sendBroadcas，方法原型如下：
public void sendBroadcast(Intent intent)；
这里我们一般就是只想要传递一个intent参数既可以，这里调用context方法，其实和上一节讲解service一样，最后都会调用到ContextImpl方法中的sendBroadcast：
@Override
public void sendBroadcast(Intent intent) {
warnIfCallingFromSystemProcess();
String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());
try {
intent.prepareToLeaveProcess(this);//只是对intent进行一下预处理
ActivityManager.getService().broadcastIntent(
mMainThread.getApplicationThread(), intent, resolvedType, null,
Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, null, false, false,
getUserId());//最后调用到了AMS里面的broadcastIntent
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
下面来看AMS的broadcastIntent方法，这里我们暂时只分析最常见的一类平行广播，不看有序部分，感兴趣可以自己分析：
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 realCallingUid,
int realCallingPid, int userId, boolean allowBackgroundActivityStarts) {
//省略部分
// Figure out who all will receive this broadcast.
List receivers = null;
List<BroadcastFilter> registeredReceivers = null;//获取接受者的List
// Need to resolve the intent to interested receivers...
if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY)
== 0) {
receivers = collectReceiverComponents(intent, resolvedType, callingUid, users);
}
if (intent.getComponent() == null) {
//具体根据intent进行filter获取接受者的List
if (userId == UserHandle.USER_ALL && callingUid == SHELL_UID) {
// Query one target user at a time, excluding shell-restricted users
for (int i = 0; i < users.length; i++) {
if (mUserController.hasUserRestriction(
UserManager.DISALLOW_DEBUGGING_FEATURES, users[i])) {
continue;
}
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);
}
}
if (!ordered && NR > 0) {
final BroadcastQueue queue = broadcastQueueForIntent(intent);
BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
callerPackage, callingPid, callingUid, callerInstantApp, resolvedType,
requiredPermissions, appOp, brOptions, registeredReceivers, resultTo,
resultCode, resultData, resultExtras, ordered, sticky, false, userId,
allowBackgroundActivityStarts, timeoutExempt);//构造出一个BroadcastRecord
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Enqueueing parallel broadcast " + r);
final boolean replaced = replacePending
&& (queue.replaceParallelBroadcastLocked(r) != null);
// Note: We assume resultTo is null for non-ordered broadcasts.
if (!replaced) {
queue.enqueueParallelBroadcastLocked(r);//插入平行广播队列
queue.scheduleBroadcastsLocked();
}
registeredReceivers = null;
NR = 0;
}
//省略部分
return ActivityManager.BROADCAST_SUCCESS;
}
接下来看看最重要的enqueueParallelBroadcastLocked和scheduleBroadcastsLocked部分：
public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
mParallelBroadcasts.add(r);//这里动作很简单就是把BroadcastRecord插入到mParallelBroadcasts这个list
enqueueBroadcastHelper(r);
}
接下来看scheduleBroadcastsLocked：
public void scheduleBroadcastsLocked() {
//省略部分
mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
mBroadcastsScheduled = true;
}
这里其实就只是发送了一个BROADCAST_INTENT_MSG消息：
来看看对这个消息的处理
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 ["
+ mQueueName + "]");
processNextBroadcast(true);//调用了processNextBroadcast方法
} break;
case BROADCAST_TIMEOUT_MSG: {
synchronized (mService) {
broadcastTimeoutLocked(true);
}
} break;
}
}
}
这里我们来看processNextBroadcast：
final void processNextBroadcast(boolean fromMsg) {
synchronized (mService) {
processNextBroadcastLocked(fromMsg, false);
}
}
重点看看processNextBroadcastLocked：
final void processNextBroadcastLocked(boolean fromMsg, boolean skipOomAdj) {
BroadcastRecord r;
while (mParallelBroadcasts.size() > 0) {
r = mParallelBroadcasts.remove(0);//获取平行广播的BroadcastRecord对象
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);//这里是核心调用了deliverToRegisteredReceiverLocked方法
}
addBroadcastToHistoryLocked(r);
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Done with parallel broadcast ["
+ mQueueName + "] " + r);
}
//省略部分
}
下面来看deliverToRegisteredReceiverLocked方法：
private void deliverToRegisteredReceiverLocked(BroadcastRecord r,
BroadcastFilter filter, boolean ordered, int index) {
//省略部分
try {
if (filter.receiverList.app != null && filter.receiverList.app.inFullBackup) {
//省略部分
} else {
r.receiverTime = SystemClock.uptimeMillis();
maybeAddAllowBackgroundActivityStartsToken(filter.receiverList.app, r);
performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
new Intent(r.intent), r.resultCode, r.resultData,
r.resultExtras, r.ordered, r.initialSticky, r.userId);
//最重要调用了performReceiveLocked
//省略部分
}
//省略部分
} catch (RemoteException e) {
//省略部分
}
}
接下来重点看performReceiveLocked：
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) {
try {
//调用到了具体应用进程的scheduleRegisteredReceiver方法
app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
data, extras, ordered, sticky, sendingUser, app.getReportedProcState());
} catch (RemoteException ex) {
//省略
}
} else {
throw new RemoteException("app.thread must not be null");
}
} else {
receiver.performReceive(intent, resultCode, data, extras, ordered,
sticky, sendingUser);
}
}
这里的scheduleRegisteredReceiver方法是在应用进程的ActivityThread类中实现的：
// 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, int sendingUser, int processState) throws RemoteException {
updateProcessState(processState, false);
receiver.performReceive(intent, resultCode, dataStr, extras, ordered,
sticky, sendingUser);
}
这里会调用到receiver的performReceive方法，其中IIntentReceiver实际实在LoadedApk.java中：
final static class InnerReceiver extends IIntentReceiver.Stub {
//省略
@Override
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
final LoadedApk.ReceiverDispatcher rd;
//省略
if (rd != null) {
rd.performReceive(intent, resultCode, data, extras,
ordered, sticky, sendingUser);
} else {
//省略
}
}
}
这里就调用了 LoadedApk.ReceiverDispatcher的performReceive方法，其中ReceiverDispatcher也在LoadedApk.java：
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())) {
//这句mActivityThread.post(args.getRunnable())是核心
if (mRegistered && ordered) {
IActivityManager mgr = ActivityManager.getService();
if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
"Finishing sync broadcast to " + mReceiver);
args.sendFinished(mgr);
}
}
}
这里mActivityThread.post(args.getRunnable())是核心，就是往主线程post了一个runnable，我们来看getRunnable这个方法：
public final Runnable getRunnable() {
return () -> {
//省略部分
try {
ClassLoader cl = mReceiver.getClass().getClassLoader();
intent.setExtrasClassLoader(cl);
intent.prepareToEnterProcess();
setExtrasClassLoader(cl);
receiver.setPendingResult(this);
receiver.onReceive(mContext, intent);//调用到具体应用广播接收器的onReceive
} catch (Exception e) {
//省略部分
};
}
}
主要就 receiver.onReceive(mContext, intent)这里就调用到具体应用广播接收器的onReceive，也就是我们经常onReceive写处理业务地方
总结图如下：
2、广播注册接受部分
下一节讲解
扫一扫
1568
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
