Android广播管理二--广播注册（registerReceiver）流程分析

前面分析了Android系统的广播机制，从本质来说，它是一种消息订阅/发布机制。因此，使用这种消息驱动模型的第一步便是订阅消息；而对Android应用程序来说，订阅消息其实就是注册广播接收器。

接下来，我们继续分析Android应用程序是如何注册广播接收器的，以及把广播接收器注册到哪里去的。

在Android的广播机制中，ActivityManagerService扮演着广播中心的角色，负责系统中所有广播的注册和分发操作。因此，Android应用程序注册广播接收器的过程就是把广播接收器注册到AMS的过程。Android应用程序是通过调用ContextWrapper类的registerReceiver方法来把广播接收器BroadcastReceiver注册到AMS中去的，而ContextWrapper类本身又借助ContextImpl类来注册广播接收器。

在Android应用程序框架中，Activity和Service类都继承了ContextWrapper类（ContextWrapper类是Context类的包装类，ContextImpl类是Context类的实现类，调用ContextWrapper类的方法也就会调用到ContextImpl类中的方法），因此，我们可以在Activity或Service的子类中调动registerReceiver方法来注册广播接收器。

下面我们进入主题：

静态广播直接在AndroidManifest.xml中注册一下即可。

动态广播的注册在代码中需要调用Context类的registerReceiver方法，最终调用到ContextImpl类中的registerReceiver方法中。

ContextImpl.registerReceiverInternal

