【Android源码系列】BroadcastReceiver启动源码解析

一、先BB两句

Android四大组件源码已经分析完Activity和Service，已经攻克一半，现在读起源码越来越得心应手。
阅读本篇文章前建议先阅读我的前两篇博文：
【Android源码系列】Activity启动源码解析
【Android源码系列】Service启动源码解析
今天我们来看看BroadcastReceiver（广播）的源码逻辑，此前说过的流程在这里可能会简化（懒）。其实他们的流程大致都相同，这里先把流程图放上来。

好的，本篇文章到此结束。
哈哈，开个玩笑，我们还是再来熟悉一遍流程避免忘得飞快。再次提醒，强烈推荐浏览本文时和着源码。
我们一般使用广播关键步骤分为两步：

//注册
registerReceiver(new MyReceiver(), new IntentFilter("com.source.broadcastReceiver"));
//发送广播
Intent intent = new Intent("com.source.broadcastReceiver");
                sendBroadcast(intent);

我们一个一个分析。

二、注册

点开registerReceiver源码，依然和Service一样，走到ContextImpl里，并调用了registerReceiverInternal方法。

private Intent registerReceiverInternal(BroadcastReceiver receiver, int userId,
            IntentFilter filter, String broadcastPermission,
            Handler scheduler, Context context) {
        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 {
            return ActivityManagerNative.getDefault().registerReceiver(
                    mMainThread.getApplicationThread(), mBasePackageName,
                    rd, filter, broadcastPermission, userId);
        } catch (RemoteException e) {
            return null;
        }
    }

这个rd瞅着有点眼熟，感觉和Servive的connect一样，这里先不管，我们直接往下走。看到我们熟悉的ActivityManagerNative（为啥熟悉？看了前两篇文章就知道），也就是ActivityManagerService调用了registerReceiver，我们到AMS里去看看。

 public Intent registerReceiver(IApplicationThread caller, String callerPackage,
            IIntentReceiver receiver, IntentFilter filter, String permission, int userId) {
            //省略.......
ReceiverList rl
                = (ReceiverList)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) {
                throw new IllegalArgumentException(
                        "Receiver requested to register for uid " + callingUid
                        + " was previously registered for uid " + rl.uid);
            } else if (rl.pid != callingPid) {
                throw new IllegalArgumentException(
                        "Receiver requested to register for pid " + callingPid
                        + " was previously registered for pid " + rl.pid);
            } else if (rl.userId != userId) {
                throw new IllegalArgumentException(
                        "Receiver requested to register for user " + userId
                        + " was previously registered for user " + rl.userId);
            }
            BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,
                    permission, callingUid, userId);
            rl.add(bf);
            if (!bf.debugCheck()) {
                Slog.w(TAG, "==> For Dynamic broadast");
            }
            mReceiverResolver.addFilter(bf);
            //省略.......
            }

很明显，我们的AMS将receiver保存了起来。其实这里还做了Sticky（粘性广播）的发送工作，有兴趣的同学可以仔细看看源码，本文就不多说了。
好了，注册工作就完成了，步骤比较简单。我们接着看发送部分。

三、发送广播

发送广播和注册一样，都是到ContextImpl里直接调用了AMS的broadcastIntent方法，而AMS，又直接调用了自己的broadcastIntentLocked，过程我就不一一列出来了，我们直接看这个方法：

 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) {
//......
if (!ordered && NR > 0) {
            // If we are not serializing this broadcast, then send the
            // registered receivers separately so they don't wait for the
            // components to be launched.
            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);
            if (DEBUG_BROADCAST) Slog.v(
                    TAG, "Enqueueing parallel broadcast " + r);
            final boolean replaced = replacePending && queue.replaceParallelBroadcastLocked(r);
            if (!replaced) {
                queue.enqueueParallelBroadcastLocked(r);
                queue.scheduleBroadcastsLocked();
            }
            registeredReceivers = null;
            NR = 0;
        }
//......
}

broadcastIntentLocked的内容很多，我们找到关键的地方

