public Intent registerReceiver(IApplicationThread caller, String callerPackage,
        IIntentReceiver receiver, IntentFilter filter, String permission, int userId) {
    ArrayList<Intent> stickyIntents = null;
    ProcessRecord callerApp = null;
    ...
    synchronized(this) {
        if (caller != null) {
            //从mLruProcesses查询调用者的进程信息
            callerApp = getRecordForAppLocked(caller);
            ...
            callingUid = callerApp.info.uid;
            callingPid = callerApp.pid;
        } else {
            callerPackage = null;
            callingUid = Binder.getCallingUid();
            callingPid = Binder.getCallingPid();
        }

        userId = handleIncomingUser(callingPid, callingUid, userId,
                true, ALLOW_FULL_ONLY, "registerReceiver", callerPackage);

        //获取IntentFilter中的actions. 这就是平时所加需要监听的广播action
        Iterator<String> actions = filter.actionsIterator();
        if (actions == null) {
            ArrayList<String> noAction = new ArrayList<String>(1);
            noAction.add(null);
            actions = noAction.iterator();
        }

        int[] userIds = { UserHandle.USER_ALL, UserHandle.getUserId(callingUid) };
        while (actions.hasNext()) {
            String action = actions.next();
            for (int id : userIds) {
                //从mStickyBroadcasts中查看用户的sticky Intent
                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>();
                        }
                        //将sticky Intent加入到队列
                        stickyIntents.addAll(intents);
                    }
                }
            }
        }
    }

    ArrayList<Intent> allSticky = null;
    if (stickyIntents != null) {
        final ContentResolver resolver = mContext.getContentResolver();
        for (int i = 0, N = stickyIntents.size(); i < N; i++) {
            Intent intent = stickyIntents.get(i);
            //查询匹配的sticky广播 【见2.5.2】
            if (filter.match(resolver, intent, true, TAG) >= 0) {
                if (allSticky == null) {
                    allSticky = new ArrayList<Intent>();
                }
                //匹配成功，则将给intent添加到allSticky队列
                allSticky.add(intent);
            }
        }
    }

    //当IIntentReceiver为空，则直接返回第一个sticky Intent，
    Intent sticky = allSticky != null ? allSticky.get(0) : null;
    if (receiver == null) {
        return sticky;
    }

    synchronized (this) {
        if (callerApp != null && (callerApp.thread == null
                || callerApp.thread.asBinder() != caller.asBinder())) {
            return null; //调用者已经死亡
        }
        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 {
                receiver.asBinder().linkToDeath(rl, 0); //注册死亡通知
                ...
                rl.linkedToDeath = true;
            }
            //新创建的接收者队列，添加到已注册广播队列。
            mRegisteredReceivers.put(receiver.asBinder(), rl);
        }
        ...
        //创建BroadcastFilter对象，并添加到接收者队列
        BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,
                permission, callingUid, userId);
        rl.add(bf);
        //新创建的广播过滤者，添加到ReceiverResolver队列
        mReceiverResolver.addFilter(bf);

        //所有匹配该filter的sticky广播执行入队操作
        //如果没有使用sendStickyBroadcast，则allSticky=null。
        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);
                //根据intent返回前台或后台广播队列
                BroadcastQueue queue = broadcastQueueForIntent(intent);
                //创建BroadcastRecord
                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);
                //调度广播，发送BROADCAST_INTENT_MSG消息，触发处理下一个广播。
                queue.scheduleBroadcastsLocked();
            }
        }
        return sticky;
    }
}

public final class BroadcastQueue {
    //...

    /**
     * Lists of all active broadcasts that are to be executed immediately
     * (without waiting for another broadcast to finish).  Currently this only
     * contains broadcasts to registered receivers, to avoid spinning up
     * a bunch of processes to execute IntentReceiver components.  Background-
     * and foreground-priority broadcasts are queued separately.
     */
    final ArrayList<BroadcastRecord> mParallelBroadcasts = new ArrayList<>();

    /**
     * List of all active broadcasts that are to be executed one at a time.
     * The object at the top of the list is the currently activity broadcasts;
     * those after it are waiting for the top to finish.  As with parallel
     * broadcasts, separate background- and foreground-priority queues are
     * maintained.
     */
    final ArrayList<BroadcastRecord> mOrderedBroadcasts = new ArrayList<>();

    public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
        mParallelBroadcasts.add(r);
        r.enqueueClockTime = System.currentTimeMillis();
    }

}

