registerReceiver

registerReceiver方法有很多重載方法，但是最終的入口都是在ContextImpl中，

private Intent registerReceiverInternal(BroadcastReceiver receiver, int userId,IntentFilter filter, String broadcastPermission,Handler scheduler, Context context, int flags) {IIntentReceiver rd = null;if (receiver != null) {if (mPackageInfo != null && context != null) {if (scheduler == null) {// 注冊receiver的時候可以指定接受receiver的Handler// 如果沒有指定，則默認用主線程的handler處理scheduler = mMainThread.getHandler();}// 獲取IIntentReceiver，Binder對象，當廣播來臨時，用于AMS向客戶端發起回調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 {// 通過Binder與AMS通信，進行廣播注冊final Intent intent = ActivityManager.getService().registerReceiver(mMainThread.getApplicationThread(), mBasePackageName, rd, filter,broadcastPermission, userId, flags);if (intent != null) {intent.setExtrasClassLoader(getClassLoader());intent.prepareToEnterProcess();}return intent;} catch (RemoteException e) {throw e.rethrowFromSystemServer();}}

在新建廣播接收發布器ReceiverDispatcher時，會在構造函數里面創建一個InnerReceiver實例，這是一個Binder對象，實現了IIntentReceiver接口，可以通過ReceiverDispatcher.getIIntentReceiver函數來獲得，即獲取到上面的rd對象，獲得后就會把它傳給ActivityManagerService，以便接收廣播。

有兩個重要的地方：1.getReceiverDispatcher方法? ? ? 2.ActivityManager.getService().registerReceiver方法

下面分析第一個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;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();}}

該函數通過參數r在ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher>判斷ReceiverDispatcher是否存在了，有就直接返回了，否則新建一個ReceiverDispatcher并保存。接下來是以Context，這里即為MainActivity為Key，以上面ArrayMap為值保存在LoadedApk的成員變量mReceivers中，這樣，只要給定一個Activity和BroadcastReceiver，就可以查看LoadedApk里面是否已經存在相應的廣播接收發布器ReceiverDispatcher了。

所以該方法就是返回一個ReceiverDispatcher對象，通過該對象可以獲取rd實例。

ActivityManager.getService().registerReceiver方法通過Binder驅動程序就進入到ActivityManagerService中的registerReceiver函數中去了。下面看AMS的registerReceiver方法，rd傳入參數名為receiver。

public Intent registerReceiver(IApplicationThread caller, String callerPackage,IIntentReceiver receiver, IntentFilter filter, String permission, int userId,int flags) {//省略了關于粘性廣播的代碼 .....ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder());if (rl == null) {//receiver封裝到一個ReceiverList對象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);} //rl又封裝到BroadcastFilter BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,permission, callingUid, userId, instantApp, visibleToInstantApps);rl.add(bf);if (!bf.debugCheck()) {Slog.w(TAG, "==> For Dynamic broadcast");}//bf添加到mReceiverResolver內部的集合中了mReceiverResolver.addFilter(bf);return sticky;} }

把廣播接收器receiver保存一個ReceiverList列表中，這個列表的宿主進程是rl.app，這里就是MainActivity所在的進程了，在ActivityManagerService中，用一個進程記錄塊來表示這個應用程序進程，它里面有一個列表receivers，專門用來保存這個進程注冊的廣播接收器。接著，又把這個ReceiverList列表以receiver為Key保存在ActivityManagerService的成員變量mRegisteredReceivers中，這些都是為了方便在收到廣播時，快速找到對應的廣播接收器的。

接著創建一個BroadcastFilter來把廣播接收器列表rl和filter關聯起來，然后保存在ActivityManagerService中的成員變量mReceiverResolver中去。

總結：廣播注冊，主要就是將廣播接收器receiver及其要接收的廣播類型filter保存在ActivityManagerService中，以便以后能夠接收到相應的廣播并進行處理。

sendBroadcast

ActivityManager.getService().broadcastIntent(mMainThread.getApplicationThread(), intent, resolvedType, null,Activity.RESULT_OK, null, null, receiverPermissions, appOp, null, false, false,getUserId());

無論是有序還是無序廣播，最后都是通過該方法進入到ActivityManagerService中的broadcastIntent函數中去。

public final int broadcastIntent(IApplicationThread caller,Intent intent, String resolvedType, IIntentReceiver resultTo,int resultCode, String resultData, Bundle resultExtras,String[] requiredPermissions, int appOp, Bundle bOptions,boolean serialized, boolean sticky, int userId) {enforceNotIsolatedCaller("broadcastIntent");synchronized(this) {.....int res = broadcastIntentLocked(callerApp,callerApp != null ? callerApp.info.packageName : null,intent, resolvedType, resultTo, resultCode, resultData, resultExtras,requiredPermissions, appOp, bOptions, serialized, sticky,callingPid, callingUid, userId);Binder.restoreCallingIdentity(origId);return res;}}

進入ActivityManagerService.broadcastIntentLocked方法

final int broadcastIntentLocked(ProcessRecord callerApp,String callerPackage, Intent intent, String resolvedType,IIntentReceiver resultTo, int resultCode, String resultData,Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle bOptions,boolean ordered, boolean sticky, int callingPid, int callingUid, int userId) {....... ........ queue.enqueueOrderedBroadcastLocked(r);queue.scheduleBroadcastsLocked();........ return ActivityManager.BROADCAST_SUCCESS;}

內部調用了broadcastIntentLocked方法。這個方法比較長，前面的流程是在判斷是否是系統的廣播，如果是系統的廣播，則拋出安全權限異常。對動態，靜態廣播進行合并，獲取所有接收該廣播的廣播接收器，然后封裝到BroadcastRecord對象，并且添加到BroadcastQueue中。

scheduleBroadcastsLocked方法，發送了一個消息 public void scheduleBroadcastsLocked() {if (mBroadcastsScheduled) {return;}mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));mBroadcastsScheduled = true; }

此處的handler的線程還是在AMS線程

public void handleMessage(Message msg) {switch (msg.what) {case BROADCAST_INTENT_MSG: {processNextBroadcast(true);} break;case BROADCAST_TIMEOUT_MSG: {synchronized (mService) {broadcastTimeoutLocked(true);}} break;}}

processNextBroadcast方法也很長，是廣播調度與派發的流程。

進程在的情況下processCurBroadcastLocked

進程不在則啟動進程，記錄要處理的廣播mPendingBroadcast

final void processNextBroadcast(boolean fromMsg) {synchronized(mService) {BroadcastRecord r;.....// First, deliver any non-serialized broadcasts right away.while (mParallelBroadcasts.size() > 0) {r = mParallelBroadcasts.remove(0);r.dispatchTime = SystemClock.uptimeMillis();r.dispatchClockTime = System.currentTimeMillis(); final int N = r.receivers.size();for (int i=0; i<N; i++) {Object target = r.receivers.get(i);if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,"Delivering non-ordered on [" + mQueueName + "] to registered "+ target + ": " + r);deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);}addBroadcastToHistoryLocked(r);if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Done with parallel broadcast ["+ mQueueName + "] " + r);}....}

?deliverToRegisteredReceiverLocked方法，主要里面調用了performReceiveLocked方法

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.try {app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,data, extras, ordered, sticky, sendingUser, app.repProcState);} catch (RemoteException ex) {.... }} }

