BroadcastReceiver源码分析

1.1 registerReceiver调用的是Context的registerReceiver

---

我们查看App进程发起注册，ContextImpl的registerReceiver

@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();

}

}

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();

}

}

1、IIntentReceiver是一个Binder对象，传递给AMS用于AMS回调App进程，回调的方法是performReceive。一个Context和一个BroadcaseReceiver构成一个二元组，确定一个IIntentReceiver

AMS -> IIntentReceiver -> ReceiverDispatcher -> BroadcastReceiver

2、mPackageInfo.getReceiverDispatcher 构建接收器

3、ActivityManager.getService().registerReceiver()通知AMS注册接收器

1.2 AMS端处理注册

---

public Intent registerReceiver(IApplicationThread caller, String callerPackage,

IIntentReceiver receiver, IntentFilter filter, String permission, int userId,

int flags) {

···

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);

}

mRegisteredReceivers.put(receiver.asBinder(), rl);

}

BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,

permission, callingUid, userId, instantApp, visibleToInstantApps);

rl.add(bf);

mReceiverResolver.addFilter(bf);

}

}

1 mRegisteredReceivers是个HashMap<IBinder, ReceiverList>，这个Binder就是IIntentReceiver，ReceiverList记录了所有的这个与IIntentReceiver对应的接收者，将注册接收者添加到Map中

二、普通广播发送后的动态接收

============================================================================

2.1 调用Context的sendBroadcast

---

最后会调用到

ContextImpl.java

public void sendBroadcast(Intent intent) {

warnIfCallingFromSystemProcess();

String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());

intent.prepareToLeaveProcess(this);

ActivityManager.getService().broadcastIntent(

mMainThread.getApplicationThread(), intent, resolvedType, null,

Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, null, false, false,

getUserId());

}

2.2 AMS处理broadcastIntent

---

ActivityManagerService.java

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) {

···

int res = broadcastIntentLocked(callerApp,

callerApp != null ? callerApp.info.packageName : null,

intent, resolvedType, resultTo, resultCode, resultData, resultExtras,

requiredPermissions, appOp, bOptions, serialized, sticky,

callingPid, callingUid, userId);

···

}

}

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){

···

//1 找到匹配的Receiver列表

registeredReceivers = mReceiverResolver.queryIntent(intent,

resolvedType, false /defaultOnly/, userId);

int NR = registeredReceivers != null ? registeredReceivers.size() : 0;

//是否是有序广播，并且存在接收者

if (!ordered && NR > 0) {

//取出普通任务queue

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);

//添加到并行分发queue

queue.enqueueParallelBroadcastLocked®;

//开始分发广播

queue.scheduleBroadcastsLocked();

registeredReceivers = null;

NR = 0;

}

}

2.3 AMS发送到队列处理广播

---

queue.scheduleBroadcastsLocked();会发送BROADCAST_INTENT_MSG，调用processNextBroadcast(true);

BroadcastQueue.java

final void processNextBroadcast(boolean fromMsg) {

synchronized (mService) {

processNextBroadcastLocked(fromMsg, false);

}

}

final void processNextBroadcastLocked(boolean fromMsg, boolean skipOomAdj){

while (mParallelBroadcasts.size() > 0) {

r = mParallelBroadcasts.remove(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, i);

}

}

}

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) {

//通知客户端分发广播，Binder采用 oneway 异步 应用端会自动串行化

app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,

data, extras, ordered, sticky, sendingUser, app.repProcState);

}

} else {

receiver.performReceive(intent, resultCode, data, extras, ordered,

sticky, sendingUser);

}

}

2.4 客户端处理receiver

---

AMS端的app.thread.scheduleRegisteredReceiver()，会调用到注册时注册的InnerReceiver的performReceive方法

ActivityThread.java

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);

//1

receiver.performReceive(intent, resultCode, dataStr, extras, ordered,

sticky, sendingUser);

}

InnerReceiver.java

public void performReceive(Intent intent, int resultCode, String data,

Bundle extras, boolean ordered, boolean sticky, int sendingUser) {

final LoadedApk.ReceiverDispatcher rd;

···

if (rd != null) {

//调用LoadedApk.ReceiverDispatcher的performReceive

rd.performReceive(intent, resultCode, data, extras,

ordered, sticky, sendingUser);

···

}

}

···

LoadedApk.ReceiverDispatcher.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);

···

//向ActivityThread发送一个Runnable

if (intent == null || !mActivityThread.post(args.getRunnable())) {

}

}

Args.java

public final Runnable getRunnable() {

return () -> {

final BroadcastReceiver receiver = mReceiver;

final boolean ordered = mOrdered;

=

final IActivityManager mgr = ActivityManager.getService();

···

receiver.setPendingResult(this);

//这里触发了BoradcastReciever回调

receiver.onReceive(mContext, intent);

···

};

}

三、动态注册解析总结：

=========================================================================

1、首先动态注册BroadcastReceiver到AMS，将他们存储在一个Map中，Map的key是IIntentReceiver用于回调注册端，value是一个ReceiverList

2、发送这发送Intent到AMS，筛选出匹配的ReceiverList，遍历通知注册端

四、BroadcastReceiver静态注册接收

=======================================================================================

4.1 PMS解析清单文件获取注册信息

---

PackageParser.java

private boolean parseBaseApplication(Package owner, Resources res,

XmlResourceParser parser, int flags, String[] outError){

else if (tagName.equals(“receiver”)) {

Activity a = parseActivity(owner, res, parser, flags, outError, cachedArgs,

true, false);

owner.receivers.add(a);

}

}

1、将receiver解析成一个Activity（这个Activity表示的是一个组件）对象，添加到receivers的列表中，receivers是一个ArrayList

五、普通广播发送后的静态接收