queue.scheduleBroadcastsLocked();

工作转移到了BroadcastQueue这个类里，看名字就知道这是一个储存和操作Revceiver的队列，进去后发现他内部有一个专门的BroadcastHandler，并将事件分发给了自己的processNextBroadcast方法

final void processNextBroadcast(boolean fromMsg) {
//.......
if (r.resultTo != null) {
                        try {
                            if (DEBUG_BROADCAST) {
                                int seq = r.intent.getIntExtra("seq", -1);
                                Slog.i(TAG, "Finishing broadcast ["
                                        + mQueueName + "] " + r.intent.getAction()
                                        + " seq=" + seq + " app=" + r.callerApp);
                            }
                            performReceiveLocked(r.callerApp, r.resultTo,
                                new Intent(r.intent), r.resultCode,
                                r.resultData, r.resultExtras, false, false, r.userId);
                            // Set this to null so that the reference
                            // (local and remote) isn't kept in the mBroadcastHistory.
                            r.resultTo = null;
                        } catch (RemoteException e) {
                            r.resultTo = null;
                            Slog.w(TAG, "Failure ["
                                    + mQueueName + "] sending broadcast result of "
                                    + r.intent, e);
                        }
                    }
}

一样省略大部分无光代码，找出之前存好的ProcessRecord，调用了自己的performReceiveLocked

private static 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) {
                // If we have an app thread, do the call through that so it is
                // correctly ordered with other one-way calls.
                app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
                        data, extras, ordered, sticky, sendingUser, app.repProcState);
            } else {
                // Application has died. Receiver doesn't exist.
                throw new RemoteException("app.thread must not be null");
            }
        } else {
            receiver.performReceive(intent, resultCode, data, extras, ordered,
                    sticky, sendingUser);
        }
    }

依旧是我们熟悉的ActivityThread

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

调用了IIntentReceiver的performReceive，这个这很明显是一个Binder接口，有了Service的经验，很容易我们就找到了ReceiverDispatcher这个对象（上文注册时也提到过），他的内部类InnerReceiver继承了IIntentReceiver.Stub。InnerReceiver的performReceive方法直接调用了ReceiverDispatcher的performReceive方法。

public void performReceive(Intent intent, int resultCode, String data,
                Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
            if (ActivityThread.DEBUG_BROADCAST) {
                int seq = intent.getIntExtra("seq", -1);
                Slog.i(ActivityThread.TAG, "Enqueueing broadcast " + intent.getAction() + " seq=" + seq
                        + " to " + mReceiver);
            }
            Args args = new Args(intent, resultCode, data, extras, ordered,
                    sticky, sendingUser);
            if (!mActivityThread.post(args)) {
                if (mRegistered && ordered) {
                    IActivityManager mgr = ActivityManagerNative.getDefault();
                    if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
                            "Finishing sync broadcast to " + mReceiver);
                    args.sendFinished(mgr);
                }
            }
        }

这里出现了一个Args,他实现了runable接口，mActivityThread是我们的H类（handler）。

mActivityThread.post(args)

所以又转到，Args的run方法里。

public void run() {
                //......
                try {
                    ClassLoader cl =  mReceiver.getClass().getClassLoader();
                    intent.setExtrasClassLoader(cl);
                    setExtrasClassLoader(cl);
                    receiver.setPendingResult(this);
                    receiver.onReceive(mContext, intent);
                } catch (Exception e) {
                    if (mRegistered && ordered) {
                        if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
                                "Finishing failed broadcast to " + mReceiver);
                        sendFinished(mgr);
                    }
                //.......
        }

好了，onReceive方法已经调用，意味着广播发送成功。

四、总结

1、最重要的依然是我们的Binder，通过一系列的IPC通信，最终传给了我们的BroadcastReceiver。
2、多次利用handler发送消息，虽然我们频繁使用它，或多或少对他的原理有些了解，但是Android的消息机制是究竟如何实现的，研究完四大组件，将他定为下一个研究对象。