AOSP思绎|从 ActivityThread.main() 出发:Activity、Service、Provider、Receiver 到底是怎么启动的?

47 阅读16分钟

点击桌面图标打开一个应用,系统可能先发现目标进程不存在,于是创建进程并进入 ActivityThread.main()。但这个 main() 不是首页 Activity 的 onCreate()。如果别的应用先请求该应用的 Service 或 ContentProvider,或者系统需要投递符合条件的清单广播,也可能由这些事件先触发目标进程启动。

这就有两个问题:

  • 谁负责把进程创建出来?
  • 进程就绪后,谁负责把这一次请求交给具体组件?

本文以「打开一个尚未运行的 MainActivity」为入门例子,再对照 Service、ContentProvider 和 BroadcastReceiver。四种入口并不要求先有 Activity;你也会看到为什么 Provider 的 onCreate() 可能早于 Application 的 onCreate()。

先给结论:共用进程入口,组件各有调度入口

先看图 1:它只回答「目标组件所在进程尚不存在时,怎样创建并绑定新进程」。随后用文字速览四类组件在进程就绪后的调度:进程创建不是组件创建;已有进程不会再走图 1 的创建路径,也不是每次调用都会重复 bindApplication。

01_进程创建与绑定.jpg

图 1:①处列出四类入口及其服务端处理模块;Activity、Service、Provider 的请求分别由对应模块处理,清单声明的 BroadcastReceiver 由 AMS 的广播队列安排投递。这里的 BroadcastQueueImpl 是此 AOSP 版本中 AMS 所用广播队列的具体实现;本图一次只取对应的一类入口,不是四个组件依次启动。①到②的箭头标注了继续向下的条件:目标进程未运行且请求获准启动;已有可用进程不走②—⑩这条冷启动路径。三个泳道分别展示 AMS/ProcessList、Zygote/USAP 和新应用进程的职责。编号是逻辑主线,Binder 派发与主线程执行不保证全局严格串行;省略异常、受限备份等特殊分支。

🔵 架构推断(非 AOSP 官方设计说明):在 2008 年初始公开提交 中,已有“创建 Application 对象 → 创建、初始化并发布 Provider → 调用 Application.onCreate()”的顺序;2012 年文档修订 又特意注明:Application.onCreate() 在 Activity、Service、Receiver 创建前调用,ContentProvider 不在这一保证内;但这些提交并未解释为什么这样排序。结合应用侧创建并发布 Provider和服务端发布时唤醒等待方,一种合理的架构推断是:先发布 Provider,可避免其发布被应用自定义且可能耗时的 Application.onCreate() 阻塞,让等待它的调用方更早拿到 Provider。这只涉及等待 Provider 发布,不保证 query() 等实际调用立即完成;Provider 自身的 onCreate() 也可能耗时。这里分析的是可观察的架构效果,不是已证实的原始设计动机。

进程就绪后,四类组件各做什么?

  • 🟦 Activity:需要新实例时,由 LaunchActivityItem 安排创建并调用 onCreate();可以复用实例时,不会仅因这次请求重建 Activity,按情况交付新 Intent。
  • 🟩 Service:首次创建实例时,应用进程收到 CREATE_SERVICE 消息,创建 Service 并调用 onCreate();已有实例则复用,不重跑 onCreate()。之后按请求类型处理:启动请求调用 onStartCommand();绑定请求按状态调用 onBind() / onRebind(),也可能复用已有绑定结果。
  • 🟨 ContentProvider:需要新实例时,应用侧创建 Provider、调用 onCreate() 并向 AMS 发布;已有实例可复用。
  • 🟪 BroadcastReceiver(清单声明):系统安排投递时,应用侧实例化接收器并调用 onReceive()。

这四种组件各有自己的调度路径,并不是一次请求要依次创建四个组件。上面只概括请求到达应用进程后的处理;Service 的绑定何时会创建实例见第四节,动态注册 Receiver 的分发方式见第六节。

是否需要走图 1 的冷启动路径,要看目标组件所在进程是否已可用,不能只看应用包名。一个应用的组件默认可以共享进程,也可以通过 android:process 分属不同进程;同一包里的某个进程已经运行,不代表另一个进程不需要启动。每个新建的应用进程分别完成绑定和 Application 初始化,也不能认为整个应用包只会调用一次 Application.onCreate()。