我们看下方法调用：

    @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());//broadcastPermission为null，scheduler为null    }

    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) {//mPackageInfo是LoadedApk对象，在创建ContextImpl对象的时候指定了LoadedApk对象                if (scheduler == null) {//没有设置Handler时，使用主线程的Handler                    scheduler = mMainThread.getHandler();//这个handler用来分发AMS发送过来的广播用的                }                rd = mPackageInfo.getReceiverDispatcher(                    receiver, context, scheduler,                    mMainThread.getInstrumentation(), true);//获取IIntentReceiver对象，传递到AMS，用于接收广播（广播分发器）            } else {                if (scheduler == null) {                    scheduler = mMainThread.getHandler();                }                rd = new LoadedApk.ReceiverDispatcher(                        receiver, context, scheduler, null, true).getIIntentReceiver();            }        }        try {            final Intent intent = ActivityManagerNative.getDefault().registerReceiver(                    mMainThread.getApplicationThread(), mBasePackageName,                    rd, filter, broadcastPermission, userId);//这里调用到AMS中的registerReceiver方法            if (intent != null) {                intent.setExtrasClassLoader(getClassLoader());                intent.prepareToEnterProcess();            }            return intent;        } catch (RemoteException e) {            throw e.rethrowFromSystemServer();        }    }

通过两个函数的中转，最终调用到ContextImpl.registerReceiverInternal()。我们先看一下这几个参数，receiver表示用户注册广播接收器；userId注册广播应用程序的userID；filter为广播接收器的接收条件；broadcastPermission广播接收器的权限信息，广播发送者必须带上这个权限信息，它所发出的广播才能被注册者接收到；scheduler表示接收广播的线程的Handler。

方法中使用到了成员变量mPackageInfo是一个LoadedApk实例，它是用来负责处理广播的接收的，在后面一篇讲到广播的发送时（sendBroadcast），会详细描述。参数broadcastPermission和scheduler都为null，而参数context是上面的方法通过调用getOuterContext（）得到的，这里它就是指向注册广播的Activity了，因为Activity是继承于Context类的，因此，这里用Context类型来引用。

由于条件mPackageInfo != null和context != null都成立，而且条件scheduler == null也成立，于是就调用mMainThread.getHandler来获得一个Handler了，这个Hanlder是后面用来分发ActivityManagerService发送过的广播用的。这里的成员变量mMainThread是一个ActivityThread实例。我们先来看看ActivityThread.getHandler函数的实现，然后再回过头来继续分析ContextImpl.registerReceiverInternal函数。

ActivityThread.getHandler()

public final class ActivityThread {......final H mH = new H();private final class H extends Handler {......public void handleMessage(Message msg) {......switch (msg.what) {......}......}......}......final Handler getHandler() {return mH;}......}

有了这个Handler之后，就可以分发消息给应用程序处理了。

再回到上一步的ContextImpl.registerReceiverInternal函数中，它通过mPackageInfo.getReceiverDispatcher函数获得一个IIntentReceiver接口对象rd，这是一个Binder对象，接下来会把它传给ActivityManagerService，ActivityManagerService在收到相应的广播时，就是通过这个Binder对象来通知MainActivity来接收的。

我们也是先来看一下mPackageInfo.getReceiverDispatcher函数的实现，然后再回过头来继续分析ContextImpl.registerReceiverInternal函数。

LoadedApk.getReceiverDispatcher

    public IIntentReceiver getReceiverDispatcher(BroadcastReceiver r,            Context context, Handler handler,            Instrumentation instrumentation, boolean registered) {        synchronized (mReceivers) {            LoadedApk.ReceiverDispatcher rd = null;            ArrayMap map = null;            if (registered) {//上面传递的参数为true                map = mReceivers.get(context);//根据key值获取对应的value，key为context对象                if (map != null) {                    rd = map.get(r);//根据key值，获取对应的value；key为BroadcastReceiver，value为ReceiverDispatcher                }            }            if (rd == null) {                rd = new ReceiverDispatcher(r, context, handler,                        instrumentation, registered);//创建LoadedApk.ReceiverDispatcher                if (registered) {                    if (map == null) {                        map = new ArrayMap();                        mReceivers.put(context, map);                    }                    map.put(r, rd);//将创建的LoadedApk.ReceiverDispatcher保存到map数组中                }            } else {                rd.validate(context, handler);            }            rd.mForgotten = false;            return rd.getIIntentReceiver();//获取IIntentReceiver.stub对象（InnerReceiver）        }    }

    private final ArrayMap> mReceivers        = new ArrayMap>();

在LoadedApk.getReceiverDispatcher函数中，首先看一下参数r是不是已经有相应的ReceiverDispatcher存在了，如果有，就直接返回了；否则就新建一个ReceiverDispatcher，并且以r为Key值保在一个HashMap中，而这个HashMap以Context（注册广播接收器的Activity）为Key值保存在LoadedApk的成员变量mReceivers中。这样，只要给定一个Activity和BroadcastReceiver，就可以查看LoadedApk里面是否已经存在相应的广播接收分发器ReceiverDispatcher了。

final class LoadedApk {...... static final class ReceiverDispatcher { final static class InnerReceiver extends IIntentReceiver.Stub { final WeakReference mDispatcher;...... InnerReceiver(LoadedApk.ReceiverDispatcher rd, boolean strong) { mDispatcher = new WeakReference(rd);...... }......}......final IIntentReceiver.Stub mIIntentReceiver;//接收AMS发送的广播final Handler mActivityThread;//用于分发广播......ReceiverDispatcher(BroadcastReceiver receiver, Context context,Handler activityThread, Instrumentation instrumentation,boolean registered) {......mIIntentReceiver = new InnerReceiver(this, !registered);//创建InnerReceiver对象mActivityThread = activityThread;......}......IIntentReceiver getIIntentReceiver() {//getIIntentReceiver方法获取IIntentReceiver.Stub对象return mIIntentReceiver;}}......}

在新建广播接收分发器ReceiverDispatcher时，会在构造函数里面创建一个InnerReceiver实例，这是一个Binder对象，实现了IIntentReceiver接口，可以通过ReceiverDispatcher.getIIntentReceiver函数来获得，获得后就会把它传给ActivityManagerService，以便接收广播。在ReceiverDispatcher类的构造函数中，还会把传进来的Handle类型的参数activityThread保存下来，以便后面在分发广播的时候使用。现在，再回到ContextImpl.registerReceiverInternal函数，在获得了IIntentReceiver类型的Binder对象后，就开始要把它注册到ActivityManagerService中去了。

ActivityManagerService.registerReceiver()

这个方法逻辑比较清楚，但是涉及到很多变量，我们先梳理一下这几个变量：

mStickyBroadcasts：保存了当前系统中所有用户的Sticky广播，key为广播的action，value为该action对应的所有广播Intents；

    /**     * State of all active sticky broadcasts per user.  Keys are the action of the每个用户的所有sticky广播     * sticky Intent, values are an ArrayList of all broadcasted intents with内层key值是sticky广播的action，value是action对应的所有Intents     * that action (which should usually be one).  The SparseArray is keyed     * by the user ID the sticky is for, and can include UserHandle.USER_ALL     * for stickies that are sent to all users.最外层的key值是userID（包括UserHandle.USER_ALL）     */    final SparseArray>> mStickyBroadcasts =            new SparseArray>>();

mRegisteredReceivers：保存了已经注册的所有广播；

mReceiverResolver：保存当前系统注册的所有的BroadcastFilter；

    /**     * Resolver for broadcast intents to registered receivers.已注册广播的Intents解析器     * Holds BroadcastFilter (subclass of IntentFilter).保存BroadcastFilter     */    final IntentResolver mReceiverResolver            = new IntentResolver()

BroadcastRecord：需要发送的一条广播记录，里面的receivers成员存储了需要接收当前广播的所有接收器。

下面我们分块来分析registerReceiver方法。

过滤出与当前注册的IntentFilter中的action匹配的所有的Intent

第一步就是先找出与注册action相匹配的所有的Intent。

    public Intent registerReceiver(IApplicationThread caller, String callerPackage,            IIntentReceiver receiver, IntentFilter filter, String permission, int userId) {        enforceNotIsolatedCaller("registerReceiver");        ArrayList stickyIntents = null;        ProcessRecord callerApp = null;        int callingUid;        int callingPid;        synchronized(this) {            if (caller != null) {                callerApp = getRecordForAppLocked(caller);//获取ProcessRecord对象                ......                callingUid = callerApp.info.uid;                callingPid = callerApp.pid;            } else {                callerPackage = null;                callingUid = Binder.getCallingUid();                callingPid = Binder.getCallingPid();            }            userId = mUserController.handleIncomingUser(callingPid, callingUid, userId, true,                    ALLOW_FULL_ONLY, "registerReceiver", callerPackage);//获取用户ID            Iterator actions = filter.actionsIterator();//获取当前IntentFilter中所有的actions            if (actions == null) {                ArrayList noAction = new ArrayList(1);                noAction.add(null);                actions = noAction.iterator();            }            // Collect stickies of users收集与注册用户（userId）相关的所有已经被广播过的Intents，存储在stickyIntents中            int[] userIds = { UserHandle.USER_ALL, UserHandle.getUserId(callingUid) };//包括所有用户，以及注册进程所对应的用户            while (actions.hasNext()) {//第一层：遍历actions                String action = actions.next();                for (int id : userIds) {//第二层：遍历与调用进程相关的用户id                    ArrayMap> stickies = mStickyBroadcasts.get(id);//用户id发送过的所有的sticky广播                    if (stickies != null) {                        ArrayList intents = stickies.get(action);//获取action对应的所有广播Intents                        if (intents != null) {//如果已经发送的Intents里面包含上面的action，则保存在stickyIntents中                            if (stickyIntents == null) {                                stickyIntents = new ArrayList();                            }                            stickyIntents.addAll(intents);                        }                    }                }            }        }

从mStickyBroadcasts里面找出发送给所有用户和调用者userID的所有的Sticky广播的Intents，然后和当前注册的IntentFilter中所有的action逐个比较，找出符合的所有的intent，存储在stickyIntents里面。注意，这里仅仅通过action进行了一次筛选。

从stickyIntents里面找出与当前注册的IntentFilter匹配的Intent

上面第一步找出了与注册的action相匹配的Intent，然后在这些Intent中再进行精确匹配，找出精确匹配的Intent。

上面根据action对相应用户的stickyIntents进行了一次过滤，下面根据IntentFilter.match方法对筛选出来的stickyIntents进行精确的匹配，包括action、type、scheme、data、categories等，将最终的匹配结果存放在allSticky里面。如果调用registerReceiver方法传递的receiver是null，就返回allSticky中的第一个匹配的Intent，或者返回null。

        ArrayList allSticky = null;        if (stickyIntents != null) {            final ContentResolver resolver = mContext.getContentResolver();            // Look for any matching sticky broadcasts...            for (int i = 0, N = stickyIntents.size(); i < N; i++) {//再把stickyIntents里面的intent逐个比较                Intent intent = stickyIntents.get(i);                // If intent has scheme "content", it will need to acccess                // provider that needs to lock mProviderMap in ActivityThread                // and also it may need to wait application response, so we                // cannot lock ActivityManagerService here.                if (filter.match(resolver, intent, true, TAG) >= 0) {//match方法中会对action、type、scheme、data等进行比较                    if (allSticky == null) {                        allSticky = new ArrayList();                    }                    allSticky.add(intent);                }            }        }        // The first sticky in the list is returned directly back to the client.查找的是stickyIntent，        Intent sticky = allSticky != null ? allSticky.get(0) : null;//如果存在满足action条件的已经广播的intent，立即发送一次广播        if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Register receiver " + filter + ": " + sticky);        if (receiver == null) {            return sticky;        }

上面的两部分主要从sticky广播的历史记录中筛选出与当前注册的IntentFilter匹配的历史Intent，将最终的结果保存在allSticky中。如果注册的广播是非sticky广播，一般来说allSticky为null，但是对于网络切换这种发送的时候是以sticky广播形式发送的，这里allSticky就不是null。

在注册记录中查找当前的receiver

        synchronized (this) {            if (callerApp != null && (callerApp.thread == null                    || callerApp.thread.asBinder() != caller.asBinder())) {                // Original caller already died                return null;            }            ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder());//以receiver为key值，获取对应的IntentFilter列表，初始为null            if (rl == null) {                rl = new ReceiverList(this, callerApp, callingPid, callingUid,                        userId, receiver);//创建ReceiverList对象                if (rl.app != null) {//ProcessRecord                    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);//保存receiver对应的ReceiverList            } 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);            }

首先判断当前进程是否还活着；然后从当前系统所有已经动态注册的mRegisteredReceivers中查找当前注册的receiver，返回对应的ReceiverList，该类继承了ArrayList，语义就是一个receiver可以对应着一串BroadcastFilter，所以说对于同一个receiver对象而言，可以多次调用registerReceiver方法注册不同的广播条件BroadcastFilter，这里面是注册动作中最关键的地方，将receiver以及对应的ReceiverList存储到AMS.mRegisteredReceivers中。

将当前注册的广播过滤器放到ReceiverList里面

            BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,                    permission, callingUid, userId);//根据filter创建BroadcastFilter（IntentFilter）广播过滤器            rl.add(bf);//将BroadcastFilter加入ReceiverList中            if (!bf.debugCheck()) {                Slog.w(TAG, "==> For Dynamic broadcast");            }            mReceiverResolver.addFilter(bf);//将bf添加到mReceiverResolver中，当AMS接收到广播时就可以从mReceiverResolver中找到接收者

根据当前的IntentFilter创建BroadcastFilter对象，BroadcastFilter继承于IntentFilter，基本上和IntentFilter没有太大的区别，里面还包含对ReceiverList的引用。

创建完BroadcastFilter后，将其加到mReceiverResolver中，内部用的是一个ArraySet，说明重复添加完全相同的BroadcastFilter对象不会多次添加。到这里没有匹配的sticky广播已经注册结束了。

我们这里再看一下mReceiverResolver这个变量，mReceiverResolver变量用来存储系统应用进程中所有receiver动态注册的所有的BroadcastFilter，也就是说动态注册的BroadcastReceiver最终保存到了这里。

发送匹配过滤器的sticky广播

            // Enqueue broadcasts for all existing stickies that match            // this filter.如果存在满足条件的sticky intents，需要立即发送这些广播            if (allSticky != null) {                ArrayList receivers = new ArrayList();                receivers.add(bf);                final int stickyCount = allSticky.size();                for (int i = 0; i < stickyCount; i++) {//遍历allSticky，逐个发送Intent                    Intent intent = allSticky.get(i);                    BroadcastQueue queue = broadcastQueueForIntent(intent);//获取BroadcastQueue                    BroadcastRecord r = new BroadcastRecord(queue, intent, null,                            null, -1, -1, null, null, AppOpsManager.OP_NONE, null, receivers,                            null, 0, null, null, false, true, true, -1);//创建BroadcastRecord                    queue.enqueueParallelBroadcastLocked(r);//将BroadcastRecord对象条件到BroadcastQueue.mParallerlBraodcasts数组中                    queue.scheduleBroadcastsLocked();//尝试推动一次发送广播的行为，但是如果目前有广播还在发送的处理过程中，本次尝试失败                }            }            return sticky;

上面注册结束以后，如果筛选出与当前注册的IntentFilter匹配的sticky广播的Intent，就将所有匹配的Intent逐条发送广播给当前的注册者receiver，可以看到这里的接收者receivers里面就只有当前创建的一个BroadcastFilter，也就是当前的注册者。

上面就是动态广播注册的整个过程，主要就是将当前注册的动态广播接收器以及对应的广播过滤器BroadcastFilter添加到AMS.mRegisteredReceivers和AMS.mReceiverResolver中，同时处理了与sticky广播的相关逻辑。从这里可以看到对于注册sticky广播而言，在注册结束以后，系统会立马发送与之匹配的sticky广播。

下面继续分析广播发送流程：Android广播管理三--广播发送（sendBroadcast）流程分析