Isming | 码农明明桑

1

grep -c -w "vmx\|svm" /proc/cpuinfo

1

lunch aosp_cf_x86_64_phone-trunk_staging-eng

1
2
3

tools/buildutils/build_packages.sh
sudo dpkg -i ./cuttlefish-base_*_*64.deb || sudo apt-get install -f
sudo dpkg -i ./cuttlefish-user_*_*64.deb || sudo apt-get install -f

1

While resolving toolchains for target //src/tools/ak/generatemanifest:generatemanifest (6312974): invalid registered toolchain '@local_jdk//:bootstrap_runtime_toolchain_definition': no such target '@local_jdk//:bootstrap_runtime_toolchain_definition': target 'bootstrap_runtime_toolchain_definition' not declared in package '' defined by /home/sam/.cache/bazel/_bazel_jcater/ddb4e20e0e2e6bca92f5deeef02ce168/external/local_jdk/BUILD.bazel (Tip: use `query "@local_jdk//:*"` to see all the targets in that package)

1

bazel info java-home

1
2

sudo usermod -aG kvm,cvdnetwork,render $USER
sudo reboot

1
2

source ./build/envsetup.sh
lunch aosp_cf_x86_64_phone-trunk_staging-eng

1

launch_cvd --daemon

1

launch --help

1

stop_cvd

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

{
  "repoRoot" : "/home/sam/android/android-source",
  "modulePaths" : [
    "frameworks",
    "packages/inputmethods"
    ],
  "lunchTarget" : "aosp_cf_x86_64_phone-trunk_staging-eng",
  "nativeConfig" : {
    "excludePaths" : [ ],
    "excludeGenPaths" : [ ]
  },
  "syncConfig" : {
    "environmentVars" : { },
    "buildFlags" : [ ]
  }}

1
2
3

val br: BroadcastReceiver = MyBroadcastReceiver()
val filter = IntentFilter(ACTION_CHARGING)
activity.registerReceiver(br, filter)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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) {  
                scheduler = mMainThread.getHandler();  
            }  
            rd = mPackageInfo.getReceiverDispatcher(  
                receiver, context, scheduler,  
                mMainThread.getInstrumentation(), true);  
        } else {  
           ...
        }  
    }  
    try {  
        ActivityThread thread = ActivityThread.currentActivityThread();  
        Instrumentation instrumentation = thread.getInstrumentation();  
        if (instrumentation.isInstrumenting()  
                && ((flags & Context.RECEIVER_NOT_EXPORTED) == 0)) {  
            flags = flags | Context.RECEIVER_EXPORTED;  
        }  
        final Intent intent = ActivityManager.getService().registerReceiverWithFeature(  
                mMainThread.getApplicationThread(), mBasePackageName, getAttributionTag(),  
                AppOpsManager.toReceiverId(receiver), rd, filter, broadcastPermission, userId,  
                flags);  
        if (intent != null) {  
            intent.setExtrasClassLoader(getClassLoader());  
			intent.prepareToEnterProcess(
				ActivityThread.isProtectedBroadcast(intent),  
                getAttributionSource());  
        }  
        return intent;  
    } catch (RemoteException e) {  
        ...
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

public Intent registerReceiverWithFeature(IApplicationThread caller, String callerPackage,  
        String callerFeatureId, String receiverId, IIntentReceiver receiver,  
        IntentFilter filter, String permission, int userId, int flags) {
        ...
        synchronized(this) {
	        ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder());  
			if (rl == null) {  
			    rl = new ReceiverList(this, callerApp, callingPid, callingUid,  
		            userId, receiver);  
			    if (rl.app != null) {  
			        final int totalReceiversForApp = rl.app.mReceivers.numberOfReceivers();  
			        if (totalReceiversForApp >= MAX_RECEIVERS_ALLOWED_PER_APP) {  
			            throw new IllegalStateException("Too many receivers, total of "  
	                    + totalReceiversForApp + ", registered for pid: "  
	                    + rl.pid + ", callerPackage: " + callerPackage);  
			        }  
			        rl.app.mReceivers.addReceiver(rl);  
			    } else {  
			        try {  
			            receiver.asBinder().linkToDeath(rl, 0);  
			        } catch (RemoteException e) {  
			            return sticky;  
			        }  
			        rl.linkedToDeath = true;  
				}  
			    mRegisteredReceivers.put(receiver.asBinder(), rl);  
			} else {
			 // 处理userId， uid，pid 等不同的错误
			}

			BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage, callerFeatureId,  
		        receiverId, permission, callingUid, userId, instantApp, visibleToInstantApps,  
		        exported);  
			if (rl.containsFilter(filter)) {  
			} else {  
		    rl.add(bf);  
		    mReceiverResolver.addFilter(getPackageManagerInternal().snapshot(), bf);  
			}
        }
        ...        
}