接下来以打开 MainActivity 为例,先看系统怎样找到或创建承载它的进程,再看进程就绪后如何调度 Activity。

一、ActivityThread.main() 从哪里来?

1. 启动 MainActivity:目标进程是否已可用?

以应用内调用 startActivity() 为例,请求通常经 Instrumentation.execStartActivity() 送往 ATMS。Instrumentation 会检查服务端返回的启动请求结果;这个结果不代表目标 Activity 已经创建。桌面启动等入口也不一定经过这段客户端代码:

// Instrumentation.execStartActivity(),节选
int result = ActivityTaskManager.getService().startActivity(whoThread,
        who.getOpPackageName(), who.getAttributionTag(), intent,
        intent.resolveTypeIfNeeded(who.getContentResolver()), token,
        target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
notifyStartActivityResult(result, options);
checkStartActivityResult(result, intent);

源码:Instrumentation.execStartActivity、ATMS.startActivityAsUser。

请求进入服务端后,ATMS 需要先确定运行 MainActivity 的目标进程是否可用。在 ActivityTaskSupervisor.startSpecificActivity() 中,如果目标进程已经附着应用线程,就继续执行 realStartActivityLocked();否则请求 startProcessAsync() 启动目标进程。

// ActivityTaskSupervisor.startSpecificActivity(),节选
final WindowProcessController wpc =
        mService.getProcessController(r.processName, r.getUid());
if (wpc != null && wpc.hasThread()) {
    try {
        realStartActivityLocked(r, wpc, andResume, checkConfig);
        return;
    } catch (RemoteException e) {
        Slog.w(TAG, "Exception when starting activity "
                + r.intent.getComponent().flattenToShortString(), e);
    }
}
// ……省略进程异常与 SDK sandbox 分支、状态记录……
mService.startProcessAsync(r, knownToBeDead, isTop,
        isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY
                : HostingRecord.HOSTING_TYPE_ACTIVITY);

源码:ActivityTaskSupervisor.startSpecificActivity。startProcessAsync() 经 ATMS 的内部进程启动入口 把进程启动请求交给 AMS。这是 system_server 内部的协作,并不是客户端再次调用 startActivity()。

在 ProcessList 中,普通应用进程的入口类被明确指定为 android.app.ActivityThread:

// ProcessList.startProcessLocked(),节选
final String entryPoint = "android.app.ActivityThread";
return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
        runtimeFlags, zygotePolicyFlags, mountExternal, seInfo, requiredAbi,
        instructionSet, invokeWith, startUptime, startElapsedTime);

源码:ProcessList:选定进程入口、ProcessList:普通路径调用 Process.start。这里传给启动流程的是进程入口类名,而不是 Activity 类名;系统还要维护进程记录和启动序号,并处理目标进程已在启动等情况。

2. Zygote 创建的是进程,不是 Activity 对象

在普通启动路径中,Process.start() 将进程入口类名和启动参数交给 Zygote。新进程随后经过 ZygoteInit.zygoteInit() 和 RuntimeInit.applicationInit(),进入该入口类的 main(String[]);Zygote 不会在创建进程时直接实例化 MainActivity。

// ZygoteInit.zygoteInit(),节选
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit();
return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges,
        enabledCompatChanges, argv, classLoader);

源码:Process.start、ZygoteProcess 向 Zygote 传递启动参数、子进程入口、RuntimeInit 查找静态 main。这里是逻辑主线:实际 fork 策略可能使用 USAP 或其他快速路径,不能断言每次都走同一条 forkAndSpecialize() 调用栈。

新进程进入 ActivityThread.main() 后,首先准备主线程,并通过 attach() 向 AMS 报到;此时还没有创建目标 Activity:

// ActivityThread.main(),节选
Looper.prepareMainLooper();

ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);

if (sMainThreadHandler == null) {
    sMainThreadHandler = thread.getHandler();
}
// ……省略日志和 Trace……
Looper.loop();

源码:ActivityThread.main。startSeq 是进程启动时传递的序号,供服务端识别本次进程附着。主线程进入 Looper.loop() 后,便在消息循环中处理后续的组件调度。

二、attachApplication 与 bindApplication:进程「报到」后做什么?

ActivityThread.attach(false, startSeq) 通过 Binder 调用 AMS:

// ActivityThread.attach(),节选
final IActivityManager mgr = ActivityManager.getService();
try {
    mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
    throw ex.rethrowFromSystemServer();
}

源码:ActivityThread.attach、AMS.attachApplication。mAppThread 是实现 IApplicationThread 的应用侧 Binder 对象;有了它,system_server 后续才能把工作安排给这个进程。

AMS 确认进程身份,并收集该进程需要创建的 Provider 等信息,然后调用应用侧的 thread.bindApplication(...)。这个 Binder 调用不会直接完成应用初始化;应用侧先把绑定数据交给主线程处理:

// ActivityThread.ApplicationThread.bindApplication(),节选
AppBindData data = new AppBindData();
// ……填充进程、应用、Provider 等绑定信息……
sendMessage(H.BIND_APPLICATION, data);

源码:AMS 收集 Provider 并 bindApplication、ActivityThread.ApplicationThread.bindApplication、主线程处理 BIND_APPLICATION。这里的 bindApplication 是系统把应用初始化信息交给新进程,不是调用 Context.bindService() 绑定 Service。

主线程处理 BIND_APPLICATION 时,handleBindApplication() 先创建 Application 对象并附着 Context,再创建、初始化并发布本进程需要的 Provider(如果有),最后调用 Application.onCreate():

// ActivityThread.handleBindApplication(),节选;省略中间初始化代码
app = data.info.makeApplicationInner(data.restrictedBackupMode, null);
// ……设置 Application 配置等……
mInitialApplication = app;
// ……
if (!data.restrictedBackupMode) {
    if (!ArrayUtils.isEmpty(data.providers)) {
        installContentProviders(app, data.providers);
    }
}
// ……
mInstrumentation.callApplicationOnCreate(app);

源码:Application 创建与 Provider 初始化顺序、Instrumentation 调用 Application.onCreate。makeApplicationInner() 会实例化/缓存 Application 并 attach Context;「创建 Application 对象」和「调用 Application.onCreate()」并非同一个时间点。如果本次绑定需要创建 Provider,它的 onCreate() 可先于 Application 的 onCreate();受限备份模式等特殊分支不适用这一常规顺序。

注意:bindApplication 负责应用初始化,不会直接创建 Activity、Service 或 Receiver;这些组件由各自的调度流程处理。服务端处理进程 attach 时也可能安排组件事务,因此图 1 的编号表示逻辑主线,不保证跨 Binder 的调度严格逐步串行。

三、Activity:启动事务如何创建目标实例

目标进程可用后,ATMS 在 realStartActivityLocked() 中创建 LaunchActivityItem,再按目标状态搭配 ResumeActivityItem 等生命周期项,将 Activity 启动事务交给该进程。这一步调度的是组件,不会再次创建应用进程。

// ActivityTaskSupervisor.realStartActivityLocked(),节选
final LaunchActivityItem launchActivityItem = new LaunchActivityItem(r.token,
        r.intent, System.identityHashCode(r), r.info,
        procConfig, overrideConfig, deviceId,
        r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
        proc.getReportedProcState(), r.getSavedState(), persistentState,
        results, newIntents, r.takeSceneTransitionInfo(), isTransitionForward,
        proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
        r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken,
        r.initialCallerInfoAccessToken, activityWindowInfo, r.getDisplayId());

// ……根据 andResume、可见性选择不同的 lifecycleItem……
final boolean isSuccessful = mService.getLifecycleManager().scheduleTransactionItems(
        proc.getThread(),
        // Immediately dispatch the transaction, so that if it fails, the server can
        // restart the process and retry now.
        true /* shouldDispatchImmediately */,
        launchActivityItem, lifecycleItem);

shouldDispatchImmediately 表示立即向客户端派发事务,不等于等待客户端同步完成 onCreate();省略的分支还可能先派发已有待处理事务。 源码:ATMS 组装 Activity 启动事务、LaunchActivityItem.execute。

客户端 IApplicationThread.scheduleTransaction() 把事务送进主线程;H.EXECUTE_TRANSACTION 执行 TransactionExecutor,LaunchActivityItem.execute() 调用 handleLaunchActivity(),最后进入 performLaunchActivity():

// ActivityThread.performLaunchActivity(),分别节选
activity = mInstrumentation.newActivity(
        cl, component.getClassName(), r.intent);
