ActivityManagerService广播怎么注册与发送

今天小编给大家分享一下ActivityManagerService广播怎么注册与发送的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。

注册广播接收器

广播接收器可以分为动态和静态，静态广播接收器就是在 AndroidManifest.xml 中注册的，而动态的广播接收器是在代码中通过 Context#reGISterReceiver() 注册的。

静态广播接收器，在发送广播时，服务端会从 PKMS 中收集，而动态的广播接收器，需要接收方发送给服务端。因此，下面只分析动态广播接收器的注册过程

// ContextImpl.javapublic Intent registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user,        IntentFilter filter, String broadcastPermission, Handler scheduler) {    return registerReceiverInternal(receiver, user.getIdentifier(),            filter, broadcastPermission, scheduler, getOuterContext(), 0);}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) {            // 默认主线程 Handler            if (scheduler == null) {                scheduler = mMainThread.getHandler();            }            // 1. 获取 IIntentReceiver 对象            // 其实这里获取的就是一个 Binder 对象，用于注册给 AMS，从而接收广播信息的回调            rd = mPackageInfo.getReceiverDispatcher(                receiver, context, scheduler,                mMainThread.getInstrumentation(), true);        } else {            // ...        }    }    try {        // 2. 向 AMS 注册 IIntentReceiver        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) {        throw e.rethrowFromSystemServer();    }}

广播接收方注册接收器的过程如下

• 获取 IIntentReceiver 对象，它是一个 Binder 对象，其实就是一个 Binder 回调。

• 向服务端 AMS 注册 IIntentReceiver 对象，用于接收广播消息的回调。

当接收方收到来自服务端的广播消息后，会通过 IIntentReceiver 对象，调用 BroadcastReceiver#onReceive() 来处理广播。

现在来看下服务端是如何完成广播接收器的注册工作的