1
2
3
4
5

Intent().also { intent -> 
	intent.setAction("com.example.broadcast.MY_NOTIFICATION") 
	intent.putExtra("data", "Nothing to see here, move along.")  
	activity.sendBroadcast(intent)  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

@Override  
public void sendBroadcast(Intent intent) {  
    warnIfCallingFromSystemProcess();  
    String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());  
    try {  
        intent.prepareToLeaveProcess(this);  
        ActivityManager.getService().broadcastIntentWithFeature(  
                mMainThread.getApplicationThread(), getAttributionTag(), intent, resolvedType,  
                null, Activity.RESULT_OK, null, null, null, null /*excludedPermissions=*/,  
                null, AppOpsManager.OP_NONE, null, false, false, getUserId());  
    } catch (RemoteException e) {  
        throw e.rethrowFromSystemServer();  
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

@Override  
public final int broadcastIntentWithFeature(IApplicationThread caller, String callingFeatureId,  
        Intent intent, String resolvedType, IIntentReceiver resultTo,  
        int resultCode, String resultData, Bundle resultExtras,  
        String[] requiredPermissions, String[] excludedPermissions,  
        String[] excludedPackages, int appOp, Bundle bOptions,  
        boolean serialized, boolean sticky, int userId) {  
    enforceNotIsolatedCaller("broadcastIntent");  
    synchronized(this) {  
        intent = verifyBroadcastLocked(intent);  
  
        final ProcessRecord callerApp = getRecordForAppLOSP(caller);  
        final int callingPid = Binder.getCallingPid();  
        final int callingUid = Binder.getCallingUid();  
  
        final long origId = Binder.clearCallingIdentity();  
        try {  
            return broadcastIntentLocked(callerApp,  
                    callerApp != null ? callerApp.info.packageName : null, callingFeatureId,  
                    intent, resolvedType, resultTo, resultCode, resultData, resultExtras,  
                    requiredPermissions, excludedPermissions, excludedPackages, appOp, bOptions,  
                    serialized, sticky, callingPid, callingUid, callingUid, callingPid, userId);  
        } finally {  
            Binder.restoreCallingIdentity(origId);  
        }  
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

//ActivityManagerService.java 
//final int broadcastIntentLocked(...)
intent = new Intent(intent);
intent.addFlags(Intent.FLAG_EXCLUDE_STOPPED_PACKAGES);
if (!mProcessesReady && (intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) == 0) {  
    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);  
}
userId = mUserController.handleIncomingUser(callingPid, callingUid, userId, true,  
        ALLOW_NON_FULL, "broadcast", callerPackage);
final String action = intent.getAction();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

if (action != null) {
	...
	switch (action) {
		...
		case Intent.ACTION_PACKAGE_DATA_CLEARED:
		{  
		    Uri data = intent.getData();  
		    String ssp;  
		    if (data != null && (ssp = data.getSchemeSpecificPart()) != null) {  
		        mAtmInternal.onPackageDataCleared(ssp, userId);  
		    }  
		    break;  
		}  
		case Intent.ACTION_TIMEZONE_CHANGED:  
			mHandler.sendEmptyMessage(UPDATE_TIME_ZONE);  
		    break;
		    ...
	}
}

1
2
3
4
5
6

int[] users;  
if (userId == UserHandle.USER_ALL) {  
    users = mUserController.getStartedUserArray();  
} else {  
    users = new int[] {userId};  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

List receivers = null;  
List<BroadcastFilter> registeredReceivers = null;  
if ((intent.getFlags() & Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {  
    receivers = collectReceiverComponents(  
            intent, resolvedType, callingUid, users, broadcastAllowList);  
}  
if (intent.getComponent() == null) {  
    final PackageDataSnapshot snapshot = getPackageManagerInternal().snapshot();  
    if (userId == UserHandle.USER_ALL && callingUid == SHELL_UID) {  
        ...
    } else {  
        registeredReceivers = mReceiverResolver.queryIntent(snapshot, intent,  
                resolvedType, false /*defaultOnly*/, userId);  
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

private List<ResolveInfo> collectReceiverComponents(Intent intent, String resolvedType,  
        int callingUid, int[] users, int[] broadcastAllowList) {  
    int pmFlags = STOCK_PM_FLAGS | MATCH_DEBUG_TRIAGED_MISSING;  
  
    List<ResolveInfo> receivers = null;  
    HashSet<ComponentName> singleUserReceivers = null;  
    boolean scannedFirstReceivers = false;  
    for (int user : users) {  
        List<ResolveInfo> newReceivers = mPackageManagerInt.queryIntentReceivers(  
                intent, resolvedType, pmFlags, callingUid, user, true /* forSend */);  //通过PMS，根据intent和uid读取Manifest中注册的接收器
        if (user != UserHandle.USER_SYSTEM && newReceivers != null) {  
            for (int i = 0; i < newReceivers.size(); i++) {  
                ResolveInfo ri = newReceivers.get(i);  
                //如果调用不是系统用户，移除只允许系统用户接收的接收器
                if ((ri.activityInfo.flags & ActivityInfo.FLAG_SYSTEM_USER_ONLY) != 0) {  
                    newReceivers.remove(i);  
                    i--;  
                }  
            }  
        }  
        // 把别名替换成真实的接收器  
        if (newReceivers != null) {  
            for (int i = newReceivers.size() - 1; i >= 0; i--) {  
                final ResolveInfo ri = newReceivers.get(i);  
                final Resolution<ResolveInfo> resolution =  
                        mComponentAliasResolver.resolveReceiver(intent, ri, resolvedType,  
                                pmFlags, user, callingUid, true /* forSend */);  
                if (resolution == null) {  
                    // 未找到对应的接收器，删除这个记录 
                    newReceivers.remove(i);  
                    continue;  
                }  
                if (resolution.isAlias()) {  
	                //找到对应的真实的接收器，就把别名的记录替换成真实的目标
                    newReceivers.set(i, resolution.getTarget());  
                }  
            }  
        }  
        if (newReceivers != null && newReceivers.size() == 0) {  
            newReceivers = null;  
        }  
  
        if (receivers == null) {  
            receivers = newReceivers;  
        } else if (newReceivers != null) {  
            if (!scannedFirstReceivers) {  
	            //查找单用户记录的接收器，并且保存
                scannedFirstReceivers = true;  
                for (int i = 0; i < receivers.size(); i++) {  
                    ResolveInfo ri = receivers.get(i);  
                    if ((ri.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) {  
                        ComponentName cn = new ComponentName(  
                                ri.activityInfo.packageName, ri.activityInfo.name);  
                        if (singleUserReceivers == null) {  
                            singleUserReceivers = new HashSet<ComponentName>();  
                        }  
                        singleUserReceivers.add(cn);  
                    }  
                }  
            }  
            for (int i = 0; i < newReceivers.size(); i++) {  
                ResolveInfo ri = newReceivers.get(i);  
                if ((ri.activityInfo.flags & ActivityInfo.FLAG_SINGLE_USER) != 0) {  
                    ComponentName cn = new ComponentName(  
                            ri.activityInfo.packageName, ri.activityInfo.name);  
                    if (singleUserReceivers == null) {  
                        singleUserReceivers = new HashSet<ComponentName>();  
                    }  
                    if (!singleUserReceivers.contains(cn)) {  
	                    //对于单用户的接收器，只存一次到返回结果中
                        singleUserReceivers.add(cn);  
                        receivers.add(ri);  
                    }  
                } else {  
                    receivers.add(ri);  
                }  
            }  
        }  
    }
    ...
    return receivers;  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

protected final List<R> queryIntent(@NonNull PackageDataSnapshot snapshot, Intent intent,  
        String resolvedType, boolean defaultOnly, @UserIdInt int userId, long customFlags) {  
    ArrayList<R> finalList = new ArrayList<R>();  
    F[] firstTypeCut = null;  
    F[] secondTypeCut = null;  
    F[] thirdTypeCut = null;  
    F[] schemeCut = null;  
  
    if (resolvedType == null && scheme == null && intent.getAction() != null) {  
        firstTypeCut = mActionToFilter.get(intent.getAction());  
    }  
  
    FastImmutableArraySet<String> categories = getFastIntentCategories(intent);  
    Computer computer = (Computer) snapshot;  
    if (firstTypeCut != null) {  
        buildResolveList(computer, intent, categories, debug, defaultOnly, resolvedType,  
                scheme, firstTypeCut, finalList, userId, customFlags);  
    }  
    sortResults(finalList);  //按照IntentFilter的priority优先级降序排序
    return finalList;  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

int NR = registeredReceivers != null ? registeredReceivers.size() : 0;  
if (!ordered && NR > 0) {  
    ...
    final BroadcastQueue queue = broadcastQueueForIntent(intent);  
    BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp, callerPackage,  
            callerFeatureId, callingPid, callingUid, callerInstantApp, resolvedType,  
            requiredPermissions, excludedPermissions, excludedPackages, appOp, brOptions,  
            registeredReceivers, resultTo, resultCode, resultData, resultExtras, ordered,  
            sticky, false, userId, allowBackgroundActivityStarts,  
            backgroundActivityStartsToken, timeoutExempt);  
    ...
    final boolean replaced = replacePending  
            && (queue.replaceParallelBroadcastLocked(r) != null);  
    if (!replaced) {  
        queue.enqueueParallelBroadcastLocked(r);  
        queue.scheduleBroadcastsLocked();  
    }  
    registeredReceivers = null;  
    NR = 0;  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

int ir = 0;  
if (receivers != null) {  
    String skipPackages[] = null;  
    //对于添加应用，删除应用数据之类的广播，不希望变化的应用能够接收到对应的广播
    //这里设置忽略它们
    if (Intent.ACTION_PACKAGE_ADDED.equals(intent.getAction())  
            || Intent.ACTION_PACKAGE_RESTARTED.equals(intent.getAction())  
            || Intent.ACTION_PACKAGE_DATA_CLEARED.equals(intent.getAction())) {  
        Uri data = intent.getData();  
        if (data != null) {  
            String pkgName = data.getSchemeSpecificPart();  
            if (pkgName != null) {  
                skipPackages = new String[] { pkgName };  
            }  
        }  
    } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(intent.getAction())) {  
        skipPackages = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);  
    }  
    if (skipPackages != null && (skipPackages.length > 0)) {  
	    //如果Manifest注册的广播接收器的包名和skip的一样，那就移除它们
        for (String skipPackage : skipPackages) {  
            if (skipPackage != null) {  
                int NT = receivers.size();  
                for (int it=0; it<NT; it++) {  
                    ResolveInfo curt = (ResolveInfo)receivers.get(it);  
                    if (curt.activityInfo.packageName.equals(skipPackage)) {  
                        receivers.remove(it);  
                        it--;  
                        NT--;  
                    }  
                }  
            }  
        }  
    }  
  
    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) {  
            //如果动态注册的广播优先级比静态注册的等级高，就把它添加到静态注册的前面。
            receivers.add(it, curr);  
            ir++;  
            curr = null;  
            it++;  
            NT++;  
        } else {  
            // 如果动态注册的广播优先级没有静态注册的等级高，那就移动静态注册的游标，下一轮在执行相关的判断。
            it++;  
            curt = null;  
        }  
    }  
}
while (ir < NR) {  //如果registeredReceivers中的元素没有全部放到receivers里面，就一个一个的遍历并放进去。
    if (receivers == null) {  
        receivers = new ArrayList();  
    }  
    receivers.add(registeredReceivers.get(ir));  
    ir++;  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

if ((receivers != null && receivers.size() > 0)  
        || resultTo != null) {  
    BroadcastQueue queue = broadcastQueueForIntent(intent);  
    BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp, callerPackage,  
            callerFeatureId, callingPid, callingUid, callerInstantApp, resolvedType,  
            requiredPermissions, excludedPermissions, excludedPackages, appOp, brOptions,  
            receivers, resultTo, resultCode, resultData, resultExtras,  
            ordered, sticky, false, userId, allowBackgroundActivityStarts,  
            backgroundActivityStartsToken, timeoutExempt);  
  
    final BroadcastRecord oldRecord =  
            replacePending ? queue.replaceOrderedBroadcastLocked(r) : null;  
    if (oldRecord != null) {  
        if (oldRecord.resultTo != null) {  
            final BroadcastQueue oldQueue = broadcastQueueForIntent(oldRecord.intent);  
            try {  
                oldRecord.mIsReceiverAppRunning = true;  
                oldQueue.performReceiveLocked(oldRecord.callerApp, oldRecord.resultTo,  
                        oldRecord.intent,  
                        Activity.RESULT_CANCELED, null, null,  
                        false, false, oldRecord.userId, oldRecord.callingUid, callingUid,  
                        SystemClock.uptimeMillis() - oldRecord.enqueueTime, 0);  
            } catch (RemoteException e) {  
  
            }  
        }  
    } else {  
        queue.enqueueOrderedBroadcastLocked(r);  
        queue.scheduleBroadcastsLocked();  
    }  
}else {
	//对于无人关心的广播，也做一下记录
	if (intent.getComponent() == null && intent.getPackage() == null  
        && (intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) { 
	    addBroadcastStatLocked(intent.getAction(), callerPackage, 0, 0, 0);  
	}
}

1
2
3
4
5
6
7

public void enqueueParallelBroadcastLocked(BroadcastRecord r) {  
    r.enqueueClockTime = System.currentTimeMillis();  
    r.enqueueTime = SystemClock.uptimeMillis();  
    r.enqueueRealTime = SystemClock.elapsedRealtime();  
    mParallelBroadcasts.add(r);  
    enqueueBroadcastHelper(r);  
}

1
2
3
4
5
6
7

public void enqueueOrderedBroadcastLocked(BroadcastRecord r) {  
    r.enqueueClockTime = System.currentTimeMillis();  
    r.enqueueTime = SystemClock.uptimeMillis();  
    r.enqueueRealTime = SystemClock.elapsedRealtime();  
    mDispatcher.enqueueOrderedBroadcastLocked(r);  
    enqueueBroadcastHelper(r);  
}

1
2
3
4
5
6
7

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

1
2
3
4
5

private void processNextBroadcast(boolean fromMsg) {  
    synchronized (mService) {  
        processNextBroadcastLocked(fromMsg, false);  
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

if (fromMsg) {  
    mBroadcastsScheduled = false;  //通过handleMessage过来，把flag设置为false
}
while (mParallelBroadcasts.size() > 0) {  
    r = mParallelBroadcasts.remove(0);  
    r.dispatchTime = SystemClock.uptimeMillis();  
    r.dispatchRealTime = SystemClock.elapsedRealtime();  
    r.dispatchClockTime = System.currentTimeMillis();  
    r.mIsReceiverAppRunning = true;  
    final int N = r.receivers.size();  
    
    for (int i=0; i<N; i++) {  
        Object target = r.receivers.get(i);  
        
        deliverToRegisteredReceiverLocked(r,  
                (BroadcastFilter) target, false, i);  //分发
    }  
    addBroadcastToHistoryLocked(r);  //把广播添加的历史记录中
}


这里就是遍历`ParallelBroadcasts`中的每一条`BroadcastRecord`，其中会再分别遍历每一个`BroadcastFilter`，调用`deliverToRegisteredReceiverLocked`来分发广播。
```java
private void deliverToRegisteredReceiverLocked(BroadcastRecord r,  
        BroadcastFilter filter, boolean ordered, int index) {  
    boolean skip = false;  
    ...

    if (filter.requiredPermission != null) {  
        int perm = mService.checkComponentPermission(filter.requiredPermission,  
                r.callingPid, r.callingUid, -1, true);  
        if (perm != PackageManager.PERMISSION_GRANTED) {  
            skip = true;  
        } else {  
            final int opCode = AppOpsManager.permissionToOpCode(filter.requiredPermission);  
            if (opCode != AppOpsManager.OP_NONE  
                    && mService.getAppOpsManager().noteOpNoThrow(opCode, r.callingUid,  
                    r.callerPackage, r.callerFeatureId, "Broadcast sent to protected receiver")  
                    != AppOpsManager.MODE_ALLOWED) {  
                skip = true;  
            }  
        }  
    }  
    ...
    if (skip) {  
        r.delivery[index] = BroadcastRecord.DELIVERY_SKIPPED;  
        return;  
    }  
    
    r.delivery[index] = BroadcastRecord.DELIVERY_DELIVERED;  
    ...
    try {  
        
        if (filter.receiverList.app != null && filter.receiverList.app.isInFullBackup()) {  
            if (ordered) {  
                skipReceiverLocked(r);  
            }  
        } else {  
            r.receiverTime = SystemClock.uptimeMillis();  
            maybeAddAllowBackgroundActivityStartsToken(filter.receiverList.app, r);  
            maybeScheduleTempAllowlistLocked(filter.owningUid, r, r.options);  
            maybeReportBroadcastDispatchedEventLocked(r, filter.owningUid);  
            performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,  
                    new Intent(r.intent), r.resultCode, r.resultData,  
                    r.resultExtras, r.ordered, r.initialSticky, r.userId,  
                    filter.receiverList.uid, r.callingUid,  
                    r.dispatchTime - r.enqueueTime,  
                    r.receiverTime - r.dispatchTime);  
            if (filter.receiverList.app != null  
                    && r.allowBackgroundActivityStarts && !r.ordered) {  
                postActivityStartTokenRemoval(filter.receiverList.app, r);  
            }  
        }  
        if (ordered) {  
            r.state = BroadcastRecord.CALL_DONE_RECEIVE;  
        }  
    } catch (RemoteException e) {  
        ...
        if (ordered) {  
            r.receiver = null;  
            r.curFilter = null;  
            filter.receiverList.curBroadcast = null;  
        }  
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,  
        Intent intent, int resultCode, String data, Bundle extras,  
        boolean ordered, boolean sticky, int sendingUser,  
        int receiverUid, int callingUid, long dispatchDelay,  
        long receiveDelay) throws RemoteException {  
    if (app != null) {  
        final IApplicationThread thread = app.getThread();  
        if (thread != null) {  
            try {  
                thread.scheduleRegisteredReceiver(receiver, intent, resultCode,  
                        data, extras, ordered, sticky, sendingUser,  
                        app.mState.getReportedProcState());  
            } catch (RemoteException ex) {  
                ...
                throw ex;  
            }  
        } else {  
            ...
            throw new RemoteException("app.thread must not be null");  
        }  
    } else {  
        receiver.performReceive(intent, resultCode, data, extras, ordered,  
                sticky, sendingUser);  
    }  
    ...
}