源碼分析廣播運行原理
作者：Android開發編程
在 Android 里面有各種各樣的廣播，比如電池的使用狀態，電話的接收和短信的接收都會產生一個廣播，應用程序開發者也可以監聽這些廣播并做出程序邏輯的處理。
前言
在 Android 里面有各種各樣的廣播，比如電池的使用狀態，電話的接收和短信的接收都會產生一個廣播，應用程序開發者也可以監聽這些廣播并做出程序邏輯的處理;
今天我們就來分析下廣播的運行機制
一、廣播原理機制詳解
1、靜態廣播注冊流程分析
- 靜態廣播是通過PackageManagerService在啟動的時候掃描已安裝的應用去注冊的;
- 在PackageManagerService的構造方法中,會去掃描應用安裝目錄,順序是先掃描系統應用安裝目錄再掃描第三方應用安裝目錄;
PackageManagerService.scanDirLI就是用于掃描目錄的方法:
- private void scanDirLI(File dir, int flags, int scanMode, long currentTime) {
- String[] files = dir.list();
- if (files == null) {
- return;
- }
- int i;
- for (i=0; i<files.length; i++) {
- File file = new File(dir, files[i]);
- if (!isPackageFilename(files[i])) {
- continue;
- }
- PackageParser.Package pkg = scanPackageLI(file,
- flags|PackageParser.PARSE_MUST_BE_APK, scanMode, currentTime, null);
- if (pkg == null && (flags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
- mLastScanError == PackageManager.INSTALL_FAILED_INVALID_APK) {
- file.delete();
- }
- }
- }
- private static final boolean isPackageFilename(String name) {
- return name != null && name.endsWith(".apk");
- }
- 可以看到,它通過File.list方法列出目錄下的所有后綴為".apk"的文件傳給scanPackageLI去處理;
- 而scanPackageLI(File scanFile,int parseFlags, int scanMode, long currentTime, UserHandle user)內部會調用它的重載方法;
- scanPackageLI(PackageParser.Package pkg,int parseFlags, int scanMode, long currentTime, UserHandle user):
- private PackageParser.Package scanPackageLI(File scanFile,int parseFlags, int scanMode, long currentTime, UserHandle user) {
- ...
- final PackageParser.Package pkg = pp.parsePackage(scanFile,scanPath, mMetrics, parseFlags);
- ...
- PackageParser.Package scannedPkg = scanPackageLI(pkg, parseFlags, scanMode | SCAN_UPDATE_SIGNATURE, currentTime, user);
- ...
- }
在這個scanPackageLIl里面會解析Package并且將AndroidManifest.xml中注冊的BroadcastReceiver保存下來:
- ...
- N = pkg.receivers.size();
- r = null;
- for (i=0; i<N; i++) {
- PackageParser.Activity a = pkg.receivers.get(i);
- a.info.processName = fixProcessName(pkg.applicationInfo.processName,
- a.info.processName, pkg.applicationInfo.uid);
- mReceivers.addActivity(a, "receiver");
- ...
- }
- ...
靜態廣播的流程:
- 系統應用的廣播先于第三方應用的廣播注冊;
- 而安裝在同一個目錄下的應用的靜態廣播的注冊順序是按照File.list列出來的apk的順序注冊的;
- 他們的注冊順序就決定了它們接收廣播的順序;
- 通過靜態廣播的注冊流程,我們已經將靜態廣播注冊到了PackageManagerService的mReceivers中;
而我們可以使用PackageManagerService.queryIntentReceivers方法查詢intent對應的靜態廣播
- public List<ResolveInfo> queryIntentReceivers(Intent intent, String resolvedType, int flags, int userId) {
- if (!sUserManager.exists(userId)) return Collections.emptyList();
- 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;
- }
- 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 null;
- }
- }
2、動態廣播注冊流程分析
我們調用Context.registerReceiver最后會調到ActivityManagerService.registerReceiver:
- public Intent registerReceiver(IApplicationThread caller, String callerPackage, IIntentReceiver receiver, IntentFilter filter, String permission, int userId) {
- ...
- ReceiverList rl = (ReceiverList)mRegisteredReceivers.get(receiver.asBinder());
- ...
- BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage, permission, callingUid, userId);
- ...
- mReceiverResolver.addFilter(bf);
- ...
- }
所以通過mReceiverResolver.queryIntent就能獲得intent對應的動態廣播了;
3、發送廣播流程分析
ContextImpl.sendBroadcast中會調用ActivityManagerNative.getDefault().broadcastIntent()
- public void sendBroadcast(Intent intent) {
- warnIfCallingFromSystemProcess();
- String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());
- try {
- intent.prepareToLeaveProcess();
- ActivityManagerNative.getDefault().broadcastIntent(
- mMainThread.getApplicationThread(), intent, resolvedType, null,
- Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, false, false,getUserId());
- } catch (RemoteException e) {
- }
- }
實際是調用ActivityManagerService.broadcastIntent:
- public final int broadcastIntent(IApplicationThread caller,
- Intent intent, String resolvedType, IIntentReceiver resultTo,
- int resultCode, String resultData, Bundle map,
- String requiredPermission, int appOp, boolean serialized, boolean sticky, int userId) {
- enforceNotIsolatedCaller("broadcastIntent");
- synchronized(this) {
- 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, map, requiredPermission, appOp, serialized, sticky,
- callingPid, callingUid, userId);
- Binder.restoreCallingIdentity(origId);
- return res;
- }
- }
調用ActivityManagerService.broadcastIntentLocked,而broadcastIntentLocked中的關鍵代碼如下:
- broadcastIntentLocked
- // 靜態廣播
- List receivers = null;
- // 動態廣播
- List<BroadcastFilter> registeredReceivers = null;
- if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY)
- == 0) {
- // 查詢靜態廣播
- receivers = collectReceiverComponents(intent, resolvedType, users);
- }
- if (intent.getComponent() == null) {
- // 查詢動態廣播
- registeredReceivers = mReceiverResolver.queryIntent(intent,
- resolvedType, false, userId);
- }
- final boolean replacePending =
- (intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;
- int NR = registeredReceivers != null ? registeredReceivers.size() : 0;
- if (!ordered && NR > 0) {
- final BroadcastQueue queue = broadcastQueueForIntent(intent);
- BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
- callerPackage, callingPid, callingUid, resolvedType, requiredPermission,
- appOp, registeredReceivers, resultTo, resultCode, resultData, map,
- ordered, sticky, false, userId);
- final boolean replaced = replacePending && queue.replaceParallelBroadcastLocked(r);
- if (!replaced) {
- // 發送動態廣播
- queue.enqueueParallelBroadcastLocked(r);
- queue.scheduleBroadcastsLocked();
- }
- registeredReceivers = null;
- NR = 0;
- }
- ...
- if ((receivers != null && receivers.size() > 0)
- || resultTo != null) {
- BroadcastQueue queue = broadcastQueueForIntent(intent);
- BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
- callerPackage, callingPid, callingUid, resolvedType,
- requiredPermission, appOp, receivers, resultTo, resultCode,
- resultData, map, ordered, sticky, false, userId);
- boolean replaced = replacePending && queue.replaceOrderedBroadcastLocked(r);
- if (!replaced) {
- // 發送靜態廣播
- queue.enqueueOrderedBroadcastLocked(r);
- queue.scheduleBroadcastsLocked();
- }
- }
- 動態廣播會優先于靜態廣播,從上面的代碼我們可以看到;
- 實際上靜態廣播靜態就是從PackageManagerService中查詢的:
- private List<ResolveInfo> collectReceiverComponents(Intent intent, String resolvedType,
- int[] users) {
- ...
- List<ResolveInfo> newReceivers = AppGlobals.getPackageManager()
- .queryIntentReceivers(intent, resolvedType, STOCK_PM_FLAGS, user);
- ...
4、廣播隊列
- 從ActivityManagerService.broadcastIntentLocked中我們可以看到,實際上它不是直接將廣播發送到BroadcastReceiver中;
- 而是將他包裝到BroadcastRecord中,再放進BroadcastQueue:
- BroadcastQueue queue = broadcastQueueForIntent(intent);
- BroadcastRecord r = new BroadcastRecord(queue, intent, null,
- null, -1, -1, null, null, AppOpsManager.OP_NONE, receivers, null, 0,
- null, null, false, true, true, -1);
- queue.enqueueParallelBroadcastLocked(r);
- queue.scheduleBroadcastsLocked();
- enqueueParallelBroadcastLocked方法用于并發執行廣播的發送.它很簡單,就是將BroadcastRecord放到了mParallelBroadcasts中:
- public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
- mParallelBroadcasts.add(r);
- }
scheduleBroadcastsLocked方法同樣很簡單,就是向mHandler發送了個BROADCAST_INTENT_MSG消息:
- public void scheduleBroadcastsLocked() {
- if (mBroadcastsScheduled) {
- return;
- }
- mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
- mBroadcastsScheduled = true;
- }
mHandler在接收到BROADCAST_INTENT_MSG消息的時候會做些什么:
- final Handler mHandler = new Handler() {
- 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方法用于從隊列中獲取廣播消息并發送給BroadcastReceiver,它內部有兩個分支,并行處理和串行處理;
5、并行處理
動態注冊的非有序廣播等就是使用并行處理:
- final void processNextBroadcast(boolean fromMsg) {
- synchronized(mService) {
- BroadcastRecord r;
- mService.updateCpuStats();
- if (fromMsg) {
- mBroadcastsScheduled = false;
- }
- 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);
- // 發送消息給Receiver
- deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false);
- }
- addBroadcastToHistoryLocked(r);
- }
- ...
- }
- ...
- }
- private final void deliverToRegisteredReceiverLocked(BroadcastRecord r,
- BroadcastFilter filter, boolean ordered) {
- ...
- // 獲取BroadcastReceiver的Binder
- r.receiver = filter.receiverList.receiver.asBinder();
- ...
- // 使用Binder機制將消息傳遞給BroadcastReceiver
- performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
- new Intent(r.intent), r.resultCode, r.resultData,
- r.resultExtras, r.ordered, r.initialSticky, r.userId);
- ...
- }
- void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,
- Intent intent, int resultCode, String data, Bundle extras,
- boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
- ......
- //通過Binder將消息處理傳到應用進程,應用進程內部再使用Handler機制,將消息處理放到主線程中
- app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
- data, extras, ordered, sticky, sendingUser, app.repProcState);
- ......
- }
- }
6、串行處理
有序廣播和靜態廣播等,會通過enqueueOrderedBroadcastLocked傳給BroadcastQueue:
- public void enqueueOrderedBroadcastLocked(BroadcastRecord r) {
- mOrderedBroadcasts.add(r);
- }
然后在processNextBroadcast里面會對mOrderedBroadcasts進行特殊處理;
廣播隊列傳送廣播給Receiver的原理其實就是將BroadcastReceiver和消息都放到BroadcastRecord里面,然后通過Handler機制遍歷BroadcastQueue里面的BroadcastRecord,將消息發送給BroadcastReceiver;
二、廣播流程總結
1、Android廣播分為兩個方面：廣播發送者和廣播接收者：
- 廣播作為Android組件間的通信方式，可以使用的場景如下：
- 同一app內部的同一組件(Component)內的消息通信(單個或多個線程之間);
- 同一app內部的不同組件之間的消息通信(單個進程);
- 同一app具有多個進程的不同組件之間的消息通信;
- 不同app之間的組件之間消息通信;
- Android系統在特定情況下與App之間的消息通信;
2、實現原理
從實現原理上看，Android中的廣播使用了觀察者模式，基于消息的發布/訂閱事件模型。因此，從實現的角度來看，Android中的廣播將廣播的發送者和接受者極大程度上解耦，使得系統能夠方便集成，更易擴展。具體實現流程要點粗略概括如下：
- 廣播接收者BroadcastReceiver通過Binder機制向AMS(Activity Manager Service)進行注冊;
- 廣播發送者通過binder機制向AMS發送廣播;
- AMS查找符合相應條件(IntentFilter/Permission等)的BroadcastReceiver，將廣播發送到BroadcastReceiver相應的消息循環隊列中;
- 消息循環隊列拿到此廣播后，回調BroadcastReceiver中的onReceive()方法;
- 廣播發送者和廣播接收者分別屬于觀察者模式中的消息發布和訂閱兩端，AMS屬于中間的處理中心;
- 廣播發送者和廣播接收者的執行是異步的，發出去的廣播不會關心有無接收者接收，也不確定接收者到底是何時才能接收到;
總結
學如逆水行舟，不進則退。心似平原跑馬，易放難收;
本文轉載自微信公眾號「Android開發編程」
責任編輯：姜華
來源：
Android開發編程
