Android AOSP 6.0.1 sendBroadcast Analysis of the broadcast sending process

The broadcast registration process was analyzed in the previous section, so what steps did sendBroadcast go through?

The onStartCommand of DemoService calls sendBroadcast with a String before it is sent.

package com.demo.framework

import android.app.Service
import android.content.Intent
import android.os.IBinder
import android.util.Log

class DemoService : Service() {

    companion object {
        const val TAG = "DemoService"
    }

    override fun onBind(intent: Intent): IBinder? {
        Log.d(TAG, "onBind")
        return null
    }

    override fun onCreate(a) {
        Log.d(TAG, "onCreate")
        super.onCreate()
    }

    override fun onStartCommand(intent: Intent? , flags:Int, startId: Int): Int {
        Log.d(TAG, "onStartCommand flags=$flags,startId=$startId")
        val intent = Intent(MainActivity.ACTION)
        intent.putExtra(MainActivity.VALUE_KEY, "DemoService Hello!")
        sendBroadcast(intent)
        return super.onStartCommand(intent, flags, startId)
    }

    override fun onDestroy(a) {
        Log.d(TAG, "onDestroy")
        super.onDestroy()
    }
}
Copy the code

The sendBroadcast method comes from the ContextWrapper class and ends up calling the sendBroadcast method in the ContextImpl class.

frameworks/base/core/java/android/content/ContextWrapper.java

public class ContextWrapper extends Context {...@Override
    public void sendBroadcast(Intent intent) { mBase.sendBroadcast(intent); }... }Copy the code

The ContextImpl class takes the ActivityManagerProxy object from the sendBroadcast method and calls its broadcastIntent method. MMainThread. GetApplicationThread () returns ApplicationThread object.

frameworks/base/core/java/android/app/ContextImpl.java

class ContextImpl extends Context {...@Override
    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, null.false.false,
                    getUserId());
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e); }}... }Copy the code

The broadcastIntent method of ActivityManagerProxy ends up calling its own mRemote, a Binder proxy object, to send ActivityManagerService a message of type BROADCAST_INTENT_TRANSACTION Interprocess communication requests.

frameworks/base/core/java/android/app/ActivityManagerNative.java

class ActivityManagerProxy implements IActivityManager
{...public int broadcastIntent(IApplicationThread caller,
            Intent intent, String resolvedType, IIntentReceiver resultTo,
            int resultCode, String resultData, Bundle map,
            String[] requiredPermissions, int appOp, Bundle options, boolean serialized,
            boolean sticky, int userId) throws RemoteException
    { Parcel data = Parcel.obtain(); Parcel reply = Parcel.obtain(); data.writeInterfaceToken(IActivityManager.descriptor); data.writeStrongBinder(caller ! =null ? caller.asBinder() : null);
        intent.writeToParcel(data, 0); data.writeString(resolvedType); data.writeStrongBinder(resultTo ! =null ? resultTo.asBinder() : null);
        data.writeInt(resultCode);
        data.writeString(resultData);
        data.writeBundle(map);
        data.writeStringArray(requiredPermissions);
        data.writeInt(appOp);
        data.writeBundle(options);
        data.writeInt(serialized ? 1 : 0);
        data.writeInt(sticky ? 1 : 0);
        data.writeInt(userId);
        mRemote.transact(BROADCAST_INTENT_TRANSACTION, data, reply, 0);
        reply.readException();
        int res = reply.readInt();
        reply.recycle();
        data.recycle();
        returnres; }... }Copy the code

This function then calls the broadcastIntentLocked method.

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public final class ActivityManagerService extends ActivityManagerNative
        implements Watchdog.Monitor.BatteryStatsImpl.BatteryCallback {...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 = verifyBroadcastLocked(intent);

            final ProcessRecord callerApp = getRecordForAppLocked(caller);
            final int callingPid = Binder.getCallingPid();
            final int callingUid = Binder.getCallingUid();
            final long origId = Binder.clearCallingIdentity();
            intres = 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);
            returnres; }}... }Copy the code

The above functions prepare the necessary parameters, and the next step is to call broadcastIntentLocked.

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public final class ActivityManagerService extends ActivityManagerNative
        implements Watchdog.Monitor.BatteryStatsImpl.BatteryCallback {...private final int broadcastIntentLocked(ProcessRecord callerApp,
            String callerPackage, Intent intent, String resolvedType,
            IIntentReceiver resultTo, int resultCode, String resultData,
            Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle options,
            boolean ordered, boolean sticky, int callingPid, int callingUid, int userId) {
        intent = new Intent(intent);

        // By default, broadcasts are not forwarded to stopped applications
        intent.addFlags(Intent.FLAG_EXCLUDE_STOPPED_PACKAGES);

        // New processes cannot be allowed to start if they have not finished
        if(! mProcessesReady && (intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) ==0) {
            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
        }

        userId = handleIncomingUser(callingPid, callingUid, userId,
                true, ALLOW_NON_FULL, "broadcast", callerPackage);

        // Make sure the user receiving this broadcast is running. If not, we'll skip it.
        if(userId ! = UserHandle.USER_ALL && ! isUserRunningLocked(userId,false)) {
            if((callingUid ! = Process.SYSTEM_UID || (intent.getFlags() & Intent.FLAG_RECEIVER_BOOT_UPGRADE) ==0)
                    && !Intent.ACTION_SHUTDOWN.equals(intent.getAction())) {
                Slog.w(TAG, "Skipping broadcast of " + intent
                        + ": user " + userId + " is stopped");
                return ActivityManager.BROADCAST_FAILED_USER_STOPPED;
            }
        }

        BroadcastOptions brOptions = null;
        if(options ! =null) {
            brOptions = new BroadcastOptions(options);
            if (brOptions.getTemporaryAppWhitelistDuration() > 0) {
                // Check whether the caller is allowed to do so. Note that we are checking the actual real caller, because who actually provides the parameters.
                if (checkComponentPermission(
                        android.Manifest.permission.CHANGE_DEVICE_IDLE_TEMP_WHITELIST,
                        Binder.getCallingPid(), Binder.getCallingUid(), -1.true)
                        != PackageManager.PERMISSION_GRANTED) {
                    String msg = "Permission Denial: " + intent.getAction()
                            + " broadcast from " + callerPackage + " (pid=" + callingPid
                            + ", uid=" + callingUid + ")"
                            + " requires "
                            + android.Manifest.permission.CHANGE_DEVICE_IDLE_TEMP_WHITELIST;
                    Slog.w(TAG, msg);
                    throw newSecurityException(msg); }}}/* * Prevents non-system code (defined here as a non-persistent process) from sending protected broadcasts. * /
        int callingAppId = UserHandle.getAppId(callingUid);
        if (callingAppId == Process.SYSTEM_UID || callingAppId == Process.PHONE_UID
            || callingAppId == Process.SHELL_UID || callingAppId == Process.BLUETOOTH_UID
            || callingAppId == Process.NFC_UID || callingUid == 0) {
            // Always okay.
        } else if (callerApp == null| |! callerApp.persistent) {try {
                if (AppGlobals.getPackageManager().isProtectedBroadcast(
                        intent.getAction())) {
                    String msg = "Permission Denial: not allowed to send broadcast "
                            + intent.getAction() + " from pid="
                            + callingPid + ", uid=" + callingUid;
                    Slog.w(TAG, msg);
                    throw new SecurityException(msg);
                } else if (AppWidgetManager.ACTION_APPWIDGET_CONFIGURE.equals(intent.getAction())) {
                    // Special case of compatibility: we don't want the application to send this,
                    // But historically it has not been protected, so rather than make it protected, restrict it from the caller.
                    if (callerApp == null) {
                        String msg = "Permission Denial: not allowed to send broadcast "
                                + intent.getAction() + " from unknown caller.";
                        Slog.w(TAG, msg);
                        throw new SecurityException(msg);
                    } else if(intent.getComponent() ! =null) {
                        // They are good enough to send to explicit components... Verify that it has been sent to the calling application.
                        if(! intent.getComponent().getPackageName().equals( callerApp.info.packageName)) { String msg ="Permission Denial: not allowed to send broadcast "
                                    + intent.getAction() + " to "
                                    + intent.getComponent().getPackageName() + " from "
                                    + callerApp.info.packageName;
                            Slog.w(TAG, msg);
                            throw newSecurityException(msg); }}else {
                        // Restrict broadcasting to your own package.intent.setPackage(callerApp.info.packageName); }}}catch (RemoteException e) {
                Slog.w(TAG, "Remote exception", e);
                returnActivityManager.BROADCAST_SUCCESS; }}final String action = intent.getAction();
        if(action ! =null) {
            switch (action) {
                case Intent.ACTION_UID_REMOVED:
                case Intent.ACTION_PACKAGE_REMOVED:
                case Intent.ACTION_PACKAGE_CHANGED:
                case Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE:
                case Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE:
                    // Handle special intent: If this broadcast is a message from the package manager about deleting a package,
                    // We need to remove all activities from the history stack.
                    
                    // If the permission is not met, a SecurityException is thrown
                    if (checkComponentPermission(
                            android.Manifest.permission.BROADCAST_PACKAGE_REMOVED,
                            callingPid, callingUid, -1.true)
                            != PackageManager.PERMISSION_GRANTED) {
                        String msg = "Permission Denial: " + intent.getAction()
                                + " broadcast from " + callerPackage + " (pid=" + callingPid
                                + ", uid=" + callingUid + ")"
                                + " requires "
                                + android.Manifest.permission.BROADCAST_PACKAGE_REMOVED;
                        Slog.w(TAG, msg);
                        throw new SecurityException(msg);
                    }
                    switch (action) {
                        case Intent.ACTION_UID_REMOVED:
                            final Bundle intentExtras = intent.getExtras();
                            final intuid = intentExtras ! =null
                                    ? intentExtras.getInt(Intent.EXTRA_UID) : -1;
                            if (uid >= 0) {
                                mBatteryStatsService.removeUid(uid);
                                mAppOpsService.uidRemoved(uid);
                            }
                            break;
                        case Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE:
                            // If the resource is not available, force all these packages to stop and flush the property cache.
                            String list[] =
                                    intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
                            if(list ! =null && list.length > 0) {
                                for (int i = 0; i < list.length; i++) {
                                    forceStopPackageLocked(list[i], -1.false.true.true.false.false, userId, "storage unmount");
                                }
                                mRecentTasks.cleanupLocked(UserHandle.USER_ALL);
                                sendPackageBroadcastLocked(
                                        IApplicationThread.EXTERNAL_STORAGE_UNAVAILABLE, list,
                                        userId);
                            }
                            break;
                        case Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE:
                            mRecentTasks.cleanupLocked(UserHandle.USER_ALL);
                            break;
                        case Intent.ACTION_PACKAGE_REMOVED:
                        case Intent.ACTION_PACKAGE_CHANGED:
                            Uri data = intent.getData();
                            String ssp;
                            if(data ! =null&& (ssp=data.getSchemeSpecificPart()) ! =null) {
                                boolean removed = Intent.ACTION_PACKAGE_REMOVED.equals(action);
                                booleanfullUninstall = removed && ! intent.getBooleanExtra(Intent.EXTRA_REPLACING,false);
                                final booleankillProcess = ! intent.getBooleanExtra(Intent.EXTRA_DONT_KILL_APP,false);
                                if (killProcess) {
                                    forceStopPackageLocked(ssp, UserHandle.getAppId(
                                            intent.getIntExtra(Intent.EXTRA_UID, -1)),
                                            false.true.true.false, fullUninstall, userId,
                                            removed ? "pkg removed" : "pkg changed");
                                }
                                if (removed) {
                                    sendPackageBroadcastLocked(IApplicationThread.PACKAGE_REMOVED,
                                            new String[] {ssp}, userId);
                                    if (fullUninstall) {
                                        mAppOpsService.packageRemoved(
                                                intent.getIntExtra(Intent.EXTRA_UID, -1), ssp);

                                        // Delete all permissions granted to this package
                                        removeUriPermissionsForPackageLocked(ssp, userId, true); removeTasksByPackageNameLocked(ssp, userId); mBatteryStatsService.notePackageUninstalled(ssp); }}else{ cleanupDisabledPackageComponentsLocked(ssp, userId, killProcess, intent.getStringArrayExtra( Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST)); }}break;
                    }
                    break;
                case Intent.ACTION_PACKAGE_ADDED:
                    // Special case for adding packages: Compatibility mode is turned on by default.
                    Uri data = intent.getData();
                    String ssp;
                    if(data ! =null&& (ssp = data.getSchemeSpecificPart()) ! =null) {
                        final boolean replacing =
                                intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
                        mCompatModePackages.handlePackageAddedLocked(ssp, replacing);

                        try {
                            ApplicationInfo ai = AppGlobals.getPackageManager().
                                    getApplicationInfo(ssp, 0.0); mBatteryStatsService.notePackageInstalled(ssp, ai ! =null ? ai.versionCode : 0);
                        } catch (RemoteException e) {
                        }
                    }
                    break;
                case Intent.ACTION_TIMEZONE_CHANGED:
                    // If this is a time zone change, queue a message to reset the time zones of all currently running processes. The message will be queued before the broadcast takes place.
                    mHandler.sendEmptyMessage(UPDATE_TIME_ZONE);
                    break;
                case Intent.ACTION_TIME_CHANGED:
                    // If the user sets the time, let all running processes know.
                    final int is24Hour =
                            intent.getBooleanExtra(Intent.EXTRA_TIME_PREF_24_HOUR_FORMAT, false)?1
                                    : 0;
                    mHandler.sendMessage(mHandler.obtainMessage(UPDATE_TIME, is24Hour, 0));
                    BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics();
                    synchronized (stats) {
                        stats.noteCurrentTimeChangedLocked();
                    }
                    break;
                case Intent.ACTION_CLEAR_DNS_CACHE:
                    mHandler.sendEmptyMessage(CLEAR_DNS_CACHE_MSG);
                    break;
                case Proxy.PROXY_CHANGE_ACTION:
                    ProxyInfo proxy = intent.getParcelableExtra(Proxy.EXTRA_PROXY_INFO);
                    mHandler.sendMessage(mHandler.obtainMessage(UPDATE_HTTP_PROXY_MSG, proxy));
                    break; }}// Add to stickiness list if desired.
        if (sticky) {
            // Check the sticky broadcast permissions
            if(checkPermission(android.Manifest.permission.BROADCAST_STICKY, callingPid, callingUid) ! = PackageManager.PERMISSION_GRANTED) { String msg ="Permission Denial: broadcastIntent() requesting a sticky broadcast from pid="
                        + callingPid + ", uid=" + callingUid
                        + " requires " + android.Manifest.permission.BROADCAST_STICKY;
                Slog.w(TAG, msg);
                throw new SecurityException(msg);
            }
            if(requiredPermissions ! =null && requiredPermissions.length > 0) {
                Slog.w(TAG, "Can't broadcast sticky intent " + intent
                        + " and enforce permissions " + Arrays.toString(requiredPermissions));
                return ActivityManager.BROADCAST_STICKY_CANT_HAVE_PERMISSION;
            }
            if(intent.getComponent() ! =null) {
                throw new SecurityException(
                        "Sticky broadcasts can't target a specific component");
            }
            // We use userId directly here, because the "all" target is maintained as a separate set of sticky broadcasts.
            if(userId ! = UserHandle.USER_ALL) {// But first, if this is not a broadcast for all users, make sure it does not conflict with an existing broadcast for all users
                ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(
                        UserHandle.USER_ALL);
                if(stickies ! =null) {
                    ArrayList<Intent> list = stickies.get(intent.getAction());
                    if(list ! =null) {
                        int N = list.size();
                        int i;
                        for (i=0; i<N; i++) {
                            if (intent.filterEquals(list.get(i))) {
                                throw new IllegalArgumentException(
                                        "Sticky broadcast " + intent + " for user "
                                        + userId + " conflicts with existing global broadcast");
                            }
                        }
                    }
                }
            }
            ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(userId);
            if (stickies == null) {
                stickies = new ArrayMap<>();
                mStickyBroadcasts.put(userId, stickies);
            }
            ArrayList<Intent> list = stickies.get(intent.getAction());
            if (list == null) {
                list = new ArrayList<>();
                stickies.put(intent.getAction(), list);
            }
            final int stickiesCount = list.size();
            int i;
            for (i = 0; i < stickiesCount; i++) {
                if (intent.filterEquals(list.get(i))) {
                    // This stickiness already exists, replace it.
                    list.set(i, new Intent(intent));
                    break; }}if (i >= stickiesCount) {
                list.add(newIntent(intent)); }}int[] users;
        if (userId == UserHandle.USER_ALL) {
            // The caller wants to broadcast to all initiated users.
            users = mStartedUserArray;
        } else {
            // The caller wants to broadcast to a specific user.
            users = new int[] {userId};
        }

        // Find out who will receive this broadcast.
        List receivers = null;
        List<BroadcastFilter> registeredReceivers = null;
        // Need to resolve intent interested receiver...
        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 users restricted by shell
                UserManagerService ums = getUserManagerLocked();
                for (int i = 0; i < users.length; i++) {
                    if (ums.hasUserRestriction(
                            UserManager.DISALLOW_DEBUGGING_FEATURES, users[i])) {
                        continue;
                    }
                    List<BroadcastFilter> registeredReceiversForUser =
                            mReceiverResolver.queryIntent(intent,
                                    resolvedType, false, users[i]);
                    if (registeredReceivers == null) {
                        registeredReceivers = registeredReceiversForUser;
                    } else if(registeredReceiversForUser ! =null) { registeredReceivers.addAll(registeredReceiversForUser); }}}else {
                registeredReceivers = mReceiverResolver.queryIntent(intent,
                        resolvedType, false, userId); }}// This flag replaces the previous Intent.
        // After sending a series of intEnts,
        // Some intents can be superseded before you have a chance to handle them.
        final booleanreplacePending = (intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) ! =0;

        if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Enqueing broadcast: " + intent.getAction()
                + " replacePending=" + replacePending);
        // Handle dynamic broadcast receivers
        intNR = registeredReceivers ! =null ? registeredReceivers.size() : 0;
        if(! ordered && NR >0) {
            // If we do not serialize the broadcast, we send it separately to the registered receiver so that we do not wait for the component to be started.
            We keep two broadcast queues and their associated bookkeeping, one for foreground priority and one for normal (background priority) broadcasts.
            final BroadcastQueue queue = broadcastQueueForIntent(intent);
            // Build a BroadcastRecord object, which contains much of the BroadcastRecord information
            BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
                    callerPackage, callingPid, callingUid, resolvedType, requiredPermissions,
                    appOp, brOptions, registeredReceivers, resultTo, resultCode, resultData,
                    resultExtras, ordered, sticky, false, userId);
            if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Enqueueing parallel broadcast " + r);
            / / replaceParallelBroadcastLocked function checks whether the queue contains have the same intention BroadcastRecord, replaced here to false
            final boolean replaced = replacePending && queue.replaceParallelBroadcastLocked(r);
            if(! replaced) { queue.enqueueParallelBroadcastLocked(r); queue.scheduleBroadcastsLocked(); } registeredReceivers =null;
            NR = 0;
        }

        // Merge into a list.
        int ir = 0;
        if(receivers ! =null) {
            // Special case of PACKAGE_ADDED: Added packages are not allowed to see this broadcast.
            // This prevents them from using this as a backdoor to run immediately after installation.
            // Maybe in the future we want to provide a special setup broadcast or something like that for the application, but we want to make this decision carefully.
            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 = newString[] { 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)) {
                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--;
                            }
                        }
                    }
                }
            }

            intNT = 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; }}}while (ir < NR) {
            if (receivers == null) {
                receivers = new ArrayList();
            }
            receivers.add(registeredReceivers.get(ir));
            ir++;
        }
        // Handle static broadcast receivers
        if((receivers ! =null && receivers.size() > 0) || resultTo ! =null) {
            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);

            if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Enqueueing ordered broadcast " + r
                    + ": prev had " + queue.mOrderedBroadcasts.size());
            if (DEBUG_BROADCAST) Slog.i(TAG_BROADCAST,
                    "Enqueueing broadcast " + r.intent.getAction());

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

        returnActivityManager.BROADCAST_SUCCESS; }... }Copy the code

Receivers are the list of static BroadcastReceivers that are interested in this broadcast; CollectReceiverComponents through PackageManager static BroadcastReceiver information obtained matching with the radio;
The mReceiverResolver stores information about dynamically registered BroadcastReceiver.

Because in our code we use dynamic registration, receivers are null. The following two functions are called:

queue.enqueueParallelBroadcastLocked(r);
queue.scheduleBroadcastsLocked();
Copy the code

The first function enlists the BroadcastRecord; The second function dispatches the broadcast. Queue is a BroadcastQueue object. We keep two broadcast queues and their associated bookkeeping, one for foreground priority and one for normal (background priority) broadcasts.