一：廣播注冊過程

注冊過程

注冊過程補(bǔ)充

1. ContextImpl.registerReceiverInternal()：
(1) 獲得一個ItentReceiver對象夕玩，用來進(jìn)行Binder通信荷辕。
(2) 通過ActivityManagerProxy來進(jìn)行跨進(jìn)程注冊廣播贰拿。

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

2. LoadApk.getReceiverDispatcher()：
1 獲得LoadApk.ReceiverDispacher. IIntentReceiver對象械荷，IIntentReceiver對象 是一個Binder對象，可以用來跨進(jìn)程傳輸暮现。
2 BroadCastReceiver是系統(tǒng)組件，不能跨進(jìn)程傳輸，所以用IIntentReceiver來進(jìn)行代替BroadCastReceiver來進(jìn)行跨進(jìn)程傳輸灿椅。
3 map里面存儲的是 <BroadcastReceiver, LoadedApk.ReceiverDispatcher>鍵值對，用來做緩存钞支。

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>();
                         mReceivers.put(context, map);
                    }
                    map.put(r, rd);
                 }
             } else {
                rd.validate(context, handler);
           }
             rd.mForgotten = false;
            return rd.getIIntentReceiver();
        }
    }

3. LoadApk.ReceiverDispatcher.InnerReceiver：是IIntentReceiver.Stub的實(shí)現(xiàn)類.是Binder對象

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;
             }
            public void performReceive(Intent intent, int resultCode, String data,
                     Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
                LoadedApk.ReceiverDispatcher rd = mDispatcher.get();
               if (ActivityThread.DEBUG_BROADCAST) {
                    int seq = intent.getIntExtra("seq", -1);
                    Slog.i(ActivityThread.TAG, "Receiving broadcast " + intent.getAction() + " seq=" + seq
                             + " to " + (rd != null ? rd.mReceiver : null));
                }
                if (rd != null) {
                   rd.performReceive(intent, resultCode, data, extras,
                             ordered, sticky, sendingUser);
                 } else {
                    // The activity manager dispatched a broadcast to a registered
                     // receiver in this process, but before it could be delivered the
                    // receiver was unregistered.  Acknowledge the broadcast on its
                     // behalf so that the system's broadcast sequence can continue.
                     if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
                            "Finishing broadcast to unregistered receiver");
                     IActivityManager mgr = ActivityManagerNative.getDefault();
                     try {
                         if (extras != null) {
                           extras.setAllowFds(false);
                         }
                        mgr.finishReceiver(this, resultCode, data, extras, false);
                     } catch (RemoteException e) {
                       Slog.w(ActivityThread.TAG, "Couldn't finish broadcast to unregistered receiver");
                     }
                 }
            }
        }

二：廣播的發(fā)送和接收過程

廣播的發(fā)送和接收過程

三：廣播工作過程細(xì)致分析

(1)BroadcastReceiver和廣播的匹配過程

在broadcastIntentLocked方法內(nèi)部有如下代碼：

// Figure out who all will receive this broadcast.
List receivers = null;
List<BroadcastFilter> registeredReceivers = null;
// Need to resolve the intent to interested receivers...
if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY)
         == 0) {
    receivers = collectReceiverComponents(intent, resolvedType, callingUid, users);
}
if (intent.getComponent() == null) {
    if (userId == UserHandle.USER_ALL && callingUid == Process.SHELL_UID) {
        // Query one target user at a time, excluding shell-restricted users
        // 略
    } else {
        registeredReceivers = mReceiverResolver.queryIntent(intent,
                resolvedType, false, userId);
    }
}

receivers = collectReceiverComponents(intent, resolvedType, callingUid, users);
registeredReceivers = mReceiverResolver.queryIntent(intent, resolvedType, false, userId);

receivers：是對這個廣播感興趣的靜態(tài)BroadcastReceiver列表
mReceiverResolver：存儲了動態(tài)注冊的BroadcastReceiver的信息茫蛹；通過mReceiverResolver.qureyIntent匹配出了對應(yīng)的BroadcastReceiver供進(jìn)一步使用。

(2)接收過程

broadcastIntentLocked方法的后半部分有如下代碼
1 首先創(chuàng)建了一個BroadcastRecord代表此次發(fā)送的這條廣播烁挟，然后把它丟進(jìn)一個隊(duì)列婴洼，最后通過scheduleBroadcastsLocked通知隊(duì)列對廣播進(jìn)行處理。

BroadcastQueue queue = broadcastQueueForIntent(intent);
BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
        callerPackage, callingPid, callingUid, resolvedType,
        requiredPermissions, appOp, brOptions, receivers, resultTo, resultCode,
        resultData, resultExtras, ordered, sticky, false, userId);

boolean replaced = replacePending && queue.replaceOrderedBroadcastLocked(r);
if (!replaced) {
    queue.enqueueOrderedBroadcastLocked(r);
    queue.scheduleBroadcastsLocked();
}

BroadcastQueue.scheduleBroadcastsLocked()
在BroadcastQueue中通過Handler調(diào)度了對于廣播處理的消息撼嗓，調(diào)度過程由processNextBroadcast方法完成柬采。

public void scheduleBroadcastsLocked() {
       if (DEBUG_BROADCAST) Slog.v(TAG, "Schedule broadcasts ["
                 + mQueueName + "]: current="
               + mBroadcastsScheduled);

       if (mBroadcastsScheduled) {
            return;
         }
         mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
         mBroadcastsScheduled = true;
     }
}

BroadcastQueue.processNextBroadcast()：這個方法通過performReceiveLocked最終調(diào)用了IIntentReceiver的performReceive方法。

private final class BroadcastHandler extends Handler {
         public BroadcastHandler(Looper looper) {
             super(looper, null, true);
         }
 
        @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                case BROADCAST_INTENT_MSG: {
                    if (DEBUG_BROADCAST) Slog.v(
                             TAG, "Received BROADCAST_INTENT_MSG");
                     processNextBroadcast(true);
                } break;
                 case BROADCAST_TIMEOUT_MSG: {
                     synchronized (mService) {
                        broadcastTimeoutLocked(true);
                     }
               } break;
             }
        }
};