Android源码解析四大组件系列（五）---广播的注册过程

广播这个篇幅打算用四篇文章来写，分别为广播注册、广播处理、广播的发送，广播深入细节理解，如果都写到一篇文章会比较长，所以拆分成四篇来写。

第一篇
Android源码解析---广播的注册过程
第二篇
Android源码解析---广播的处理过程
第三篇
Android源码解析---广播的发送过程
第四篇
Android源码解析---广播深入细节理解

想收到广播(Broadcast)，必须先要注册接收广播的组件---广播接收者(receiver)，广播接收者的注册分为动态注册和静态注册，而注册中心就是AMS，AMS再把广播分发到各个广播接收者(receiver)。

一个广播可以有多个receiver来接收它，注册的方式分为两种，一种是静态注册，一种是动态注册，动态注册广播不是常驻型广播，也就是说广播跟随Activity的生命周期，在Activity结束前，需要移除广播接收器。 静态注册是常驻型，也就是说当应用程序关闭后，如果有信息广播来，程序也会被系统调用自动运行。

1.1 动态广播注册

动态注册是由ContextImpl的registerReceiver方法调用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) {
                 //AMS并不是直接给广播接收者发送广播的，当广播到达应用程序进程的时候，
　　　　　 //会被封装成一个Message,然后push到主线程消息队列中，然后才会给接
　　　　　 //收者处理，你也可以指定一个处理的Handler，将onReceive()调度在非主线程执行。
                   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 {
         //将rd，filter等发送给AMS
           final Intent intent = ActivityManagerNative.getDefault().registerReceiver(
                   mMainThread.getApplicationThread(), mBasePackageName,
                   rd, filter, broadcastPermission, userId);
           if (intent != null) {
               intent.setExtrasClassLoader(getClassLoader());
               intent.prepareToEnterProcess();
           }
           return intent;
       } catch (RemoteException e) {
           throw e.rethrowFromSystemServer();
       }
   }

传进来的receiver不是直接发送给AMS的，首先会把receiver封装成一个IIntentReceiver对象rd,这个rd是一个binder本地对象，具备了跨进程通信的能力。mPackageInfo是LoadedApk,LoadedApk这个类包含了当前加载的apk的主要的信息,其中成员变量mReceivers表就记录了所有动态注册的receiver。

private final ArrayMap<Context, ArrayMap<BroadcastReceiver, ReceiverDispatcher>> mReceivers
      = new ArrayMap<Context, ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher>>();

rd的获取有两种，当mPackageInfo存在时候，就通过mPackageInfo.getReceiverDispatcher()来获取。

   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;
　      　//registered传进来的是true
           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>();
                       mReceivers.put(context, map);
                   }
                   map.put(r, rd);
               }
           } else {
　　　　　      //检查广播分发者的context、handler是否一致
               rd.validate(context, handler);
           }
           rd.mForgotten = false;
           return rd.getIIntentReceiver();
       }
   }

这个方法内部维护了一张表 ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher> map = null，每一个广播接收者对应一个ReceiverDispatcher(广播分发者)，并且把最后把这个map以Context为key存在mReceivers中,而这个Context跟广播的发送方有关系，如果是在Activity中发送的，这个Context就指向与这个Activity,如果是在Service中发送的，这个Context就指向了这个Service。那么这个广播分发者有什么用呢？用map来存储，表示ReceiverDispatcher跟BroadcastReceiver是一一对应的，每个广播接收者对应一个广播分发者， 当AMS向app发送广播时会调用到app进程的广播分发者，然后再将广播以message形式post到app的主线程，来执行onReceive()方法。