調用了ActivityThread的scheduleRegisteredReceiver方法

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

這里調用了receiver的performReceive方法

public void performReceive(Intent intent, int resultCode, String data,Bundle extras, boolean ordered, boolean sticky, int sendingUser) {final Args args = new Args(intent, resultCode, data, extras, ordered,sticky, sendingUser);if (intent == null || !mActivityThread.post(args.getRunnable())) {if (mRegistered && ordered) {IActivityManager mgr = ActivityManager.getService();if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,"Finishing sync broadcast to " + mReceiver);args.sendFinished(mgr);}} }

post了一個Runnable，這個Runnable里面的代碼就會調用我們的onReceive方法。

public final Runnable getRunnable() {return () -> {final BroadcastReceiver receiver = mReceiver;final IActivityManager mgr = ActivityManager.getService();final Intent intent = mCurIntent;mCurIntent = null;mDispatched = true;mPreviousRunStacktrace = new Throwable("Previous stacktrace");try {ClassLoader cl = mReceiver.getClass().getClassLoader();intent.setExtrasClassLoader(cl);intent.prepareToEnterProcess();setExtrasClassLoader(cl);receiver.setPendingResult(this);receiver.onReceive(mContext, intent);} catch (Exception e) {}}; }

總結

以上是生活随笔為你收集整理的Android—Broadcast原理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。