分析广播 的 registerReceiver、sendBroadcast、 onReceive 系统到底做了什么?
介绍
BroadcastReceiver 是 Android 的四大组件之一，它作用于应用内、进程间重要的一种通信方式，能够将某个消息通过广播的形式传递给订阅的广播接收器中，下面我们就来分析一下 广播注册到接收到消息 Android 源码到底做了些什么？
源码解析
registerReceiver
时序图
代码讲解
我们跟着上面时序图来讲解代码
先在 MainActivity registerReceiver 广播接收者
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//注册广播接收者
registerReceiver(new ReceiverB(),filterB);
}
...代码省略...
}
点击 registerReceiver 我们发现并不是 Activity 里面的方法，而是 Activity 的父类 ContextWrapper
ContextWrapper registerReceiver
public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory2,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks2,
Window.OnWindowDismissedCallback, WindowControllerCallback,
AutofillManager.AutofillClient {
....代码省略...
}
public class ContextThemeWrapper extends ContextWrapper {
....代码省略...
}
public class ContextWrapper extends Context {
@Override
public Intent registerReceiver(
BroadcastReceiver receiver, IntentFilter filter) {
return mBase.registerReceiver(receiver, filter);
}
}
这里的成员变量 mBase 是 Context，看过 Application 应用启动那块的源码知道 ContextImp 继承了 Context ，那么我们看继承类具体的 registerReceiver 方法吧。
ContextImp registerReceiver
class ContextImpl extends Context {
@Override
public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter,
String broadcastPermission, Handler scheduler, int flags) {
return registerReceiverInternal(receiver, getUserId(),
filter, broadcastPermission, scheduler, getOuterContext(), flags);
}
}
继续看 registerReceiverInternal
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) {
//获取 ActivityThread H
scheduler = mMainThread.getHandler();
}
//获取 IIntentReceiver 对象，通过它与 AMS 交互，并且通过 Handler 传递消息
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 {
//调用 AMS 的 registerReceiver
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();
}
}
注册广播接收器的函数最终进入到了 ContextImpl 的 registerReceiverInternal 这个函数，这里的成员变量 mPackageInfo 是一个 LoadApk 实例，它是用来负责处理广播的接收。
ActivityThread H
mMainThread.getHandler() 获取的这个 Handler 是用来分发 AMS 发过来的广播。
private class H extends Handler {
...
public void handleMessage(Message msg) {
case RECEIVER:
handleReceiver((ReceiverData)msg.obj);
maybeSnapshot();
break;
}
....
}
继续看 handleReceiver
private void handleReceiver(ReceiverData data) {
....
//应用 Application 局部变量
Application app;
//广播局部变量
BroadcastReceiver receiver;
//应用 Context
ContextImpl context;
try {
//制作 Applicaiton
app = packageInfo.makeApplication(false, mInstrumentation);
//拿到上下文
context = (ContextImpl) app.getBaseContext();
if (data.info.splitName != null) {
context = (ContextImpl) context.createContextForSplit(data.info.splitName);
}
java.lang.ClassLoader cl = context.getClassLoader();
data.intent.setExtrasClassLoader(cl);
data.intent.prepareToEnterProcess();
data.setExtrasClassLoader(cl);
//通过反射进行实例化广播
receiver = (BroadcastReceiver)cl.loadClass(component).newInstance();
} catch (Exception e) {
try {
if (localLOGV) Slog.v(
sCurrentBroadcastIntent.set(data.intent);
receiver.setPendingResult(data);
//onReceive 进行调用
receiver.onReceive(context.getReceiverRestrictedContext(),
data.intent);
} catch (Exception e) {
...
} finally {
sCurrentBroadcastIntent.set(null);
}
....
}
mPackageInfo.getReceiverDispatcher 函数实现
//LoadeApk
public IIntentReceiver getReceiverDispatcher(BroadcastReceiver r,
Context context, Handler handler,
Instrumentation instrumentation, boolean registered) {
synchronized (mReceivers) {
LoadedApk.ReceiverDispatcher rd = null;
ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher> map = null;
if (registered) {
map = mReceivers.get(context);
if (map != null) {
rd = map.get(r);
}
}
if (rd == null) {
rd = new ReceiverDispatcher(r, context, handler,
instrumentation, registered);
if (registered) {
if (map == null) {
map = new ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher>();
//以Context 为 key,map 为 values 存储到 mReveivers 中
mReceivers.put(context, map);
}
map.put(r, rd);
}
} else {
rd.validate(context, handler);
}
rd.mForgotten = false;
return rd.getIIntentReceiver();
}
}
在 LoadedAPK 类中的 getReceivcerDispatcher 函数中，首先看下 r 是不是已经实例化了，如果没有就创建一个，并且以 r 为 key 值保存在一个 HM 集合中，而这个 map 又被存储在了 mReceivers 中，这样只要给定一个 Activity 和 BroadcastReceiver ，就可以查看 LoadedAPK 里面是否已经存在相应的广播接收发布器了。现在在回到 ContextImpl.registerReceiverInternal 函数，获得了 IIntentReceiver 类型的 Binder 对象后，就开始注册到 AMS 中了，具体代码看下面小点。
AMS registerReceiver
/**
* 这里是通过 Binder 通知调用
* @return Intent
*/
public Intent registerReceiver(IApplicationThread caller, String callerPackage,
IIntentReceiver receiver, IntentFilter filter, String permission, int userId,
int flags) {
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) {
if (caller != null) {
//1. 获取进ProcessRecord
callerApp = getRecordForAppLocked(caller);
if (callerApp == null) {
...代码省略...
}
...代码省略...
//2. 根据 Action 查找匹配的 sticky 接收器
Iterator<String> actions = filter.actionsIterator();
if (actions == null) {
ArrayList<String> noAction = new ArrayList<String>(1);
noAction.add(null);
actions = noAction.iterator();
}
...代码省略...
//3. 获取 ReceiverList
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);
} else if (rl.uid != callingUid) {
...代码省略...
}
//4. 构建 BroadcastFilter 对象并且添加到 ReceiverList 中
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);
...代码省略...
return sticky;
}
}
- 根据上面注释 1 可知，获取进程对应的 pid,uid;
- 注释 2 获取 IntentFilter 的所有 Action；
- 注释 3 把广播接收器的 receiver 保存到了一个 ReceiverList 中，这个列表的宿主进程是 rl.app，就是 MainActivity 所在的进程。
- 注释 4 只是把广播接收器保存起来，但是还没有和 filter 关联起来，这里就创建一个 BroadcastFilter 来把广播接收器列表 rl 和 filter 关联起来，然后保存在 AMS 成员变量 mReceiverResolver 中，这样，就将广播接收器和要接收广播类型的接收器 filter 保存在 AMS 中了，以后就能接到到相应的广播并做处理了。
接下来我们看下 sendBroadcast() 。
onReceive
时序图
在 Activity 通过 sendBroadcast 发送一个广播最后 Binder 发送给 AMS , AMS 根据这个广播的 Action 类型找到相应的广播接收器，然后把这个广播放进自己的消息队列中，完成第一部分广播异步分发。
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) {
intent = new Intent(intent);
......代码省略....
if (intent.getComponent() == null) {
......代码省略....
} else {
//查询到该 Intent 对应的 BroadcastFilter 也就是接收器列表
registeredReceivers = mReceiverResolver.queryIntent(intent,
resolvedType, false /*defaultOnly*/, userId);
}
}
......代码省略....
if (!replaced) {
queue.enqueueParallelBroadcastLocked(r);
//处理广播分发
queue.scheduleBroadcastsLocked();
}
registeredReceivers = null;
NR = 0;
}
......代码省略....
return ActivityManager.BROADCAST_SUCCESS;
}
AMS 在消息循环中处理这个广播，并通过 Binder 机制把这个广播分发给注册的 ReceiverDispatch ，ReceiverDispatch 把这个广播放进 MainActivity 所在进程的消息队列中，完成第二部分异步消息分发。
public void scheduleBroadcastsLocked() {
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Schedule broadcasts ["
+ mQueueName + "]: current="
+ mBroadcastsScheduled);
if (mBroadcastsScheduled) {
return;
}
//通过 Handler 分发
mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
mBroadcastsScheduled = true;
}
private final class BroadcastHandler extends Handler {
......
@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;
....
}
}
}
ReceiverDispatch 的内部类 Args 在 MainActivity 所在的线程消息循环中处理这个广播，最终是将这个广播分发给注册的 Receiver 实例的 onReceiver 处理。
public final class LoadedApk {
...
static final class ReceiverDispatcher {
final class Args extends BroadcastReceiver.PendingResult {
....
public final Runnable getRunnable() {
return () -> {
....
try {
ClassLoader cl = mReceiver.getClass().getClassLoader();
intent.setExtrasClassLoader(cl);
intent.prepareToEnterProcess();
setExtrasClassLoader(cl);
receiver.setPendingResult(this);
//回调到接收广播的 onReceiver
receiver.onReceive(mContext, intent);
} catch (Exception e) {
...
};
}
}
}
...
}
总结
注册跟接收源码分析就到这里差不多了，简单来说广播就是一个订阅 - 发布的过程，通过一些 map 存储 BroadcastReceiver ，key 就是封装了这些广播的信息类，如 Action 之类的，当发布一个广播时通过 AMS 到这个 map 中查询注册了这个广播的 IntentFilter 的 BroadcastReceiver , 然后通过 ReceiverDispatch 将广播分发给各个订阅的对象，从而完成了整个通信过程。
《如何成为一位Android架构师？（架构视频+面试专题文档+学习笔记）》