// ……创建 Context、attach Activity,取得 Application 等……
if (r.isPersistable()) {
    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
    mInstrumentation.callActivityOnCreate(activity, r.state);
}

源码:ActivityThread 消费事务、创建 Activity 实例、调用 Activity.onCreate。Instrumentation.callActivityOnCreate() 最终触发目标 Activity 的 onCreate();是否继续执行 onStart()、onResume(),由客户端事务要求的生命周期状态决定,并不是 ActivityThread.main() 直接调用这些回调。

这里还要分清两层复用:目标进程已可用时,不必再通过 Zygote 创建进程;目标 Activity 实例可复用时,也可能只需交付新的 Intent,并按条件调用 onNewIntent(),不再创建 Activity 对象。即使调用方的 startActivity() 已返回,也不能据此认定目标 Activity 完成了 onCreate()、绘制了首帧或已经可见。

四、Service:何时创建实例,如何处理启动和绑定请求

启动 Service 不需要先创建 Activity。startService() 和 bindService() 的请求由 AMS 中的 ActiveServices 处理;请求获准且需要新建 Service 实例时,服务端通过 bringUpServiceLocked() 查找或启动目标进程,进程可用后再由 realStartServiceLocked() 安排 scheduleCreateService()。

如果只调用不带 BIND_AUTO_CREATE 的 bindService(),而 Service 实例尚未创建,系统不会仅因这次绑定就创建实例或启动目标进程;如果实例已经存在,则可以向它发起绑定。之后若有其他请求创建了该 Service,先前登记的绑定也可能继续处理。

// ActiveServices.realStartServiceLocked(),节选
thread.scheduleCreateService(r, r.serviceInfo,
        null /* compatInfo (unused but need to keep method signature) */,
        app.getReportedProcState());

源码:startServiceLocked、bindServiceLocked、bringUpServiceLocked、realStartServiceLocked 调度创建。

服务端调用 scheduleCreateService() 后,应用侧把 CREATE_SERVICE 消息交给主线程。主线程在 handleCreateService() 中实例化 Service、附着 Context,最后调用 service.onCreate():

// ActivityThread.handleCreateService(),节选
Application app = packageInfo.makeApplicationInner(false, mInstrumentation);
// ……获取 ClassLoader……
service = packageInfo.getAppFactory()
        .instantiateService(cl, data.info.name, data.intent);
// ……创建 Service Context……
service.attach(context, this, data.info.name, data.token, app,
        ActivityManager.getService());
// ……
service.onCreate();

源码:客户端接收 CREATE_SERVICE、ActivityThread.handleCreateService。这里再次调用 makeApplicationInner() 并不意味着每启动一个 Service 都会重新执行 Application 的 onCreate();已有的 Application 实例会被复用。

服务端安排创建 Service 后,还会根据启动或绑定请求发送后续消息。应用主线程先执行 Service.onCreate(),再处理相应消息;同一个实例也可能同时处于已启动和已绑定状态:

  • 启动请求:服务端通过 scheduleServiceArgs() 交付启动参数,应用侧的 handleServiceArgs() 调用 s.onStartCommand(...)。
  • 绑定请求:首次建立绑定时,handleBindService() 调用 s.onBind(...) 并向 AMS publishService(...);重新绑定时可能调用 onRebind(),已有绑定结果也可能直接复用。连接方收到绑定结果后,才执行其服务连接回调。
// ActivityThread.handleBindService() / handleServiceArgs(),分别节选
IBinder binder = s.onBind(data.intent);
ActivityManager.getService().publishService(
        data.token, data.bindToken, binder);
// ……另一条调度路径……
res = s.onStartCommand(data.args, data.flags, data.startId);

源码:服务端安排 bind、服务端安排 start 参数、客户端 onBind / publishService、客户端 onStartCommand。如果新建 Service 时启动和绑定请求都在等待,系统会为同一个实例安排创建及两类后续回调。但这不代表 onBind() 在所有情况下都早于 onStartCommand():已经运行的启动型 Service 也可能稍后才收到绑定请求。只绑定不意味着会执行 onStartCommand(),只启动也不意味着会执行 onBind();Service.onCreate() 只在实例创建时调用,不会因每次 start 或 bind 都重跑。

五、ContentProvider:访问如何拉起进程,何时调用 onCreate()