// AcitityManagerService.javapublic Intent registerReceiverWithFeature(IApplicationThread caller, String callerPackage,        String callerFeatureId, String receiverId, IIntentReceiver receiver,        IntentFilter filter, String permission, int userId, int flags) {    enforceNotIsolatedCaller("registerReceiver");    ArrayList<Intent> stickyIntents = null;    ProcessRecord callerApp = null;    final boolean visibleToInstantApps            = (flags & Context.RECEIVER_VISIBLE_TO_INSTANT_APPS) != 0;    int callingUid;    int callingPid;    boolean instantApp;    synchronized(this) {        // 确保接收方进程存在，并该进程的 uid 和 pid        if (caller != null) {            callerApp = getRecordForAppLOSP(caller);            if (callerApp == null) {                throw new SecurityException(                        "Unable to find app for caller " + caller                        + " (pid=" + Binder.getCallingPid()                        + ") when registering receiver " + receiver);            }            if (callerApp.info.uid != SYSTEM_UID                    && !callerApp.getPkgList().containsKey(callerPackage)                    && !"android".equals(callerPackage)) {                throw new SecurityException("Given caller package " + callerPackage                        + " is not running in process " + callerApp);            }            callingUid = callerApp.info.uid;            callingPid = callerApp.getPid();        } else {            callerPackage = null;            callingUid = Binder.getCallingUid();            callingPid = Binder.getCallingPid();        }        instantApp = isInstantApp(callerApp, callerPackage, callingUid);        userId = mUserController.handleIncomingUser(callingPid, callingUid, userId, true,                ALLOW_FULL_ONLY, "registerReceiver", callerPackage);        Iterator<String> actions = filter.actionsIterator();        if (actions == null) {            ArrayList<String> noAction = new ArrayList<String>(1);            noAction.add(null);            actions = noAction.iterator();        }        // Collect stickies of users        int[] userIds = { UserHandle.USER_ALL, UserHandle.getUserId(callingUid) };        // 遍历 IntentFilter 保存的所有 action，匹配相应的 sticky 广播，并保存到 stickyIntents        // 从这里可以看出，可以先发送 sticky 广播，然后再注册 sticky 广播接收器        while (actions.hasNext()) {            String action = actions.next();            for (int id : userIds) {                ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(id);                if (stickies != null) {                    ArrayList<Intent> intents = stickies.get(action);                    if (intents != null) {                        if (stickyIntents == null) {                            stickyIntents = new ArrayList<Intent>();                        }                        stickyIntents.addAll(intents);                    }                }            }        }    }    // 刚才是用 action 匹配 sticky 广播，现在使用 IntentFilter 再次过滤    // 过滤后的 sticky 广播 ，保存到 allSticky    // 因此 allSticky 保存的才是最终完美匹配到的 sticky 广播    ArrayList<Intent> allSticky = null;    if (stickyIntents != null) {        final ContentResolver resolver = mContext.getContentResolver();        // Look for any matching sticky broadcasts...        for (int i = 0, N = stickyIntents.size(); i < N; i++) {            Intent intent = stickyIntents.get(i);            // Don't provided intents that aren't available to instant apps.            if (instantApp &&                    (intent.getFlags() & Intent.FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS) == 0) {                continue;            }            // If intent has scheme "content", it will need to acccess            // provider that needs to lock mProviderMap in ActivityThread            // and also it may need to wait application response, so we            // cannot lock ActivityManagerService here.            if (filter.match(resolver, intent, true, TAG) >= 0) {                if (allSticky == null) {                    allSticky = new ArrayList<Intent>();                }                allSticky.add(intent);            }        }    }    // The first sticky in the list is returned directly back to the client.    // 从这里可以看出，如果注册的广播接收器为 null，那么表示要获取最近一次 sticky 广播的数据    Intent sticky = allSticky != null ? allSticky.get(0) : null;    if (receiver == null) {        return sticky;    }    // ...    synchronized (this) {        IApplicationThread thread;        // 注意学会这里的操作，如何判断原来的进程已经死亡        if (callerApp != null && ((thread = callerApp.getThread()) == null                || thread.asBinder() != caller.asBinder())) {            // Original caller already died            return null;        }        // 1. mRegisteredReceivers 建立客户端与服务端的广播接收器的映射        // 客户端注册的广播接收器是 IIntentReceiver， 而服务端的是 ReceiverList        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);                }                // ProcessRecord#mReceivers 保存 ReceiverList                rl.app.mReceivers.addReceiver(rl);            } else {                // ...            }            mRegisteredReceivers.put(receiver.asBinder(), rl);        } else {            // ...        }        // 2. 创建服务端的广播过滤器 BroadcastFilter，并保存到 mReceiverResolver        BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage, callerFeatureId,                receiverId, permission, callingUid, userId, instantApp, visibleToInstantApps);        if (rl.containsFilter(filter)) {            Slog.w(TAG, "Receiver with filter " + filter                    + " already registered for pid " + rl.pid                    + ", callerPackage is " + callerPackage);        } else {            // ReceiverList 是 ArrayList 子类，之所以用一个列表保存 BroadcastFilter            // 是因为在注册广播接收器时，可以为同一个广播接收器匹配多个过滤器            rl.add(bf);            if (!bf.debuGCheck()) {                Slog.w(TAG, "==> For Dynamic broadcast");            }            // 解析过滤器的数据，然后用相应的数据结构保存            mReceiverResolver.addFilter(bf);        }        // Enqueue broadcasts for all existing stickies that match        // this filter.        // 注意，这里处理的情况是，注册的 sticky 广播接收器不为 null        // 那么把匹配到的 sticky 广播，发送给这个广播接收器        // 是不是非常有意思，注册 sticky 广播接收器，就能立即收到广播，这得益于 sticky 广播被缓存        if (allSticky != null) {            // 很奇怪，BroadcastFilter 怎么是广播接收器呢?            ArrayList receivers = new ArrayList();            receivers.add(bf);            final int stickyCount = allSticky.size();            for (int i = 0; i < stickyCount; i++) {                Intent intent = allSticky.get(i);                BroadcastQueue queue = broadcastQueueForIntent(intent);                BroadcastRecord r = new BroadcastRecord(queue, intent, null,                        null, null, -1, -1, false, null, null, null, OP_NONE, null, receivers,                        null, 0, null, null, false, true, true, -1, false, null,                        false );                queue.enqueueParallelBroadcastLocked(r);                queue.scheduleBroadcastsLocked();            }        }        return sticky;    }}

服务端对于动态注册的广播接收器的处理过程如下

• 使用 mRegisteredReceivers 建立客户端与服务端的广播接收器的映射。ReceiverList 代表服务端的广播接收器，IIntentReceiver 代表客户端的广播接收器。

• 使用客户端的 IntentFilter ， 创建服务端的广播过滤器 BroadcastFilter，并保存到 mReceiverResolver。注意，这一步中，ReceiverList 和 BroadcastFilter 互相保存了引用。

这些数据结构都是相互关联的，有何种用意呢？当发送方发送广播到 AMS，AMS 会使用 mReceiverResolver 匹配 BroadcastFilter，BroadcastFilter 找到 ReceiverList，ReceiverList 找到 IIntentReceiver，IIntentReceiver 发送广播给接收方。

另外，由于 sticky 广播是会被缓存的，当注册 sticky 广播的接收器时，有以下两种处理方式

• 如果注册的广播接收器为 null，那么会返回最近的一次广播数据给接收方。

• 如果注册的广播接收器不为null，那么会把匹配到的 sticky 广播发送给接收方的广播接收器，也就是会调用 BroadcastReceiver#onReceive()。

发送广播

发送广播的方法，有多个重载方法，挑选一个最简单的来分析，如下

// ContextImpl.javapublic 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 ,                null, AppOpsManager.OP_NONE, null, false, false, getUserId());    } catch (RemoteException e) {        throw e.rethrowFromSystemServer();    }}

// ActivityManagerService.javapublic 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);        }    }}final int broadcastIntentLocked(ProcessRecord callerApp,        String callerPackage, String callerFeatureId, Intent intent, String resolvedType,        IIntentReceiver resultTo, int resultCode, String resultData,        Bundle resultExtras, String[] requiredPermissions, String[] excludedPermissions,        String[] excludedPackages, int appOp, Bundle bOptions, boolean ordered,        boolean sticky, int callingPid,        int callingUid, int realCallingUid, int realCallingPid, int userId) {    return broadcastIntentLocked(callerApp, callerPackage, callerFeatureId, intent,            resolvedType, resultTo, resultCode, resultData, resultExtras, requiredPermissions,            excludedPermissions, excludedPackages, appOp, bOptions, ordered, sticky, callingPid,            callingUid, realCallingUid, realCallingPid, userId,            false ,            null , null );}final int broadcastIntentLocked(ProcessRecord callerApp, String callerPackage,        @Nullable String callerFeatureId, Intent intent, String resolvedType,        IIntentReceiver resultTo, int resultCode, String resultData,        Bundle resultExtras, String[] requiredPermissions,        String[] excludedPermissions, String[] excludedPackages, int appOp, Bundle bOptions,        boolean ordered, boolean sticky, int callingPid, int callingUid,        int realCallingUid, int realCallingPid, int userId,        boolean allowBackgroundActivityStarts,        @Nullable IBinder backgroundActivityStartsToken,        @Nullable int[] broadcastAllowList) {    // 克隆一个 Intent，防止原始 intent 数据被修改    intent = new Intent(intent);    // ...    // If we have not finished booting, don't allow this to launch new processes.    // AMS 还没有启动完成前，广播只能发送给动态注册的广播接收器，这样可以防止拉起新的进程    if (!mProcessesReady && (intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) == 0) {        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);    }    // ...    final String action = intent.getAction();    BroadcastOptions brOptions = null;    // bOptions 可以解决发送广播的一些限制，例如从后台启动Activity，只有系统 app 才能用到的 api    if (bOptions != null) {        // ...    }    // 限制受保护的广播，只能由系统代码发送    final boolean isProtectedBroadcast;    try {        isProtectedBroadcast = AppGlobals.getPackageManager().isProtectedBroadcast(action);    } catch (RemoteException e) {        Slog.w(TAG, "Remote exception", e);        return ActivityManager.BROADCAST_SUCCESS;    }    final boolean isCallerSystem;    switch (UserHandle.getAppId(callingUid)) {        case ROOT_UID:        case SYSTEM_UID:        case PHONE_UID:        case BLUETOOTH_UID:        case NFC_UID:        case SE_UID:        case NETWORK_STACK_UID:            isCallerSystem = true;            break;        default:            isCallerSystem = (callerApp != null) && callerApp.isPersistent();            break;    }    if (!isCallerSystem) {        if (isProtectedBroadcast) {            String msg = "Permission Denial: not allowed to send broadcast "                    + action + " from pid="                    + callingPid + ", uid=" + callingUid;            Slog.w(TAG, msg);            throw new SecurityException(msg);        } else if (AppWidgetManager.ACTION_APPWIDGET_CONFIGURE.equals(action)                || AppWidgetManager.ACTION_APPWIDGET_UPDATE.equals(action)) {            // ...        }    }    boolean timeoutExempt = false;    if (action != null) {        // 如果系统配置文件中允许发送这个后台广播，那么添加 Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND 标志位        // 例如 frameworks/base/data/etc/framework-sysconfig.xml 允许发送如下后台广播        // <allow-implicit-broadcast action="android.intent.action.SIM_STATE_CHANGED" />        if (getBackgroundLaunchBroadcasts().contains(action)) {            if (DEBUG_BACKGROUND_CHECK) {                Slog.i(TAG, "Broadcast action " + action + " forcing include-background");            }            intent.addFlags(Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND);        }        switch (action) {            // 对一些特殊的广播进行处理...        }    }    // 1. 缓存 sticky 广播到 mStickyBroadcasts    if (sticky) {        // 检查权限        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");        }        // 确保使用 userId 发送的 sticky 广播，不会与使用 USER_ALL 发送的 sticky 广播有冲突        if (userId != UserHandle.USER_ALL) {            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");                        }                    }                }            }        }        // 获取 userId 对应的 sticky 广播缓存，并把这个stikcy广播添加/替换到缓存中        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 sticky already exists, replace it.                list.set(i, new Intent(intent));                break;            }        }        // 不存在就添加        if (i >= stickiesCount) {            list.add(new Intent(intent));        }    }    int[] users;    if (userId == UserHandle.USER_ALL) {        // 如果以 USER_ALL 名字发送，那么获取所有的启动的 user        users = mUserController.getStartedUserArray();    } else {        users = new int[] {userId};    }    // Figure out who all will receive this broadcast.    // 现在开始找出谁需要接收这个广播    List receivers = null;    List<BroadcastFilter> registeredReceivers = null;    // 2. 收集动态和静态广播接收器    // Intent.FLAG_RECEIVER_REGISTERED_ONLY 表示广播只能发送给动态注册的广播接收器    // 没有指定这个标志位，那么就需要收集静态注册的广播接收器    if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY)             == 0) {        // receivers 此时保存的是静态广播接收器        receivers = collectReceiverComponents(                intent, resolvedType, callingUid, users, broadcastAllowList);    }    if (intent.getComponent() == null) {        if (userId == UserHandle.USER_ALL && callingUid == shell_UID) {            // ...以 USER_ALL 身份，从 shell 发送的广播，那么需要获取所有用户注册的广播接收器        } else {            // 收集单个用户注册的动态广播接收器            registeredReceivers = mReceiverResolver.queryIntent(intent,                    resolvedType, false , userId);        }    }    // 是否替换即将发送的广播    final boolean replacePending =            (intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;    if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Enqueueing broadcast: " + intent.getAction()            + " replacePending=" + replacePending);    // broadcastAllowList 是能接收广播 app 白名单    // 如果收集的动态注册的广播接收器，不属于白名单中的 app，那么移除它    if (registeredReceivers != null && broadcastAllowList != null) {        for (int i = registeredReceivers.size() - 1; i >= 0; i--) {            final int owningAppId = UserHandle.getAppId(registeredReceivers.get(i).owningUid);            if (owningAppId >= Process.FIRST_APPLICATION_UID                    && Arrays.binarySearch(broadcastAllowList, owningAppId) < 0) {                registeredReceivers.remove(i);            }        }    }    // 3. 对于非有序广播(包括sticky广播)，先"并行"地发送给动态广播接收器    int NR = registeredReceivers != null ? registeredReceivers.size() : 0;    if (!ordered && NR > 0) {        if (isCallerSystem) {            checkBroadcastFromSystem(intent, callerApp, callerPackage, callingUid,                    isProtectedBroadcast, registeredReceivers);        }        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);        if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Enqueueing parallel broadcast " + r);        final boolean replaced = replacePending                && (queue.replaceParallelBroadcastLocked(r) != null);        // Note: We assume resultTo is null for non-ordered broadcasts.        if (!replaced) {            queue.enqueueParallelBroadcastLocked(r);            queue.scheduleBroadcastsLocked();        }        registeredReceivers = null;        // 注意，对于发送非有序广播，当把广播发送给动态接收器后， NR 重置为 0        NR = 0;    }    // 4. 对于有序广播，按照优先级从高到低的顺序，合并静态和动态广播接收器到 receivers    int ir = 0;    // receivers 收集的是静态注册的广播接收器    if (receivers != null) {        // ...        // NT 表示静态广播接收器的数量        int NT = receivers != null ? receivers.size() : 0;        int it = 0;        ResolveInfo curt = null;        BroadcastFilter curr = null;        // 注意 NR 的值，前面发送非有序广播给动态接收器时，NR 重置为 0        // 如果此时 NR 还不为 0， 那么表示发送的是有序广播        // 那么根据广播的优先级，按照从高到低的顺序，把动态广播接收器和静态广播接收器，合并到 receivers        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++;    }    if (isCallerSystem) {        checkBroadcastFromSystem(intent, callerApp, callerPackage, callingUid,                isProtectedBroadcast, receivers);    }    // 5. “序列化”地发送广播    // 注意，这里分两种情况    // 如果发送的非有序广播，那么 receivers 只保存了静态注册的广播接收器    // 如果发送的是有序广播，那么 receivers 保存了静态和动态注册的广播接收器    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) {            // 处理替换广播的情况 ....        } else {            queue.enqueueOrderedBroadcastLocked(r);            queue.scheduleBroadcastsLocked();        }    } else {        // 没有找到接收广播的接收器，简单记录下这个发送广播的操作 ...    }    return ActivityManager.BROADCAST_SUCCESS;}

这段代码设计的并不是很好，很多细节都杂糅到一个方法中。对于一些细节，我进行了详细的注释，有兴趣的读者可以自行研究，而本文只关心发送广播的主要流程。

我不打算按照代码的逻辑来讲解流程，我自己总结了一套流程。

对于非有序广播(包括 sticky 广播)，发送流程如下

• 把广播“并行”地发送给动态广播接收器。

• 把广播“串行”地发送给静态广播接收器。

为何要把非有序广播(包括 sticky 广播)优先发送给动态接收器？最简单的理由就是，不需要先拉起进程！因为"快”，所以先发送。

对于有序广播，发送的流程如下

• 按照广播的优先级，从高到低，把动态和静态广播接收器，合并到一起。

• “串行”发送广播给所有的接收器。

有序广播，为何不先发送给动态接收器呢？因为它强调一个“有序”，所以要根据优先级来发送。

对于 sticky 广播，由于它的特性，是需要对它的广播 Intent 进行缓存的。根据前面注册广播接收器的分析，当注册的广播接收器匹配到缓存的 sticky 广播 Intent，那么会立即返回数据给接收方，无论是通过函数的返回值，还是直接调用 BroadcastReceiver#onReceive()。

以上就是“ActivityManagerService广播怎么注册与发送”这篇文章的所有内容，感谢各位的阅读！相信大家阅读完这篇文章都有很大的收获，小编每天都会为大家更新不同的知识，如果还想学习更多的知识，请关注编程网精选频道。