假设我的app只有两个Activity(HomeActivity和DetailActivity)，这个app被打包成xxx.apk，那么在内存中，这个xxx.apk由LoadedApk来描述，如果HomeActivity和DetailActivity都注册了广播，那么LoadedApk内部维持的mReceivers的长度就为2。现在梳理一下上面的代码，当一个BroadcastReceiver要注册的时候，会优先使用Context查看一下，这个组件有没有注册过广播，如果有就取出来，类型是一个ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher> 的map。如果没有，就把map创建出来，并且存到mReceivers中。有了map之后，需要把ReceiverDispatcher（广播分发者）存到map里面去。第一次注册时候，肯定走的是if(rd==null)的代码块里面，这样rd对象被创建出来。现在分析一下ReceiverDispatcher这个类。

static final class ReceiverDispatcher {

       final static class InnerReceiver extends IIntentReceiver.Stub {
           final WeakReference<LoadedApk.ReceiverDispatcher> mDispatcher;
           final LoadedApk.ReceiverDispatcher mStrongRef;

           InnerReceiver(LoadedApk.ReceiverDispatcher rd, boolean strong) {
               mDispatcher = new WeakReference<LoadedApk.ReceiverDispatcher>(rd);
               mStrongRef = strong ? rd : null;
           }

       .......

       final IIntentReceiver.Stub mIIntentReceiver;
       final BroadcastReceiver mReceiver;
       final Context mContext;
       final Handler mActivityThread;
       .......
       ReceiverDispatcher(BroadcastReceiver receiver, Context context,
               Handler activityThread, Instrumentation instrumentation,
               boolean registered) {
           if (activityThread == null) {
               throw new NullPointerException("Handler must not be null");
           }
           mIIntentReceiver = new InnerReceiver(this, !registered);
           //广播接收者
           mReceiver = receiver;
           //表示哪个发送的广播
           mContext = context;
           //主线程
           mActivityThread = activityThread;
            .......
       }
       .......
       IIntentReceiver getIIntentReceiver() {
           return mIIntentReceiver;
       }
      .......
   }

在内部会创建InnerReceiver，InnerReceiver是ReceiverDispatcher的内部类，是一个实现Binder的本地对象，前面也说过了，最终是将一个InnerReceiver对象注册到了AMS中。

OK,绕了这么一大圈子，其实就是为了封装一个InnerReceiver用于和AMS通信，我也不知道谷歌这帮程序员怎么想的，有点麻烦。忽略跨进程的代码，现在由用户进程走到SystemServer进程了，即走到AMS的registerReceiver方法。

public Intent registerReceiver(IApplicationThread caller, String callerPackage,
           IIntentReceiver receiver, IntentFilter filter, String permission, int userId) {
       enforceNotIsolatedCaller("registerReceiver");
       ArrayList<Intent> stickyIntents = null;
       ProcessRecord callerApp = null;
       int callingUid;
       int callingPid;
       synchronized(this) {
           if (caller != null) {
             //由caller获取当前进程对象
               callerApp = getRecordForAppLocked(caller);
               //进程还没创建，直接抛出异常
               if (callerApp == null) {
                   throw new SecurityException(
                           "Unable to find app for caller " + caller
                           + " (pid=" + Binder.getCallingPid()
                           + ") when registering receiver " + receiver);
               }
               if (callerApp.info.uid != Process.SYSTEM_UID &&
                       !callerApp.pkgList.containsKey(callerPackage) &&
                       !"android".equals(callerPackage)) {
                   throw new SecurityException("Given caller package " + callerPackage
                           + " is not running in process " + callerApp);
               }
               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);

          //获取IntentFilter中的action
           Iterator<String> actions = filter.actionsIterator();
           if (actions == null) {
               ArrayList<String> noAction = new ArrayList<String>(1);
               noAction.add(null);
               actions = noAction.iterator();
           }

           //从actions中，先把粘性广播帅选出来，放进stickyIntents中
           int[] userIds = { UserHandle.USER_ALL, UserHandle.getUserId(callingUid) };
           while (actions.hasNext()) {
               String action = actions.next();
               for (int id : userIds) {
               //从mStickyBroadcasts中查看用户的sticky Intent,mStickyBroadcasts存了系统所有的粘性广播
                   ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(id);
                   if (stickies != null) {
                       ArrayList<Intent> intents = stickies.get(action);
                       if (intents != null) {
                           if (stickyIntents == null) {
                               stickyIntents = new ArrayList<Intent>();
                           }
                           stickyIntents.addAll(intents);
                       }
                   }
               }
           }
       }

       ArrayList<Intent> 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++) {
               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) {
                   if (allSticky == null) {
                       allSticky = new ArrayList<Intent>();
                   }
                   allSticky.add(intent);
               }
           }
       }

       // The first sticky in the list is returned directly back to the client.
       Intent sticky = allSticky != null ? allSticky.get(0) : null;
       if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Register receiver " + filter + ": " + sticky);
       //如果receiver为空，就直接返回了
       if (receiver == null) {
           return sticky;
       }

       synchronized (this) {
           if (callerApp != null && (callerApp.thread == null
                   || callerApp.thread.asBinder() != caller.asBinder())) {
               // 进程不存在(死亡了)，也是不能注册成功的
               return null;
           }
        　 //mRegisteredReceivers表存了所有动态注册的广播接收者，
　　　　 //由receiver作为key，获取到ReceiverList，为什么是ReceiverList，
　　　　//而不是一个Receiver呢，因为一个广播可能会有多个接收者，
　　　　 //最好整成一个队列或者链表的形式，而ReceiverList继承ArrayList，满足这个需求。
　　　　 //每个ReceiverList都对应着Client端的一个ReceiverDispatcher。
           ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder());
           if (rl == null) {
               rl = new ReceiverList(this, callerApp, callingPid, callingUid,
                       userId, receiver);
               if (rl.app != null) {
                   //把广播接收者列表加到这个进程对象的receivers中
                   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);
           }
         //在AMS内部，广播接收者实际上是BroadcastFilter来描述的，
　　　 //由filter等参数创建BroadcastFilter对象，并添加到接收者队列,
　　　 //注意只有registerReceiver()过程才会创建BroadcastFilter,也就是该对
　　　 //象用于动态注册的广播Receiver;，静态的接收者对象不是BroadcastFilter。
           BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,
                   permission, callingUid, userId);
           rl.add(bf);
           if (!bf.debugCheck()) {
               Slog.w(TAG, "==> For Dynamic broadcast");
           }
           mReceiverResolver.addFilter(bf);

           //如果是粘性广播，创建BroadcastRecord，并添加到
　　　//BroadcastQueue的并行广播队列(mParallelBroadcasts)，
　　　 //注册后调用AMS来尽快处理该广播。
           if (allSticky != null) {
               ArrayList receivers = new ArrayList();
               receivers.add(bf);

               final int stickyCount = allSticky.size();
               for (int i = 0; i < stickyCount; i++) {
                   Intent intent = allSticky.get(i);
                   BroadcastQueue queue = broadcastQueueForIntent(intent);
                   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);
                   queue.enqueueParallelBroadcastLocked(r);
                   queue.scheduleBroadcastsLocked();
               }
           }

         //返回值是一个Intent
           return sticky;
       }
   }

总结一下：动态注册是调用registerReceiver来注册的，大致流程如下：

在Android系统中，系统每加载一个apk，就会有一个LoadedApk对象。而每个LoadedApk对象里会有一张名字为mReceivers的HashMap，用来记录每个apk里面动态注册了那些广播接收者。mReceivers的类型是ArrayMap<Context, ArrayMap<BroadcastReceiver, ReceiverDispatcher>>，泛型中的Context代表是谁注册的，后面的值也是个map ，ArrayMap<BroadcastReceiver, ReceiverDispatcher>表示BroadcastReceiver与ReceiverDispatcher一一对应，一个BroadcastReceiver对应一个ReceiverDispatcher，通过这个定义可以知道，不管一个Activity注册了多少BroadcastReceiver，ReceiverDispatcher只有一个。ReceiverDispatcher内部有一个InnerReceiver的Binder对象，最终是把这个InnerReceiver发送给了AMS,AMS内部也维护了一张表mRegisteredReceivers，用来记录所有动态注册的接收者，首先会根据传进来的InnerReceiver对象取出来一个ReceiverList，ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder())，所以实质上每个ReceiverList都对应着Client端的一个ReceiverDispatcher。最后把创建的对象BroadcastFilter（AMS内部广播接收者用BroadcastFilter来表示）加到ReceiverList接收者队列中，注册完毕！

1.２ 静态广播注册

静态注册就是在manifest中注册。

<receiver android:name=".MyReceiver">
   <intent-filter>
       <action android:name="android.intent.action.MY_BROADCAST"/>
       <category android:name="android.intent.category.DEFAULT" />
   </intent-filter>
</receiver>

它们的信息会在系统启动时，由PackageManagerService（PMS）解析（在该类的构造方法中会对各个应用安装目录的apk文件进行扫描解析）并记录下来。

if (tagName.equals("activity")) {
               Activity a = parseActivity(owner, res, parser, flags, outError, false,
                       owner.baseHardwareAccelerated);
               if (a == null) {
                   mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
                   return false;
               }
               owner.activities.add(a);
           } else if (tagName.equals("receiver")) {
               Activity a = parseActivity(owner, res, parser, flags, outError, true, false);
               if (a == null) {
                   mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
                   return false;
               }
               owner.receivers.add(a);
           } else if (tagName.equals("service")) {
               Service s = parseService(owner, res, parser, flags, outError);
               if (s == null) {
                   mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
                   return false;
               }
               owner.services.add(s);
           } else if (tagName.equals("provider")) {
               Provider p = parseProvider(owner, res, parser, flags, outError);
               if (p == null) {
                   mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
                   return false;
               }
               owner.providers.add(p);
           }

经过上面的解析receiver就被保存到了owner.receivers中去了。然后AM会调用PMS的接口来查询“和intent匹配的组件”时，PMS内部就会去查询当初记录下来的数据，并把结果返回AMS。

 List<ResolveInfo> newReceivers = AppGlobals.getPackageManager()
                       .queryIntentReceivers(intent, resolvedType, pmFlags, user).getList();

@Override
   public @NonNull ParceledListSlice<ResolveInfo> queryIntentReceivers(Intent intent,
           String resolvedType, int flags, int userId) {
       return new ParceledListSlice<>(
               queryIntentReceiversInternal(intent, resolvedType, flags, userId));
   }

   private @NonNull List<ResolveInfo> queryIntentReceiversInternal(Intent intent,
           String resolvedType, int flags, int userId) {
       if (!sUserManager.exists(userId)) return Collections.emptyList();
       flags = updateFlagsForResolve(flags, userId, intent);
       ComponentName comp = intent.getComponent();
       if (comp == null) {
           if (intent.getSelector() != null) {
               intent = intent.getSelector();
               comp = intent.getComponent();
           }
       }
       if (comp != null) {
           List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
           ActivityInfo ai = getReceiverInfo(comp, flags, userId);
           if (ai != null) {
               ResolveInfo ri = new ResolveInfo();
               ri.activityInfo = ai;
               list.add(ri);
           }
           return list;
       }

       // reader
       synchronized (mPackages) {
           String pkgName = intent.getPackage();
           if (pkgName == null) {
               return mReceivers.queryIntent(intent, resolvedType, flags, userId);
           }
           final PackageParser.Package pkg = mPackages.get(pkgName);
           if (pkg != null) {
               return mReceivers.queryIntentForPackage(intent, resolvedType, flags, pkg.receivers,
                       userId);
           }
           return Collections.emptyList();
       }
   }

因为涉及PMS，这段逻辑想写清楚篇幅会比较大，所以，不深入讨论，以上关于广播的动态注册和静态注册就介绍完了。