Provider 的路径尤其能说明:启动进程和创建目标组件是两回事。即使这次请求是打开 MainActivity,目标进程也可能在处理 bindApplication 时先创建并初始化同进程的 Provider;Activity 实例则在主线程执行启动事务时创建。反过来,其他应用先访问 Provider,也可能因此拉起目标进程,而不需要 Activity 启动请求。

调用方会先检查本进程是否已缓存目标 Provider;若没有,ActivityThread.acquireProvider() 再向 AMS 请求。如果目标 Provider 尚未发布,调用方可能需要等待,直至它发布或等待超时:

// ActivityThread.acquireProvider(),节选
final IContentProvider provider = acquireExistingProvider(c, auth, userId, stable);
if (provider != null) {
    return provider;
}
// ……
holder = ActivityManager.getService().getContentProvider(
        getApplicationThread(), c.getOpPackageName(), auth, userId, stable);

源码:客户端获取 Provider 与等待发布。服务端 ContentProviderHelper.getContentProviderImpl() 再区分已有承载进程和冷进程:

// ContentProviderHelper.getContentProviderImpl(),节选
if (proc != null && (thread = proc.getThread()) != null
        && !proc.isKilled()) {
    if (mService.mProcessStateController.addPublishedProvider(proc,
            cpi.name, cpr)) {
        // ……临时解冻进程……
        try {
            thread.scheduleInstallProvider(cpi);
        } catch (RemoteException e) {
        }
    }
} else {
    // ……省略状态和统计……
    final HostingRecord hostingRecord = HostingRecord.forContentProvider(
            new ComponentName(cpi.applicationInfo.packageName, cpi.name),
            cpi.shouldRunInPccSandbox(),
            callingUid, r != null ? r.processName : null,
            name, stable);
    proc = mService.startProcessLocked(
            cpi.processName, cpr.mAppInfo, false, 0,
            hostingRecord,
            Process.ZYGOTE_POLICY_FLAG_EMPTY, false, false);
}

两处代码来自同一个方法的不同分支,省略了条件检查与统计。 源码:ContentProviderHelper:已有进程或启动进程。如果 Provider 已被缓存或发布,调用方可以复用它;一次 query() 并不必然触发新进程启动。

新进程处理 bindApplication 时,如果 AMS 提供了本进程需要的 Provider 列表,installContentProviders() 会逐个调用 installProvider()。这里的「安装」是框架源码的用词,指在应用进程中创建、初始化并登记 Provider,不是安装应用 APK:localProvider.attachInfo(c, info) 会触发 ContentProvider.onCreate()。处理完列表后,应用进程再通过 publishContentProviders() 向 AMS 发布成功创建的 Provider:

// ActivityThread.installContentProviders(),节选
for (ProviderInfo cpi : providers) {
    ContentProviderHolder cph = installProvider(context, null, cpi,
            false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
    if (cph != null) {
        cph.noReleaseNeeded = true;
        results.add(cph);
    }
}
// ……
ActivityManager.getService().publishContentProviders(
    getApplicationThread(), results);

再看 installProvider() 的内部实现:它创建 Provider 实例后调用 attachInfo(),而 attachInfo() 才会触发 Provider 的 onCreate():

// ActivityThread.installProvider(),节选
localProvider = packageInfo.getAppFactory()
        .instantiateProvider(cl, info.name);
// ……取得 Provider 的 Binder 并进行必要检查……
localProvider.attachInfo(c, info);

// ContentProvider.attachInfo(),节选;与上方不是同一个方法
ContentProvider.this.onCreate();

源码:创建并发布 Provider、instantiateProvider → attachInfo、attachInfo 调用 Provider.onCreate。因此普通冷启动进程的常见调用顺序是:

Application 实例创建/attach
→ ContentProvider.onCreate()(如果绑定期需要创建 Provider)
→ Application.onCreate()
→ 后续具体 Activity.onCreate() / Service.onCreate() / Receiver.onReceive()(取决于触发原因)

注意,Provider.onCreate() 先于 Application.onCreate(),不代表 Provider 对象比 Application 对象更早创建:此时 Application 对象及其 Context 已经准备好,只是 Application.onCreate() 尚未执行。如果进程早已运行,系统也可能通过 scheduleInstallProvider() 通知该进程按需创建并初始化 Provider,无须重新执行 bindApplication。

六、BroadcastReceiver:清单接收器与动态注册接收器

广播投递也可能独立触发目标应用进程启动,不需要先启动 Activity 或 Service。当广播获准投递给清单声明的接收器、而目标进程尚未运行时,BroadcastQueueImpl.scheduleReceiverColdLocked() 会构造广播类型的 HostingRecord,并请求启动该进程:

// BroadcastQueueImpl.scheduleReceiverColdLocked(),节选
final HostingRecord hostingRecord = new HostingRecord(HostingRecord.HOSTING_TYPE_BROADCAST,
        component, r.intent.getAction(), r.getHostingRecordTriggerType(), runInPccSandbox,
        r.callingUid, r.callerApp != null ? r.callerApp.processName : null);
// ……
queue.app = mService.startProcessLocked(queue.processName, info, true, intentFlags,
        hostingRecord, zygotePolicyFlags, allowWhileBooting, false);

源码:BroadcastQueueImpl:冷进程广播投递。动态注册的 Receiver 则依赖已有的注册进程:该进程消失后,旧注册不能再用来冷启动新进程。此外,广播还受投递规则和权限限制,不能理解成「任何广播都能拉起应用」。

进程可用后,队列通过 thread.scheduleReceiver(...) 调度清单接收器;客户端发 H.RECEIVER,handleReceiver() 实例化接收器并调用 onReceive():

// ActivityThread.handleReceiver(),节选
app = packageInfo.makeApplicationInner(false, mInstrumentation);
// ……准备 Context、Intent、ClassLoader……
receiver = packageInfo.getAppFactory()
        .instantiateReceiver(cl, data.info.name, data.intent);
// ……
receiver.onReceive(context.getReceiverRestrictedContext(),
        data.intent);

源码:服务端投递清单接收器、客户端 scheduleReceiver、handleReceiver / onReceive。对于进程仍在运行的动态注册 Receiver,系统通过 scheduleRegisteredReceiver() 和已有的 LoadedApk.ReceiverDispatcher 分发广播,最终也调用 onReceive();它不走上述按清单类名新建接收器实例的路径。源码:动态注册的分发入口、ReceiverDispatcher 调用 onReceive。Receiver 没有与 Activity/Service 对应的 onCreate();其业务入口是 onReceive()。

七、换个入口:不一定由 Activity 首先唤醒进程

前面分别介绍了四类组件的调度。下面用四个独立场景对照,均假设目标进程尚未运行,且相应请求获准执行:

  1. 打开界面:用户从桌面打开 MainActivity。ATMS 发现目标进程不可用时,先请求创建进程;新进程进入 ActivityThread.main(),向 AMS 报到,并在主线程完成应用绑定、处理 Activity 启动事务。发起打开请求,不等于界面已经创建或完成绘制。
  2. 请求 Service:其他应用调用 startService(),或使用带 BIND_AUTO_CREATE 标志的 bindService()。ActiveServices 可以先拉起目标进程,再安排应用侧创建 Service,并按请求调度 onStartCommand() 或绑定回调;全程不需要先打开 MainActivity。
  3. 访问 Provider:其他应用请求目标应用的 Provider。若目标进程不存在,AMS 可以为这次访问启动进程,并在应用绑定期间创建并初始化 Provider。此时 Provider 的 onCreate() 可能先于 Application.onCreate(),即使没有任何 Activity 启动请求。
  4. 投递清单广播:满足投递条件时,广播队列可以为清单声明的 Receiver 启动目标进程,进程就绪后再安排 onReceive()。动态注册不同:旧进程消失后,旧注册不能成为新的冷启动入口。

这四个场景彼此独立,并没有「先启动 Activity,再启动其他组件」的固定顺序。如果 MainActivity 此后调用 startActivity() 打开 DetailActivity,那也是应用新发起的一笔请求。

小结

读启动流程时,先确认目标组件所在进程是否可用,再追踪这次请求对应的组件调度。新进程进入 ActivityThread.main() 只说明进程已启动,不能据此认定组件已创建;Provider 还可能在应用绑定期间、Application.onCreate() 之前执行自己的 onCreate()。

参考源码

以下链接固定到同一份 AOSP frameworks/base 提交,便于对照版本差异,不使用机器上的源码路径: