说说Android的广播

对于Activity的启动流程，我们已经有了几个版本的分析了。这里我们分析一个更容易一些的，四大组件中最简单的Broadcast Receiver。

关于Broadcast，有几点需要了解。首先是广播的类型，然后是广播的发送方法，最后是广播是如何被接收的。这三者相辅相承的，比如普通广播和有序广播只有在详细了解了广播的接收过程了之后，才能真正明白它的含义。

广播的类型：普通广播,有序广播和粘性广播

普通的广播是不在意顺序的，最简单的理解是同时可以收到这个广播。如果应用是动态注册这个广播的，且广播发送时这个进程还活着，那么当然可以并发的把广播尽快地传送出去是最好的。
但是，如果是通过AndroidManifest.xml静态注册的情况，也就是说这个广播首先要把一个进程启动起来，这时并发启动很多进程就是个问题了。Android目前的做法是，对这种静态的广播接收者，自动按有序广播的方式来串行处理。但是这对应用是透明的，应用不能假设系统已经把静态的无序广播当成有序广播来处理。

这个时候讲粘性广播有福了，因为从Android 5.0(API 21)开始，因为安全性的问题，官方已经正式废弃了粘性广播。

普通广播的发送

Context类提供两个方法可以用于发送普通广播：

• sendBroadcast(Intent intent);
• sendBroadcast(Intent intent, String receiverPermission);

差别是第二个设置权限。

发给特定的用户：

• sendBroadcastAsUser(Intent intent, UserHandle user);
• sendBroadcastAsUser(Intent intent, UserHandle user, String receiverPermission);

有序广播的发送

有序广播因为要处理消息的处理结果，所以要复杂一些。

• sendOrderedBroadcast(Intent intent, String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, String initialData, Bundle initialExtras);

如果只是想让广播可以按优先级来收取，并不在意处理的结果，可以用下面的版本：

• sendOrderedBroadcast(Intent intent, String receiverPermission);

同样，在多用户环境下，也可以选择给哪个用户发广播：

• sendOrderedBroadcastAsUser(Intent intent, UserHandle user, String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, String initialData, Bundle initialExtras);

过时的粘性广播

不管是普通的还是有序的广播都对应有粘性的版本：

• sendStickyBroadcast(Intent intent);
• sendStickyBroadcastAsUser(Intent intent, UserHandle user);
• sendStickyOrderedBroadcast(Intent intent, BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, String initialData, Bundle initialExtras);
• sendStickyOrderedBroadcastAsUser(Intent intent, UserHandle user, BroadcastReceiver resultReceiver, Handler scheduler, int initialCode, String initialData, Bundle initialExtras);

以上的API都是定义于Context类中：https://developer.android.com/reference/android/content/Context.html

首先我们先看看发送端是如何发送的。
我们首先先放一个大图，让大家先有一个直观的印象，不管普通广播、有序广播、粘性广播如何组合，最终都汇集到一个大方法中。

Android_broadcast

graph TD;
    Context_sendbroadcast[Context.sendBroadcast Intent];
    Context_sendbroadcast_asUser[Context.sendBroadcastAsUser Intent,UserHandle];
    Context_sendOrderedBroadcast[Context.sendOrderedBroadcast Intent,String,BroadcastReceiver,Handler,int,String,Bundle];
    Context_sendOrderedBroadcast2[Context.sendOrderedBroadcast Intent,String];
    Context_sendStickyBroadcast[Context.sendStickyBroadcast Intent];
    Context_sendStickyBroadcast2[Context.sendStickyOrderedBroadcast Intent,BroadcastReceiver,Handler,int,String,Bundle];

    ContextWrapper_sendBroadcast[ContextWrapper.sendBroadcast Intent];

    ContextWrapper_sendOrderedBroadcast2[ContextWrapper.sendOrderedBroadcast Intent,String];
    ContextWrapper_sendOrderedBroadcast[ContextWrapper.sendOrderedBroadcast Intent,String,BroadcastReceiver,Handler,int,String,Bundle];
    ContextWrapper_sendStickyBroadcast[ContextWrapper.sendStickyBroadcast Intent];
    ContextWrapper_sendStickyBroadcast2[ContextWrapper.sendStickyOrderedBroadcast Intent,BroadcastReceiver,Handler,int,String,Bundle];
    ContextWrapper_sendbroadcast_asUser[ContextWrapper.sendBroadcastAsUser Intent,UserHandle];
    ContextImpl_sendBroadcast[ContextImpl.sendBroadcast Intent];
    ContextImpl_sendOrderedBroadcast2[ContextImpl.sendOrderedBroadcast Intent,String];
    ContextImpl_sendOrderedBroadcast[ContextImpl.sendOrderedBroadcast Intent,String,BroadcastReceiver,Handler,int,String,Bundle];
    ContextImpl_sendStickyBroadcast[ContextImpl.sendStickyBroadcast Intent];
    ContextImpl_sendStickyBroadcast2[ContextImpl.sendStickyOrderedBroadcast Intent,BroadcastReceiver,Handler,int,String,Bundle];
    ContextImpl_sendbroadcast_asUser[ContextImpl.sendBroadcastAsUser Intent,UserHandle];
    ContextImpl_sendOrderedBroadcast_all(ContextImpl.sendOrderedBroadcast Intent,String,int,BroadcastReceiver,Handler,int,String,Bundle,Bundle);

    ActivityManagerService_broadcastIntent(ActivityManagerService.broadcastIntent IApplicationThread,Intent,String,IIntentReceiver,int,String,Bundle,String,int,Bundle,boolean,boolean,int);

    Context_sendbroadcast --> ContextWrapper_sendBroadcast;
    ContextWrapper_sendBroadcast --> ContextImpl_sendBroadcast;
    ContextImpl_sendBroadcast --> ActivityManagerService_broadcastIntent;

    Context_sendbroadcast_asUser --> ContextWrapper_sendbroadcast_asUser;
    ContextWrapper_sendbroadcast_asUser --> ContextImpl_sendbroadcast_asUser;
    ContextImpl_sendbroadcast_asUser --> ActivityManagerService_broadcastIntent;

    Context_sendOrderedBroadcast2 --> ContextWrapper_sendOrderedBroadcast2;
    ContextWrapper_sendOrderedBroadcast2 --> ContextImpl_sendOrderedBroadcast2;
    ContextImpl_sendOrderedBroadcast2 --> ActivityManagerService_broadcastIntent;

    Context_sendOrderedBroadcast --> ContextWrapper_sendOrderedBroadcast;
    ContextWrapper_sendOrderedBroadcast --> ContextImpl_sendOrderedBroadcast;
    ContextImpl_sendOrderedBroadcast --> ContextImpl_sendOrderedBroadcast_all;
    ContextImpl_sendOrderedBroadcast_all --> ActivityManagerService_broadcastIntent;

    Context_sendStickyBroadcast --> ContextWrapper_sendStickyBroadcast;
    ContextWrapper_sendStickyBroadcast --> ContextImpl_sendStickyBroadcast;
    ContextImpl_sendStickyBroadcast --> ActivityManagerService_broadcastIntent;

    Context_sendStickyBroadcast2 --> ContextWrapper_sendStickyBroadcast2;
    ContextWrapper_sendStickyBroadcast2 --> ContextImpl_sendStickyBroadcast2;
    ContextImpl_sendStickyBroadcast2 --> ActivityManagerService_broadcastIntent;

应用发送广播的过程

普通广播的发送

我们先看应用发送普通广播的一个简单的例子：

Intent intent = new Intent("android.intent.action.TestAction");
intent.putExtra(EXTRA_TIME, System.currentTimeMillis());
MainActivity.this.sendBroadcast(intent);

非常简单，调用ContentWrapper的sendBroadcast方法就可以了。
然后我们顺藤摸瓜就好了。
Activity中的sendBroadcast，实际上调用的是：

void android.content.ContextWrapper.sendBroadcast(Intent intent);

ContextWrapper.sendBroadcast

我们来看frameworks/base/core/java/android/content/ContextWrapper.java中对sendBroadcast的定义：

    @Override
    public void sendBroadcast(Intent intent) {
        mBase.sendBroadcast(intent);
    }

ContextWrapper只是一个包装，真正的实现在ContextImpl中

ContextImpl.sendBroadcast

我们来看/frameworks/base/core/java/android/app/ContextImpl.java中真正实现sendBroadcast的功能：

    @Override
    public void sendBroadcast(Intent intent) {
...
        try {
...
            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);
        }
    }

它会通过IPC去调用AMS的broadcastIntent。由于我们这个普通的广播的方法参数最少，所以好多都是传null。

ActivityManagerService.broadcastIntent

public final int broadcastIntent(IApplicationThread caller,
        Intent intent, String resolvedType, IIntentReceiver resultTo,
        int resultCode, String resultData, Bundle resultExtras,
        String[] requiredPermissions, int appOp, Bundle 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();
        int res = 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);
        return res;
    }
}

加锁，定参数，然后调用真正的逻辑的实现。

有序广播的发送

我们先把broadcastIntentLocked的真正逻辑放一下，先看看有序广播是如何发送的。

ContextWrapper.sendOrderedBroadcast

Context是abstract方法，调用的是ContextWrapper的实现：

@Override
public void sendOrderedBroadcast(Intent intent,
        String receiverPermission) {
    mBase.sendOrderedBroadcast(intent, receiverPermission);
}

跟普通广播一样，还是会调用到ContextImpl.sendOrderedBroadcast

public void sendOrderedBroadcast(Intent intent, String receiverPermission) {
    warnIfCallingFromSystemProcess();
    String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());
    String[] receiverPermissions = receiverPermission == null ? null
            : new String[] {receiverPermission};
    try {
        intent.prepareToLeaveProcess();
        ActivityManagerNative.getDefault().broadcastIntent(
                mMainThread.getApplicationThread(), intent, resolvedType, null,
                Activity.RESULT_OK, null, null, receiverPermissions, AppOpsManager.OP_NONE,
                null, true, false, getUserId());
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
}

有序广播调用broadcastIntent的区别在于serialized参数，普通广播为false，有序广播为true.

原型为：

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) {

多参数的版本

前面讲过带有回调的版本，我们看看它是如何实现的：

@Override
public void sendOrderedBroadcast(
    Intent intent, String receiverPermission, BroadcastReceiver resultReceiver,
    Handler scheduler, int initialCode, String initialData,
    Bundle initialExtras) {
    mBase.sendOrderedBroadcast(intent, receiverPermission,
            resultReceiver, scheduler, initialCode,
            initialData, initialExtras);
}

当然还是调用ContextImpl.sendOrderedBroadcast

@Override
public void sendOrderedBroadcast(Intent intent,
        String receiverPermission, BroadcastReceiver resultReceiver,
        Handler scheduler, int initialCode, String initialData,
        Bundle initialExtras) {
    sendOrderedBroadcast(intent, receiverPermission, AppOpsManager.OP_NONE,
            resultReceiver, scheduler, initialCode, initialData, initialExtras, null);
}

这次变成只是一个封装了，它会调用一个更多参数的版本：

void sendOrderedBroadcast(Intent intent,
        String receiverPermission, int appOp, BroadcastReceiver resultReceiver,
        Handler scheduler, int initialCode, String initialData,
        Bundle initialExtras, Bundle options) {
    warnIfCallingFromSystemProcess();
    IIntentReceiver rd = null;
    if (resultReceiver != null) {
        if (mPackageInfo != null) {
            if (scheduler == null) {
                scheduler = mMainThread.getHandler();
            }
            rd = mPackageInfo.getReceiverDispatcher(
                resultReceiver, getOuterContext(), scheduler,
                mMainThread.getInstrumentation(), false);
        } else {
            if (scheduler == null) {
                scheduler = mMainThread.getHandler();
            }
            rd = new LoadedApk.ReceiverDispatcher(
                    resultReceiver, getOuterContext(), scheduler, null, false).getIIntentReceiver();
        }
    }
    String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());
    String[] receiverPermissions = receiverPermission == null ? null
            : new String[] {receiverPermission};
    try {
        intent.prepareToLeaveProcess();
        ActivityManagerNative.getDefault().broadcastIntent(
            mMainThread.getApplicationThread(), intent, resolvedType, rd,
            initialCode, initialData, initialExtras, receiverPermissions, appOp,
                options, true, false, getUserId());
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
}

这次是一个全参数调用broadcastIntent的版本了，除了sticky就齐了

粘性广播

我们也不绕圈子了，直接看ContextImpl.sendStickyBroadcast.

@Override
@Deprecated
public void sendStickyBroadcast(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, true,
            getUserId());
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
}