public final int broadcastIntent(IApplicationThread caller, Intent intent, String resolvedType, IIntentReceiver resultTo, int resultCode, String resultData, Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle options, boolean serialized, boolean sticky, int userId) {
    enforceNotIsolatedCaller("broadcastIntent");
    synchronized(this) {
        //验证广播intent是否有效
        intent = verifyBroadcastLocked(intent);
        //获取调用者进程记录对象
        final ProcessRecord callerApp = getRecordForAppLocked(caller);
        final int callingPid = Binder.getCallingPid();
        final int callingUid = Binder.getCallingUid();
        final long origId = Binder.clearCallingIdentity();
        int res = broadcastIntentLocked(callerApp,
                callerApp != null ? callerApp.info.packageName : null,
                intent, resolvedType, resultTo, resultCode, resultData, resultExtras,
                requiredPermissions, appOp, null, serialized, sticky,
                callingPid, callingUid, userId);
        Binder.restoreCallingIdentity(origId);
        return res;
    }
}

private final int broadcastIntentLocked(ProcessRecord callerApp,     
        String callerPackage, Intent intent, String resolvedType,     
        IIntentReceiver resultTo, int resultCode, String resultData,     
        Bundle map, String requiredPermission,     
        boolean ordered, boolean sticky, int callingPid, int callingUid) {     
  
    …………  
    …………  
      
    // 静态广播接收器list  
    List receivers = null;   
      
    // 动态广播接收器List  
    List<BroadcastFilter> registeredReceivers = null;     
  
    // 获取静态广播接收器mReceivers  
    try {     
        if (intent.getComponent() != null) {     
            // Broadcast is going to one specific receiver class...     
            ActivityInfo ai = AppGlobals.getPackageManager().     
                getReceiverInfo(intent.getComponent(), STOCK_PM_FLAGS);     
            if (ai != null) {     
                receivers = new ArrayList();     
                ResolveInfo ri = new ResolveInfo();     
                ri.activityInfo = ai;  
                receivers.add(ri);     
            }     
        } else {     
            // Need to resolve the intent to interested receivers...     
            if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY)     
                     == 0) {     
                receivers =     
                    AppGlobals.getPackageManager().queryIntentReceivers(     
                            intent, resolvedType, STOCK_PM_FLAGS);     
            }   
            // 获取动态广播接收器mReceiverResolver  
            registeredReceivers = mReceiverResolver.queryIntent(intent, resolvedType, false);     
        }     
    } catch (RemoteException ex) {     
        // pm is in same process, this will never happen.     
    }     
    
    final boolean replacePending =     
            (intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;     
        
    int NR = registeredReceivers != null ? registeredReceivers.size() : 0;    
    ……  
    // 如果接收到的广播 是普通广播。  
    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.     
        BroadcastRecord r = new BroadcastRecord(intent, callerApp,     
                callerPackage, callingPid, callingUid, requiredPermission,     
                registeredReceivers, resultTo, resultCode, resultData, map,     
                ordered, sticky, false);     
  
    // 很明显接收到普通广播之后，在这只处理了动态广播 registeredReceivers，对于普通广播而言，动态广播接收器要优先于静态广播接收器 无关设置的优先级  
        boolean replaced = false;     
        if (replacePending) {     
            for (int i=mParallelBroadcasts.size()-1; i>=0; i--) {     
                if (intent.filterEquals(mParallelBroadcasts.get(i).intent)) {     
                    if (DEBUG_BROADCAST) Slog.v(TAG,     
                            "***** DROPPING PARALLEL: " + intent);     
                    mParallelBroadcasts.set(i, r);     
                    replaced = true;     
                    break;     
                }     
            }     
        }     
        if (!replaced) {     
            mParallelBroadcasts.add(r);     
            scheduleBroadcastsLocked();     
        }     
        //将registeredReceivers置为null，后面只处理静态广播接收器，所以不会有冲突。  
        registeredReceivers = null;     
        NR = 0;     
    }     
      
    //如果是有序广播，将静态广播接收器和动态广播接收器组合成一个最终的顺序  
    int ir = 0;     
    if (receivers != null) {     
        ...     
        //合并的过程，注意顺序     
        int NT = receivers != null ? receivers.size() : 0;     
        int it = 0;     
        ResolveInfo curt = null;     
        BroadcastFilter curr = null;     
        while (it < NT && ir < NR) {     
            if (curt == null) {     
                curt = (ResolveInfo)receivers.get(it);     
            }     
            if (curr == null) {     
                curr = registeredReceivers.get(ir);     
            }     
            //如果动态广播接收器优先级高于或者等于静态广播接收器，那么就插到前面        
            //很明显动态的要在静态的前面   
            if (curr.getPriority() >= curt.priority) {     
                // Insert this broadcast record into the final list.     
                receivers.add(it, curr);     
                ir++;     
                curr = null;     
                it++;     
                NT++;     
            } else {     
                // Skip to the next ResolveInfo in the final list.     
                it++;     
                curt = null;     
            }     
        }     
    }