启动时间降了 40%,用户还是说卡:用 Trae 重测冷启动与热启动

3 阅读11分钟

启动时间降了 40%,用户还是说卡:用 Trae 重测冷启动与热启动

去年十月十七号,灰度看板上模块 M 的冷启动中位数从 1180ms 掉到 704ms,降了 40.3%,我在周会上把那条曲线投上去,觉得这事能收尾了。当天下午客服转来三条反馈,措辞几乎一样:点开图标还是要等一下才能划。我拿那台 Pixel 6 反复点了十几次才承认不对——图标按下去到首页能滑动之间还有一段空白,704ms 压根没盖住它。翻埋点才发现两个数被我当成了一个:上报的是 logcat 里 Displayed 那行的时间,用户等的是列表第一条能点的时间;采样脚本又没分进程状态,按 home 切回来的热启动、Activity 被回收后重建的温启动,全混进冷启动一起算平均。那 40% 里,有一截是我把好测的样本多算了几遍。

后来我把这句话贴在显示器边框上:一直在优化的那个数,可能不是用户感知的那个数。后面所有取舍——改用哪把尺子、把哪段初始化从首帧前面搬走、CI 上到底卡哪个分位数——都是从这一句推出来的,没有一处是拍脑袋加的优化。

那个降了 40% 的数,用户根本不等它

翻车当晚我做的第一件事,不是继续压那个 704ms,是把上报链路从头到尾捋了一遍。模块 M 是我们那个健康类 App 里承载首页健康记录的模块,包名 com.example.health,首页是一屏带卡片的 RecyclerView,数据从本地数据库读出来再拼一层网络配置。埋点字段叫 startup_ms,取的是 Activity 起来之后到 onWindowFocusChanged 那一刻,样本则来自一段跑在测试机上的 shell 脚本:循环 am start -W,把 TotalTime 抠出来求平均。

问题就出在这两个「顺手」上。onWindowFocusChanged 触发时,首帧确实画了,但 RecyclerView 的 Adapter 还是空的,卡片要等 Room 查询回来才 inflate;用户看到的是一块有底色的空列表,手指划上去没反应。而循环脚本每次 am start -W 之间只隔了三秒,进程根本没死,绝大多数轮次是热启动被当成了冷启动。

我把同一次启动在六个地方读到的数摆到一张表上,那天晚上盯着它看了很久:

观测点它真正记录的那一刻我这次读到的数从哪起算归谁管
adb shell am start -W 的 TotalTime目标 Activity 启动流程走完704msstartActivity 调用本机 shell 的计时
logcat Displayed 那一行首帧绘制完成,也就是 TTID698ms收到启动 intentsystem_server
Perfetto trace 里第一帧 Choreographer#doFrame 结束首帧真正提交给 SurfaceFlinger721msVSYNC 信号内核 ftrace
reportFullyDrawn() 打出的 Fully drawn列表第一条数据绑定完,也就是 TTFD1680ms收到启动 intent我自己在代码里埋的
用户眼睛首页能滑动、第一条卡片能点大概 1.7s 往上手指按下图标这件事用户,不归我管
线上看板 startup_ms P50一个混了三种进程状态的平均值704ms每个样本各自为政我写错的那段埋点

这张表里最刺眼的是第四行和第六行:同一个用户、同一次点击,我自己埋的 reportFullyDrawn 读到 1680ms,看板却写 704ms,差了 976ms。前两行的 704 和 698 又几乎一样,因为 am start -W 的 TotalTime 和 Displayed 本来就是同一件事的两种说法——都是首帧,都不是「能用」。第三行的 721 比 698 多出来那 23ms,是 VSYNC 对齐和 SurfaceFlinger 合帧的开销,shell 计时看不见它。

我以前一直默认「启动时间」是个单数,好像存在一个客观的、从图标按下到 App 打开的时间,工具读出来多少就是多少。那天才明白这是个复数:每个工具都在自己那一层截断,截断的位置由它能不能看见后面的事决定。Displayed 由系统在第一帧 onDraw 时打,系统此后就不知道 App 内部在干嘛了;reportFullyDrawn 得我自己调,我不调它就永远不报,官方口径里写得很清楚——如果从未调用 reportFullyDrawn(),TTFD 就退回成 TTID,等于系统替我假装「首帧即完全显示」。我那段埋点没调它,看板自然就把 TTID 当成了全部。

还有个更隐蔽的坑藏在第一行。am start -W 单次输出里其实有三个时间:

Starting: Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] cmp=com.example.health/.MainActivity }
Status: ok
LaunchState: COLD
Activity: com.example.health/.MainActivity
ThisTime: 698
TotalTime: 698
WaitTime: 704
Complete

ThisTime 是最后一个 Activity 的启动耗时,TotalTime 是所有 Activity 启动加起来(有 SplashActivity 转发时两者会分开),WaitTime 是 am 这个命令从发起到拿到结果的总耗时,包含 system_server 调度。我脚本抠的是 TotalTime,可我对外说的是「冷启动」。LaunchState: COLD 这一行是新一些的系统版本才补上的,我压根没解析它,脚本跑了半年,从没确认过每一轮到底是不是冷启动。

三态不是三种快慢,是三条不同的路

把样本混在一起之所以能把数拉低一大截,是因为冷、温、热根本不是同一条路径的三个快慢档,而是三条岔路,各自省掉的步骤不一样。

  • 冷启动:进程不存在。Zygote 要 fork 一个新进程,ART 起来,Application 对象新建,attachBaseContext 和 onCreate 都跑一遍,ContentProvider 逐个安装,目标 Activity 从 onCreate 走到 onResume,首帧绘制。系统在这一路会显示启动窗口(StartingWindow),Android 12 起显示的是 SplashScreen。
  • 温启动:进程还活着,但 Activity 已经被销毁了。按 back 退出、或者系统回收了 Activity 栈却留着缓存进程,都属于这档。不用 fork 进程,Application.onCreate 不重跑,但要重建 Activity,onCreate / onStart / onResume 重新走一遍,View 树重新 inflate。Android 12 起这一路也会显示 SplashScreen。
  • 热启动:进程和 Activity 都在,只是被带到后台又带回前台。按 home 键再点图标是最典型的,走的是 onRestart / onStart / onResume,连 View 树都不用重建,通常只是把已有的 window 重新显示出来。这一路系统从不显示 SplashScreen,启动窗口也不出现。

我在那台 Pixel 6(Android 14,API 34)上用同一版包各测了十轮,取中位数:冷启动 1240ms,温启动 480ms,热启动 190ms。冷是热的六倍多。我那个循环脚本三秒一轮,进程一直没死,绝大多数落在 190ms 那一档,少数重建 Activity 的落在 480ms,真正的冷启动可能十轮里一轮都没有。把这三档求平均,得出来的数当然好看,也当然跟用户点开新一天第一次使用的体感对不上。

用一张状态图把岔路画出来,比记文字牢靠:

stateDiagram-v2
    [*] --> 不存在: 从未启动 / force-stop / lmkd 回收进程
    不存在 --> 冷启动: 点击图标,Zygote fork + Application.onCreate + Activity 全量
    冷启动 --> 前台: 首帧 + reportFullyDrawn
    前台 --> 后台缓存_Activity在: 按 home(Activity 只 onStop)
    前台 --> 后台缓存_Activity销毁: 按 back(Activity finish,进程留着)
    后台缓存_Activity在 --> 热启动: 再点图标,onRestart/onStart/onResume,无 SplashScreen
    后台缓存_Activity销毁 --> 温启动: 再点图标,重建 Activity,无 Application.onCreate
    后台缓存_Activity在 --> 不存在: lmkd 按 oom_adj_score 回收
    后台缓存_Activity销毁 --> 不存在: lmkd 按 oom_adj_score 回收
    热启动 --> 前台: 直接带回 window
    温启动 --> 前台: 重建 View 树后首帧

想测哪一档,就得亲手造出那一档

三态定义背得再熟,机器不给面子的时候也没用。我后来把造态的命令固定成四条,写进脚本注释里,每次跑之前先确认自己站在哪条岔路上。

# 干净冷启动:杀进程、清 Task、停掉所有组件,回到「从未启动」
adb shell am force-stop com.example.health

# 只杀后台进程,保留 Activity 栈记录,用来造温启动
adb shell am kill com.example.health

# 冷启动单次计时,注意解析 LaunchState 那一行
adb shell am start -W -n com.example.health/.MainActivity

# 看当前进程还在不在,adj 是多少
adb shell ps -A | grep com.example.health
adb shell cat /proc/$(adb shell pidof com.example.health)/oom_score_adj

am force-stop 和 am kill 的差别我一开始也搞混过。force-stop 会把包标记成 stopped 状态,连带把它的 Task、闹钟、广播注册全清掉,下一次启动是从零开始;am kill 只挑后台进程杀,Activity 栈和任务栈的记录还留在 system_server 里,用户再点图标时系统知道「这个 Task 之前在哪」,于是走重建 Activity 那条路。按 back 和按 home 的区别同理:back 默认会 finish() 掉当前 Activity,home 只是把它 onStop,两者都留进程,但前者下次要重建 View,后者不用。

真正麻烦的是 lmkd。缓存进程留着是为了切换快,系统按 oom_adj_score 从高到低回收,内存一紧张,后台进程说没就没。我在 Redmi Note 11(Android 11,API 30,4GB 内存)上复现过:同一个包、同一个版本,连着测十次冷启动,中位数能差到 2.3 倍,原因就是前几次跑完机器把别的缓存进程收了、留下了我的,后几次内存吃紧把我的也收了,进程状态在冷和温之间来回跳。同一台机、同一个版本,数据差几倍,多数时候不是代码变了,是我以为在测 A,实际测到了 B 或 C。

从那天起我给自己立了条规矩:任何「优化后」的数字,必须同时写清三件事——进程状态用什么命令造的、口径是 TTID 还是 TTFD、样本量和分位数。三件缺一件,那个数我就不往周会上放。十月那次 40.3% 的曲线,后来被我从复盘文档里划掉了,改成一句「口径错误,样本污染,作废」。

一次冷启动,在系统里到底走了多远

要判断一个数到底截在哪一层,得先知道这一路都经过谁。我把冷启动的完整链路画成一张时序图,贴在 docs/startup-chain.md 里,后来给 Trae 讲需求时也是先 @ 这张图。图不复杂,但有两个节点的位置,我以前一直摆错了。

sequenceDiagram
    autonumber
    participant L as Launcher
    participant ATMS as ATMS / AMS<br/>(system_server)
    participant Z as Zygote
    participant AT as ActivityThread
    participant App as Application
    participant CP as ContentProvider
    participant A as MainActivity
    participant V as ViewRootImpl
    participant C as Choreographer / VSYNC

    L->>ATMS: 点击图标 → startActivity(intent)
    ATMS->>ATMS: 解析 ActivityInfo、校验权限、<br/>决定目标栈与 Task
    ATMS->>Z: 目标进程不存在 → 请求 fork<br/>(Process.start / Zygote)
    Z-->>AT: fork() 出新进程,加载 ART 运行时
    AT->>AT: ActivityThread.main()<br/>Looper.prepareMainLooper()
    AT->>ATMS: attachApplication()
    ATMS->>AT: bindApplication()
    AT->>App: new Application → attachBaseContext()
    Note over CP,App: 关键:installContentProviders() 在这一段,<br/>ContentProvider.onCreate 早于 Application.onCreate
    AT->>CP: installContentProviders() → 各 CP.onCreate()
    AT->>App: Application.onCreate()
    ATMS->>AT: 调度 LAUNCH_ACTIVITY
    AT->>A: Activity.onCreate / onStart / onResume
    A->>V: setContentView → ViewRootImpl.setView()
    V->>C: scheduleTraversals() → 申请 VSYNC
    C-->>V: VSYNC 到来 → doFrame()
    V->>V: measure / layout / draw → 首帧提交 SurfaceFlinger
    Note over V,L: logcat 打 Displayed,TTID 到这里为止
    A->>A: 异步数据就绪 → reportFullyDrawn()
    Note over A,L: TTFD 到这里,用户才真正能划能点

从手指按下去到 startActivity,Launcher 那一侧其实已经有一段系统开销了:输入事件分发、Launcher 自己的点击动画、intent 组装。这段不在 am start -W 的计时里,也不在 Displayed 里,但用户在等它。我后来用 Perfetto 抓 InputDispatcher 到 ActivityTaskManager 的那一段,在这台 Pixel 6 上稳定有 40~70ms,低功耗状态下偶尔到 110ms。用户眼睛那一行比工具读数多出来的零头,有一部分就来自这里。

ATMS 是 Android 10(API 29)之后从 AMS 里拆出来的,专门管 Activity 和 Task 栈,AMS 继续管进程、Service、内存。老文章里一律写 AMS,我按自己 targetSdk 34 的现状标成 ATMS / AMS,免得后面查源码时两个名字对不上。它决定这个 intent 落在哪个 Task、要不要复用已有 Activity、启动窗口长什么样,然后发现目标进程不存在,才回头找 Zygote。

Zygote 那一步是冷启动贵的根。它不是从头建一个虚拟机,而是把自己这个已经预加载了框架类、资源、共享库的进程 fork() 一份,子进程靠写时复制直接继承这些页。fork 本身很快,贵的是之后 ART 要把 APK 里的 dex 映射进来、按需把类和方法编译成本地代码、把 resources.arsc 和 .so mmap 好。我在这台 Pixel 6 上抓过一次,bindApplication 到 Application.onCreate 之前光是类加载和 dex 页错误就吃了 200ms 上下,这部分压不到零,只能靠后面要讲的编译链让它少发生一点。

ActivityThread.main() 是应用进程真正的入口,它建主线程 Looper,然后 attachApplication() 回头告诉 system_server「我起来了」。system_server 再通过 bindApplication 把该装的都塞回来。顺序是固定的:new Application → attachBaseContext() → 安装 ContentProvider → Application.onCreate()。注意中间那一步,我把它标成图里唯一一个 Note,因为这是我踩得最久的一个坑,下一节专门讲。

ContentProvider 比 Application 先醒,这件事坑了我两次

installContentProviders() 排在 Application.onCreate() 前面,不是实现细节,是 ActivityThread.handleBindApplication() 里写死的顺序。系统在 bindApplication 这一趟里,先把 Manifest 里声明的 <provider> 按优先级逐个实例化、调 onCreate(),全装完了才轮到 Application.onCreate()。我第一次踩它,是给模块 M 接一个推送 SDK,对方文档只说「在 Application 里 init 一下」,我照做了,结果线上冷启动多了 90ms。抓 trace 才看见,那个 SDK 自己在 Manifest 里塞了个 InitProvider,onCreate 在我那行 init 之前就跑完了,我等于初始化了两遍。

第二次更隐蔽。我想把某个非关键 SDK 挪到首帧之后,用 IdleHandler 延迟加载,改完测下来 TTID 只降了 8ms。翻 AndroidManifest.xml 才发现它也声明了一个空壳 <provider>,onCreate 里就一句 return true,但光是这个 provider 的实例化、类加载、PackageManager 查询就已经在 Application.onCreate 之前花掉了时间。我以为搬走的是 Application.onCreate 里的代码,实际挡路的根本不在那儿。


<provider
    android:name=".EmptyInitProvider"
    android:authorities="com.example.health.emptyinit"
    android:exported="false"
    android:initOrder="50" />

把 provider 清单整个扫出来,成了我后来给 Trae 的第一轮任务。initOrder 越大越先装,同一个进程里所有 provider 都在主线程串行执行,谁在前面谁就抬高了后面所有人的起点。这也是 Jetpack App Startup 当初要解决的问题:一堆 SDK 各带一个 ContentProvider,就有十次 getPackageInfo 和十次跨进程查询,它把大家收进一个 InitializationProvider,用依赖图排一次序。原理我认,但落地我不想为一个拓扑排序多引一层库,后面定稿代码里是直接用原生 Kotlin 写的 StartupGraph,几百行都不到。

从 onCreate 到那一帧,中间还隔着 VSYNC

Activity 走完 onCreate / onStart / onResume 只代表它「活了」,不代表屏幕上有了东西。setContentView() 建的是 View 树,真正把它贴到窗口上的是 ViewRootImpl.setView(),接着 scheduleTraversals() 向 Choreographer 申请一次 VSYNC。等到下一个 VSYNC 信号,doFrame() 才跑 measure / layout / draw,把绘制命令交给 RenderThread,再由 SurfaceFlinger 合帧上屏。

Choreographer 这层决定了「首帧」不是想画就画的。就算我把 onCreate 压到 1ms,首帧也得等下一个 VSYNC,60Hz 屏上最多等 16.6ms,90Hz 上约 11.1ms。logcat 里那行 Displayed 打的就是这一帧完成的时刻,系统判断 TTID 的依据是 Choreographer 第一次调 Activity 的 onDraw()。它到此为止——系统不知道我的列表什么时候填完,也不该知道。

// 我用来对齐「首帧」和「可交互」两个时刻的最小埋点,落在 MainActivity
class MainActivity : AppCompatActivity() {

    private var firstFrameLogged = false

    override fun onCreate(savedInstanceState: Bundle?) {
        val splash = installSplashScreen()
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        window.decorView.viewTreeObserver.addOnPreDrawListener(object :
            ViewTreeObserver.OnPreDrawListener {
            override fun onPreDraw(): Boolean {
                if (!firstFrameLogged) {
                    firstFrameLogged = true
                    viewTreeObserver.removeOnPreDrawListener(this)
                    StartupTrace.mark("first_frame_predraw")
                }
                return true
            }
        })

        viewModel.records.observe(this) { list ->
            adapter.submitList(list) {
                // 列表第一条真正绑定完、能点能划,才报完全显示
                reportFullyDrawn()
                StartupTrace.mark("fully_drawn")
            }
        }
    }
}

reportFullyDrawn() 是 ComponentActivity 上的方法,调它之后 logcat 会跟着出一行:

I/ActivityManager: Fully drawn com.example.health/.MainActivity: +1s680ms

官方把 TTID 定义成「显示应用界面第一帧所需的时间」,TTFD 定义成「TTID 加上首帧之后异步加载内容显示出来的时间」,并且明确:TTFD 在调用 ComponentActivity.reportFullyDrawn() 后报告,如果从不调用,就改报 TTID。还有一条容易翻车的时序——不能在第一帧绘制之前调 reportFullyDrawn(),否则系统会把 TTID 和 TTFD 报成同一个值,等于白埋。我上面那段把它放在 submitList 的提交回调里,就是为了保证一定晚于首帧。

如果「完全显示」要等好几个后台任务,官方给的做法是 getFullyDrawnReporter() 拿 FullyDrawnReporter,每个任务注册一个 reporter,全部 release() 之后系统才真正报 TTFD。这么做还有个附带好处:这些任务里跑过的代码路径会被算进启动路径,生成 Baseline Profile 时能一起收进去。我模块 M 的首页有本地库查询、配置拉取、埋点 SDK 就绪三件事,就是靠三个 reporter 收口的,没有自己拿计数器硬凑。

启动窗口、白屏,和那个「假死」开关

冷启动建进程要几百毫秒,这段时间屏幕上不能是黑的,系统在真正窗口起来之前先垫一个 StartingWindow。它长得由主题里的 android:windowBackground 决定:没专门配,就跟着主题的 colorBackground 走,浅色主题一片白、深色主题一片黑。用户嘴里说的「点开先白一下」「先黑一下」,指的就是它,不是 App 卡了。

老办法是给启动 Activity 设一个专门的 windowBackground,塞一张品牌图或纯色 layer-list,把白屏换成自家底色:


<style name="Theme.Health.Launch" parent="Theme.Health">
    <item name="android:windowBackground">@drawable/launch_background</item>
    <item name="android:windowNoTitle">true</item>
</style>


<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@color/launch_bg" />
    <item android:gravity="center">
        <bitmap android:src="@drawable/ic_launch_mark" android:gravity="center" />
    </item>
</layer-list>

这招到今天还能用,但只是「遮」,不缩短任何一步。真正出事的是另一个开关:


<item name="android:windowDisablePreview">true</item>

我见过有人为了「不要白屏」把它设成 true,结果系统连 StartingWindow 都不画了,从点击到首帧之间屏幕一直停在 Launcher 上一动不动,用户以为点了个没反应的图标,连点三下再卸载。它不是去掉白屏,是把「系统还在干活」这个反馈也一起去掉了,把等待变成假死。这条我写进了项目的 Rules,凡是 windowDisablePreview 出现一律打回。

Android 12(API 31)把这件事从「应用自己遮」收成了「系统统一画」。SplashScreen 是 Window 层面的东西,不是一个 Activity:系统在新建 Task、新窗口时由 PhoneWindow 画出来,不走 setContentView,也不占 Activity 栈。所以冷启动和温启动都会显示——这两种都要新建或重建窗口;热启动从不显示——它只是把已有 window 带回前台,压根没有新窗口这回事。我以前一直以为闪屏是个「页面」,直到为了迁移去读 SplashScreenViewProvider 才转过来。

图标规格是跟着 Adaptive Icon 走的,我按官方那张表对的:

形态图片尺寸内容必须落在的圆备注
带图标背景(Theme.SplashScreen.IconBackground)240×240 dp直径 160 dp圆外会被遮掉
无图标背景(Theme.SplashScreen)288×288 dp直径 192 dp用矢量图时绝对尺寸不重要
品牌图(Android 12+)200×80 dp—固定在底部
动画图标时长——建议不超过 1000ms,系统有上限

core-splashscreen 这个 AndroidX 库是 1.0.0 起提供的,把 Android 12 的这套行为向下补到了 API 23,低版本上除了动画矢量图不支持,其余靠主题模拟。接入就三步:依赖、主题、installSplashScreen()。有一条时序我返工过——installSplashScreen() 必须在 super.onCreate() 之前调,因为它要负责把主题切到 postSplashScreenTheme;我第一版放在 super.onCreate() 后面,Android 12 上闪屏退场动画死活不触发。


<style name="Theme.Health.Starting" parent="Theme.SplashScreen">
    <item name="windowSplashScreenBackground">@color/launch_bg</item>
    <item name="windowSplashScreenAnimatedIcon">@drawable/ic_splash_mark</item>
    <item name="windowSplashScreenAnimationDuration">800</item>
    <item name="postSplashScreenTheme">@style/Theme.Health</item>
</style>


<style name="Theme.Health.Starting" parent="Theme.SplashScreen">
    <item name="android:windowSplashScreenBackground">@color/launch_bg</item>
    <item name="android:windowSplashScreenAnimatedIcon">@drawable/ic_splash_mark</item>
    <item name="android:windowSplashScreenBrandingImage">@drawable/ic_brand</item>
    <item name="android:windowSplashScreenAnimationDuration">800</item>
    <item name="postSplashScreenTheme">@style/Theme.Health</item>
</style>
// SplashActivity / MainActivity 的接法,installSplashScreen 必须在 super 之前
class MainActivity : AppCompatActivity() {
    private var ready = false

    override fun onCreate(savedInstanceState: Bundle?) {
        val splash = installSplashScreen()
        // 首屏必须用到的少量数据没就绪前,别急着撤闪屏,但要设超时上限
        splash.setKeepOnScreenCondition { !ready }
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        lifecycleScope.launch {
            withTimeoutOrNull(2000) { viewModel.loadFirstPage() }
            ready = true
        }
    }
}

setKeepOnScreenCondition 是把闪屏留久一点的钩子,条件返回 true 就一直挂着。它很适合原来那个做路由的 SplashActivity:迁移时不想立刻删,就让条件恒为 true、自己 finish() 跳到真正的首页,闪屏会顺着转到下一个 Activity。但一定要配超时,我给的是 2000ms——网络一慢,没有上限的 setKeepOnScreenCondition 会让闪屏挂到天荒地老,用户看到的就是另一个版本的假死。

Android 11 及以下那些自定义闪屏必须迁,不是可选项。旧的 SplashActivity + Handler.postDelayed 跳首页那套,到了 Android 12 会跟系统 SplashScreen 叠成两层闪屏,启动时间不降反增,官方迁移文档里也是明着建议把自定义 Activity 整个删掉。我删的时候顺手把里面那段 800ms 的 postDelayed 一起清了,那一天 TTID 直接少了 700 多毫秒——所谓「启动优化」里最夸张的一次降幅,来自删掉一个本来就不该存在的等待。

挡在首帧前面的,是一张初始化依赖图

把启动链拆到系统层之后,我回过头数了数 Application.onCreate() 里到底堆了多少东西。模块 M 那份清单我贴出来过一次,二十七个 init 调用,SDK、数据库、埋点、推送、配置、图片加载、崩溃上报……一字排开全在主线程同步跑。它们不是彼此无关的一堆,是有依赖的:数据库要先建好,埋点才能写;配置要先拉到,网络层才知道连哪个域名;推送要等账号模块就绪。可代码里看不出依赖,只看出书写顺序,谁先谁后全靠「当年谁先接进来的」。

App Startup 的思路我认:每个组件声明成一个 Initializer<T>,用 dependencies() 返回它依赖哪些别的 Initializer,库按这张图做一次拓扑排序,保证被依赖的先跑,且全部收进同一个 ContentProvider。原理讲透就够,落地我不引它——二十七个节点用一个 ArrayDeque 做 Kahn 排序不过几十行,还能顺手把「同步 / 异步 / 延迟 / 懒加载」的分级一起做进去,不用为了等一个第三方库的 API 去改自己的节奏。定稿代码里的 StartupGraph 就是这么来的。

依赖图长这样,箭头是「谁得先于谁」:

flowchart TD
    BOOT[进程 fork / attachBaseContext] --> CORE[CoreInitializer<br/>同步·主线程]
    CORE --> DB[DatabaseInitializer<br/>同步·主线程]
    CORE --> CFG[ConfigInitializer<br/>同步·主线程]
    DB --> REPO[RecordRepository<br/>同步·主线程]
    CFG --> NET[NetworkInitializer<br/>同步·主线程]
    REPO --> VM[首页 ViewModel 数据<br/>决定 TTFD]
    NET --> VM
    CORE -.延迟.-> PUSH[PushInitializer<br/>IdleHandler 后]
    CORE -.延迟.-> TRACK[TrackingInitializer<br/>首帧后]
    CORE -.懒加载.-> IMAGE[ImageLoader<br/>首次用到才建]
    DB -.异步.-> CACHE[CacheWarmInitializer<br/>IO 线程]
    PUSH -.依赖.-> CFG
    VM --> RFD[reportFullyDrawn]

分级我是按「首帧之前必须就绪吗」这一刀切的,四档:

档位判据放在哪模块 M 里的例子搬错档的代价
同步首帧 inflate 就要用到,缺了直接崩Application.onCreate 主线程数据库、配置、网络层没法搬,只能压它自己
异步首帧不依赖,但越早越好启动即投 IO 线程本地缓存预热放主线程会抢首帧 CPU
延迟首页能显示之后再用得上首帧后 / IdleHandler推送、埋点、崩溃上报放早了白占主线程
懒加载只有特定页面才用第一次用到才建图片加载、报表导出提前建等于白干

延迟这档最容易写歪。我最早用 Handler.postDelayed({ initPush() }, 1500),觉得延后 1.5 秒总安全了。结果在那台 Redmi Note 11 上,首帧偶尔要 1.6 秒,postDelayed 正好卡在 doFrame 之前醒来,跟首帧抢主线程,TTID 不降反抖。postDelayed 是按墙上时间到点就投,它不知道主队列此刻忙不忙,所谓「延迟」是我猜的一个数,不是系统给出的空档。

换成 IdleHandler 才对:它只在消息队列暂时空下来时回调,也就是首帧那轮 traversal 跑完、主线程没活了才轮到它,天然不会抢首帧。

// 首帧之后再跑的活,挂到主线程空闲,而不是猜一个延时
Looper.myLooper()?.let { looper ->
    MessageQueue.IdleHandler {
        StartupGraph.runDeferred("PushInitializer")
        StartupGraph.runDeferred("TrackingInitializer")
        false   // 返回 false 表示只回调一次,别反复唤醒
    }.also { handler ->
        Looper.myQueue().addIdleHandler(handler)
    }
}

要揪出还有谁在主线程偷偷干重活,我靠 StrictMode,不靠猜:

// debug 构建才开,别带进 release
if (BuildConfig.DEBUG) {
    StrictMode.setThreadPolicy(
        StrictMode.ThreadPolicy.Builder()
            .detectDiskReads()
            .detectDiskWrites()
            .detectNetwork()
            .penaltyLog()
            .build()
    )
    StrictMode.setVmPolicy(
        StrictMode.VmPolicy.Builder()
            .detectActivityLeaks()
            .detectLeakedSqlLiteObjects()
            .penaltyLog()
            .build()
    )
}

开了之后第一周 logcat 里刷出来十几条,最离谱的一条是某个 SDK 在 ContentProvider.onCreate 里同步读了三个 SharedPreferences 文件——又是那个比 Application 先醒的位置。主线程磁盘读在冷启动上尤其贵,因为这时候页缓存还没热起来,一次 sp.getAll() 能顶掉几十毫秒。

这里顺带碰到合规的边界。有几个 SDK 的隐式初始化里夹着设备标识采集和权限申请,我把它们从同步档挪出去之后,第一次真正申请权限的时机也跟着变了。我们那个健康类 App 涉及健康数据和定位,做法是先把用途说明用原生 AlertDialog 弹出来讲清楚,用户点了确认再走 requestPermissions,不提前、不静默、不靠 SDK 自己在 provider 里偷偷申请。这块不在这篇展开,但初始化拓扑改完之后,哪些 SDK 会在何时碰权限,反而比改之前清楚多了——依赖图顺手把合规边界也画出来了。

测启动的尺子和被换掉的老办法

一把尺子,十几年换过好几轮

启动这件事最早的测量手段朴素得有点可爱:Android 4.4 前后,system_server 在把首帧画出来时往 logcat 打一行 Displayed,开发拿秒表对着日志看。这行日志到今天还在,我十年前就是靠它调启动的。

I/ActivityTaskManager: Displayed com.example.health/.MainActivity: +698ms

早年间 tag 是 ActivityManager,后来 Activity 栈管理拆给 ActivityTaskManager,tag 跟着变了,但语义没变:从收到启动 intent 到第一帧绘制完成。它是系统唯一一个不需要 App 配合就能给出的时间,所以到今天仍是很多看板的默认口径——也是我那次翻车的根源。系统能测到首帧,测不到首帧之后 App 自己还在等的数据。

am start -W 是同一时期给开发用的壳,把 ThisTime / TotalTime / WaitTime 三个数摆出来;前面那张对照表已经拆过,这里补一句它为什么容易被误用:-W 是「等这个 Activity 启动完」的意思,它天然只关心启动流程本身,不关心启动之后界面里有没有内容。用 shell 循环反复打,还默认复用进程,LaunchState 不解析就分不清态。工具没错,是我拿它答了另一道题。

系统侧真正能标出「可交互」的口子,是 reportFullyDrawn()。官方对两个指标的定义我抄在 docs/metrics.md 里,每次跟人对齐口径都直接贴:TTID 是显示应用界面第一帧所需的时间;TTFD 是 TTID 加上首帧之后异步加载内容显示出来的时间,在调用 ComponentActivity.reportFullyDrawn() 后报告,从不调用就改报 TTID。系统不知道每个 App 什么时候算「全画完」,所以 TTFD 得应用自己喊。这句话我读到第三遍才真正记住——不是系统不给我更准的数,是那件事只有我自己知道。

Android 12(API 31)又补了一层 FrameTimeline。它不再只给一个总时间,而是把每一帧的 deadline、实际完成时间、以及「是谁没赶上」记下来,能区分 AppDeadlineMissed 和 SurfaceFlingerDeadlineMissed:

adb shell dumpsys gfxinfo com.example.health framestats
# 或走 Perfetto 的 FrameTimeline 数据源,按帧看:
#   expectedPresentTime / actualPresentTime
#   jankType: AppDeadlineMissed | SurfaceFlingerDeadlineMissed | None

这层对启动的意义是:以前我只能说「首帧 698ms」,现在能说「首帧那轮 App 自己 measure/layout 花了 41ms,没超 16.6ms 的预算,但后面第三帧因为列表 inflate 超了 22ms」。TTID 和 TTFD 之间那段空白,终于能被拆成一帧一帧的账。

采集后端也换过。老 Systrace 是基于 atrace 的 Python 脚本,Android 10(API 29)起系统级 trace 默认走 Perfetto,之后 Systrace 命令行逐步退场,Perfetto 的数据源、SQL 查询和长时录制成了主流。我现在的启动 trace 一律用 Perfetto 抓,脚本放在 scripts/record_startup.sh,后面定稿代码里给全。

真正把「冷启动」变成可重复实验的,是 Jetpack Macrobenchmark。它把编译状态、进程状态、迭代次数都变成参数,不再靠我手写 shell 循环。官方给的冷启动对照写法我基本照搬:

@RunWith(AndroidJUnit4::class)
class ColdStartupBenchmark {
    @get:Rule val benchmarkRule = MacrobenchmarkRule()

    @Test fun startupNoCompilation() = startup(CompilationMode.None())

    @Test fun startupPartialWithBaselineProfiles() =
        startup(CompilationMode.Partial(baselineProfileMode = BaselineProfileMode.Require))

    @Test fun startupPartialCompilation() = startup(
        CompilationMode.Partial(
            baselineProfileMode = BaselineProfileMode.Disable,
            warmupIteration = 3
        )
    )

    @Test fun startupFullCompilation() = startup(CompilationMode.Full())

    private fun startup(compilationMode: CompilationMode) =
        benchmarkRule.measureRepeated(
            packageName = "com.example.health",
            metrics = listOf(StartupTimingMetric()),
            compilationMode = compilationMode,
            iterations = 10,
            startupMode = StartupMode.COLD,
            setupBlock = { pressHome() }
        ) {
            uiAutomator {
                startApp("com.example.health")
                onElement(5_000) { viewIdResourceName == "record_list" }
            }
        }
}

几个参数是我踩过坑才固定下来的。startupMode = StartupMode.COLD 明确造冷态,比我自己 am force-stop 靠谱;iterations = 10 是官方示例的取值,配合 CompilationMode 里的 warm-up 把 JIT 预热噪声隔开;CompilationMode.Partial(baselineProfileMode = BaselineProfileMode.Require) 里的 Require 很关键——它要求目标 App 的 Baseline Profile 方法必须真的被预编译,profile 没打进包或没生效,测试直接报错,而不是静默地量一个没优化过的包。我第一版用的是 UseIfAvailable,profile 因为 R8 混淆改了类名没匹配上,测试照样绿,白高兴两天。

StartupTimingMetric 报的是 timeToInitialDisplayMs,只有 App 调了 reportFullyDrawn() 才会多出 timeToFullDisplayMs。官方拿 Now in Android 在 Pixel 7 上跑的对照是:Baseline Profiles 229.0ms,无编译 324.8ms,全量编译 315ms,部分编译 312ms。我第一次看到这组数注意的不是差值,是「无编译比全量编译还慢」——同一份代码,冷启动能差出近 100ms,只因为 ART 有没有提前把它编好。这件事得单开一章讲。

还有一条我改得很晚的习惯:不看平均值,看分布。Macrobenchmark 每次输出 min / median / max,我把十轮结果导成 JSON 再算 P50 和 P90:

{
  "device": "Pixel 6 / Android 14 / API 34",
  "startupMode": "COLD",
  "compilationMode": "Partial(Require)",
  "iterations": 10,
  "timeToInitialDisplayMs": { "min": 461, "median": 498, "max": 573, "p90": 549 },
  "timeToFullDisplayMs":    { "min": 742, "median": 806, "max": 1104, "p90": 1088 }
}

平均值会被一轮降频或一次后台同步拉走,中位数不会;而用户投诉的往往是尾部那几轮,P90 才是要盯的。我那次看板报的 704ms 是平均值,还是混了三态的平均值,两重失真叠在一起。改成 P90 之后,优化前那个数从 704ms 变成 1910ms,难看多了,但那才是用户真正在等的量级。

从 2008 到 2026,一条时间线

把版本、API level 和行为变化摆在一张表上,是为了后面判断「某个老办法为什么当年管用、现在不管用」。表里只列跟启动这条线直接相关的节点。

时间版本 / API行为变化对我这把尺子的影响
2008-091.0 / API 1Zygote fork + Dalvik 解释执行,编译链还没成形启动慢是常态,没有可对照的优化手段
2010 前后2.xDalvik 引入 JIT,运行时编译热点方法首次启动与「用了一阵之后」开始分化
2013-104.4 / API 19logcat Displayed 系统化,系统首次给出统一的首帧时间有了第一个「官方数」,也只有首帧
2014-115.0 / API 21ART 成为默认运行时,安装时全量 AOT安装慢、占空间、OTA 后要重编,换启动快
2015-096.0 / API 23延续全量 AOT同上,代价持续被吐槽
2016-087.0 / API 24回到 JIT + profile-guided 编译,不再安装时全量 AOT安装快了,冷启动重新依赖「跑过多少次」
2018-089 / API 28Play 引入 Cloud Profiles,聚合设备上传的 profile 下发给新装用户冷启动平均至少快 15%,但聚合要几天
2019-0910 / API 29ATMS 从 AMS 拆出;Perfetto 成为系统级 trace 后端源码名字和采集工具都要跟着换
2020-0911 / API 30后台启动限制收紧;SplashScreen 迁移窗口的最后一个旧版本多进程、后台拉活这类老招开始失灵
2021-07—Baseline Profiles 被提出应用可自带 profile,不再等云端聚合
2021-1012 / API 31SplashScreen 强制、是 Window 不是 Activity;FrameTimeline 加入自定义闪屏变成负担;能按帧归因 jank
2022-01—官方博客系统介绍 Baseline Profiles,兼容 API 24+周更 App 终于吃得到这份红利
2022-0312L / API 32大屏方向,窗口级适配与启动测量无直接关系,仅记版本
2022-0813 / API 33Baseline Profile 生成可用 API 33+ 设备,不必强求 root生成门槛降了一档
2023-1014 / API 34我这次主要回归机型冷/温/热三态数据都在这台 Pixel 6 上取
2024-0915 / API 35支持 16KB 页表;Play 对 target 35+ 的 16KB 对齐要求已生效,官方页把「不支持则无法发布更新」的截止写成 2027-02-01系统级优化,启动提升 3%~30%
2026现状Macrobenchmark + Baseline Profile + TTFD 成为常规口径我现在的 CI 卡的就是 TTFD P90

表里 16KB 页表那行我特意只放了一句。它带来的 3%~30% 启动提升比我在应用层抠几百毫秒狠得多,可那是系统换页大小、改 MMU 页表项换来的,我这层代码动不了,引它一句只是为了提醒自己:别把应用层那点优化当成全部。原理归内存那篇讲,这里不展开。

哪些老办法到今天失效了,哪些反而回来了

时间线拉出来之后,我顺手把项目里还留着的「祖传优化」过了一遍,分成两堆。

老办法当年为什么管用到今天我怎么处理
给启动 Activity 配 windowBackground 遮白屏系统 StartingWindow 默认白/黑,自己铺张图就不刺眼Android 12 起系统统一画 SplashScreen,自己铺的成了第二层保留 compat 主题给低版本,12+ 交给系统
windowDisablePreview=true想去掉白屏连「系统还在干活」的反馈也去掉,变成假死写进 Rules,出现即打回
独立 SplashActivity + postDelayed 跳首页早期用来做路由和品牌展示与系统闪屏叠成两层,启动不降反增整个删掉,路由挪进 Application 之后的首帧
把 SDK 塞进独立进程减轻主进程主进程看起来轻了多 fork 一次、多跑一遍 Application.onCreate、内存更差、后台更易被杀收回同进程,靠分级和延迟解决
手动 System.gc()早年以为能腾内存ART 下调度由系统管,GC 反而可能吃掉帧预算全删,GC 那层不在这篇展开
安装时全量 AOT / 手动 dex2oat5.0/6.0 换启动快API 24 起不再全量 AOT,手动编译路径被收交给 profile 驱动
取十轮平均值当「启动时间」简单好报被一轮降频拉偏,且掩盖尾部投诉换中位数 + P90

反而回来的那一堆更有意思。5.0 丢掉的 JIT,7.0 原样请了回来,还顺手带了 profile;「按用户实际跑过的路径提前编译」这个思路,2018 年以 Cloud Profiles 的形态出现,2022 年又以 Baseline Profiles 的形态回到应用自己手里;启动窗口那张占位图,现在改叫 placeholder / skeleton,官方迁移文档里明着建议「网络内容没回来时先显示骨架,结构要和真实内容对齐」——换了个名字,还是同一件事;reportFullyDrawn() 这个一直存在但没人用的 API,因为 TTFD 被重新重视,变成了每个首页都要埋的一行;连「把启动期用到的类排在 dex 前面」这种老式布局优化,也借 startup profile 以 dex layout optimization 的名字回来了。Handler.postDelayed 是少数真的退场的,从「延迟初始化主力」缩到「给 setKeepOnScreenCondition 兜个超时上限」这点活。

给 Trae 立的规矩

真开始动手之前,我先花了一晚上把「怎么给 Trae 提需求」定下来。前面那次翻车说到底是口径没对齐,工具没罪,人也累;要是让 Trae 继续在我那套含糊的说法上改代码,改出来的东西只会更整齐地错下去。

第一件是 .traeignore。启动这个主题特别容易被构建产物带偏,APK、mapping、生成的 profile、几十兆的 Perfetto trace,混进上下文里既没用又占位置:

# .traeignore —— 别让构建产物和二进制混进上下文
build/
**/build/
.gradle/
.idea/
*.apk
*.aab
*.keystore
*.jks
app/src/*/generated/baselineProfiles/
**/baseline-prof.txt.bak
*.perfetto-trace
*.trace
captures/
local.properties
secrets.properties

第二件是 Rules。我把项目里哪类文件该被读、哪类绝对不许碰,写成带 globs 的规则,省得每轮提示词里重复一遍:

# .trae/rules/startup_rules.yaml
version: 1
globs:
  include:
    - "app/src/main/**/*.kt"
    - "app/src/main/AndroidManifest.xml"
    - "app/src/main/res/values*/**/*.xml"
    - "baseline-profile/**/*.kt"
    - "build.gradle.kts"
    - "gradle/libs.versions.toml"
    - "scripts/**/*.sh"
    - "scripts/**/*.py"
    - "docs/**/*.md"
    - ".github/workflows/**/*.yml"
  exclude:
    - "**/build/**"
    - "**/generated/**"
    - "**/*.perfetto-trace"
    - "**/mapping.txt"
constraints:
  - 只用平台 API / AndroidX / Gradle 原生能力,零第三方依赖;历史介绍可以提库名,落地代码不许 import。
  - 所有初始化必须收进 StartupGraph,不许新增 ContentProvider,不许在 Application.onCreate 之外留隐式 init。
  - 任何「优化后」的数字必须同时写清进程状态、TTID 还是 TTFD、样本量与分位数;不许只报一个平均值。
  - 出现 android:windowDisablePreview、Handler.postDelayed 做初始化、手动 System.gc() 一律打回并说明原因。
  - 涉及权限申请,先用原生 AlertDialog 弹用途说明,用户确认后再 requestPermissions。
output:
  - 每轮先给一份「现状与证据」,再改代码,不跳过证据直接给结论。
  - 每轮结束列出改动文件路径、验收命令、以及这一轮没解决的问题。

三条 Constraints 我不写在提示词里反复念,固定在 Rules 里:零第三方依赖、初始化一律收进 StartupGraph 且不新增 ContentProvider、任何数字都要带进程状态加口径加样本量。剩下两条是主题专属的禁令和权限边界。写进 Rules 之后,后面六轮提示词明显短了一截,因为不用每轮重声明。

第三件是五段式提示词骨架。我把它存成 docs/prompt-skeleton.md,每轮提示词都往这个模子里填:

【一 · 上下文】
我们是 com.example.health,一个健康类 App,模块 M 承载首页健康记录列表。
当前在优化冷/温/热启动,判定口径见 docs/metrics.md,启动链路见 docs/startup-chain.md。

【二 · 现状与证据】
本轮我 @ 进来的文件是:...
已经测到的数是:...(带设备、口径、样本量、分位数)
trace / logcat 片段是:...
上一轮遗留的问题是:...

【三 · 目标与约束】
本轮只解决一件事:...
4 个可度量的数里,本轮只对 ... 负责,目标 ...
遵守 .trae/rules/startup_rules.yaml 的全部 constraints。

【四 · 期望产出】
按路径列出要新增/修改的文件,每个文件一句话说明用途。
不改的文件也要点名说明为什么不改。

【五 · 验收方式】
给出一条命令或一组数据,说明怎样算本轮通过、怎样算回归。
数字必须带进程状态、口径、样本量与分位数。

第四件,也是最容易漏的,是先把四个数定死。没有固定的尺子,六轮下来每轮都会挑一个对自己有利的数报,最后又回到十月份那条 40.3% 的曲线。翻车之后我用同一套 Macrobenchmark 配置把基线重测了一遍(Pixel 6 / Android 14 / API 34,StartupMode.COLD,CompilationMode.Partial(Require),iterations = 10),看板那条只当线索,不当基线:

数口径优化前基线目标
冷启动 TTID P50StartupTimingMetric,冷态,十轮712ms≤ 520ms
冷启动 TTFD P50reportFullyDrawn() 触发,冷态,十轮1240ms≤ 850ms
冷启动 TTFD P90同上1910ms≤ 1100ms
线上可交互 P90自有埋点,仅 force-stop 冷态,灰度混合机型2180ms≤ 1250ms

四个数里只有第三个能直接对上用户那句「点开要等一下」,前面两个更像过程指标,第四个是线上兜底。我把它们的定义、am force-stop 造态步骤、分位数算法全写进 docs/metrics.md,六轮里每一轮都 @ 它,谁也不许临时换口径。

模式这块我返工过一次,得单独记一笔。我照着 2025 年收藏的教程找 SOLO Builder,界面里翻了三遍没有,只有 SOLO Agent。查了更新记录才确认:2026 年 5 月 SOLO Builder 和 SOLO Coder 已经合并成 SOLO Agent,旧教程里那个分「规划 / 编码」两个入口的说法作废了。我第一版提示词还按 Builder 的写法分了两段、让它先出计划再等确认,结果 Agent 直接把计划和执行一口气做完,我那两段等于白写。后来把六轮全改成一次投喂、五段式自带证据和验收,才顺起来。这个返工不影响代码,但影响了后面每一轮提示词的长度,我写在这里免得下个版本升级又踩一遍。

六轮提示词,我按这个顺序跑完的

六轮不是六次「帮我优化一下启动」。前半段我一行业务代码都不许它改:先把现状扫清楚、把版本行为核准、把口径对齐,再把启动链每一段埋上点、把二十七个 init 排成依赖图,最后才动首帧前面那几个阻塞项。每一轮我都写了在哪个模式、@ 了哪些文件、整段提示词、期望产出哪些文件、我实际返工了什么、用哪条命令或哪组数据验收。模式统一是 SOLO Agent,提示词块里的路径都按项目真实结构写,全选复制就能投。

顺序上我刻意把「不许改代码」放在前两轮。十月份那次翻车就是没体检直接优化,这回先把证据摆够。后面还有六轮——闪屏迁移、Baseline Profile、三态回归、CI 门禁和归档——写在另一篇里,轮次编号接着往下走。

第 1 轮 · 给现状做个体检

模式:SOLO Agent(我一开始误用了纯问答式的 Chat,做成只给建议不改文件,第二轮才切回 Agent 全流程)。

@ 的文件:app/src/main/AndroidManifest.xml、app/src/main/java/com/example/health/MyApplication.kt、app/src/main/java/com/example/health/di/InitCalls.kt、build.gradle.kts、docs/metrics.md。

体检要回答的就一件事:首帧之前到底有哪些代码会跑。我特别强调「只读不改」,因为上一轮的教训还在。

【一 · 上下文】
我们是 com.example.health,健康类 App,模块 M 是首页健康记录列表。
本轮是启动优化流水线的第 1 轮,目标是体检,不是优化。
口径与四个可度量的数见 docs/metrics.md,启动链路见 docs/startup-chain.md。

【二 · 现状与证据】
我 @ 了 AndroidManifest.xml、MyApplication.kt、InitCalls.kt、app/build.gradle.kts。
十月十七号灰度看板报「冷启动降 40.3%」,事后确认口径是 logcat Displayed,
且采样脚本没区分冷/温/热,作废。翻车当晚单次读数:Displayed 698ms、
reportFullyDrawn 1680ms、用户眼睛约 1.7s。

【三 · 目标与约束】
本轮只产出一份现状报告,禁止修改任何 .kt / .xml / .gradle 文件。
遵守 .trae/rules/startup_rules.yaml 全部 constraints。
需要覆盖三件事:
  1) 把 Application.onCreate 及它调用到的所有 init 按调用顺序列全,标出所在线程;
  2) 把 AndroidManifest.xml 里所有 <provider> 列全,带 android:authorities、
     android:initOrder、android:exported,并说明 installContentProviders() 早于
     Application.onCreate 这件事对清单里每一项意味着什么;
  3) 标出哪些 init 是 SDK 通过 ContentProvider 隐式触发的,哪些是显式调用的。
报告里每个结论都要附文件路径和行号,不许写「可能」「大概」。

【四 · 期望产出】
docs/startup-inventory.md:现状清单,含 init 调用表、provider 表、隐式初始化标注。
scripts/scan_providers.py:可重复跑的 Manifest provider 扫描脚本,输出 CSV。
不改其他文件;请在报告末尾点名说明为什么没改 MyApplication.kt。

【五 · 验收方式】
给出运行 scripts/scan_providers.py 的命令与预期输出行数;
给出一条 adb 命令,用来验证报告里「某 provider 早于 Application.onCreate」这个判断。

期望产出:docs/startup-inventory.md(现状清单)、scripts/scan_providers.py(可重复扫描)、docs/startup-inventory.md 末尾一段「本轮未改业务代码」的说明。

我实际返工了什么:第一版提示词漏了「禁止修改任何文件」这句,Trae 挺勤快,顺手把两个看起来没用的 init 从 MyApplication.kt 删了,还改了 InitCalls.kt 的调用顺序。我 git diff 一看不对,整轮作废重跑,把「只读不改」提到第三段第一行,并要求它把没改的文件也点名。第二版报告又漏了 android:initOrder——我本来以为不重要,直到想起 provider 是按它排序串行安装的,才加进要求里。第三版才把二十七个 init、六个 provider 全扫齐,其中三个是 onCreate 里只 return true 的空壳,正是我前面白折腾那次的元凶。报告里还标出三个 SDK 是「Manifest 里声明 provider 隐式启动,Application 里那行 init 其实是第二遍」。

验收:

python3 scripts/scan_providers.py app/src/main/AndroidManifest.xml
# provider_count=6, implicit_init=3, empty_oncreate=3
# authorities,initOrder,exported
# com.example.health.emptyinit,50,false
# com.example.health.pushinit,80,false
# ...
adb shell am force-stop com.example.health
adb logcat -v brief -s ActivityTaskManager StartupTrace | grep -E 'Displayed|attachBaseContext|provider|onCreate'

scan_providers.py 输出 6 行 provider、3 行标成隐式、3 行标成空壳,和我手工数的一致。logcat 里 EmptyInitProvider 的打印确实排在 MyApplication.onCreate 之前,报告里那条判断算验住了。这一轮没动一个字节的业务代码,是我最满意的一轮。

第 2 轮 · 把当前版本的行为核准

模式:SOLO Agent(开联网检索,我要求每条结论带官方文档出处和版本边界)。

@ 的文件:build.gradle.kts、gradle/libs.versions.toml、baseline-profile/build.gradle.kts、app/src/main/res/values/styles.xml、app/src/main/res/values-v31/styles.xml、docs/metrics.md。

体检之后我没敢直接改,先让 Trae 把「我这套构建配置在 2026 年到底会怎样」核准一遍。AGP 版本、targetSdk、编译模式、SplashScreen compat 版本、profile 生成条件,这些年年变,凭记忆写提示词最容易埋雷。

【一 · 上下文】
com.example.health,健康类 App,模块 M 首页健康记录列表。第 2 轮:核准版本行为。
上一轮产出 docs/startup-inventory.md,扫出 27 个 init、6 个 provider(3 个空壳)。
四个可度量的数与口径见 docs/metrics.md。

【二 · 现状与证据】
我 @ 了 app/build.gradle.kts、gradle/libs.versions.toml、baseline-profile/build.gradle.kts、
values/styles.xml、values-v31/styles.xml。
当前待确认的猜测:AGP 8.2 起 R8 会重写 baseline profile 规则;
core-splashscreen 1.0.0 把 Android 12 闪屏行为向下补到 API 23;
installSplashScreen() 必须在 super.onCreate() 之前;
Baseline Profile 采集需要 userdebug/root,API 33+ 可放宽;
reportFullyDrawn() 从不调用时 TTFD 会退回 TTID。

【三 · 目标与约束】
本轮仍然禁止修改任何文件,只产出一份事实表。逐条核准上面每个猜测:
  - 给出官方文档出处(标题即可,不必贴长链接)与生效的版本 / API level 边界;
  - 写明我这套配置(AGP 版本、compileSdk、targetSdk、minSdk)下该结论成不成立;
  - 遇到搜不到确切版本或数字的,标「待核,不写死」,不许用博客里的说法凑数;
  - 额外核准:当前 targetSdk 下 Android 12 SplashScreen 是否强制、
    冷/温启动显示而热启动不显示这一条是否准确、
    TTID 与 TTFD 的官方定义原文口径。
遵守 .trae/rules/startup_rules.yaml 全部 constraints。

【四 · 期望产出】
docs/version-facts.md:一张「结论 / 出处 / 版本边界 / 本项目是否成立 / 证据」表,
末尾单列「待核」清单和「与老教程冲突」清单。
不改任何文件,包括我 @ 进来的那几个 build.gradle.kts。

【五 · 验收方式】
给出一条 gradle 命令,验证 baseline profile 插件确实接在 :app 上;
给出一条命令查看当前 effective AGP 版本;
列出哪几条结论如果写错,会导致后面某一轮代码直接失效。

期望产出:docs/version-facts.md(事实表)、表尾的「待核」清单与「与老教程冲突」清单。

我实际返工了什么:这轮返工最多。Trae 第一版把某篇博客里「Android 9 起强制 SplashScreen」当成事实写进表了,我一眼看出不对——强制是 Android 12 / API 31 的事,API 28 那条是 Cloud Profiles,两件事被串了。我打回并要求只认 developer.android.com 的口径,博客只能进「待核」。第二版又漏了 installSplashScreen() 必须在 super.onCreate() 之前这条时序,我在自己机器上试过,放进 super 之后退场动画不触发,补进表里。核准回来的几条我后来一直用:AGP 8.2 的 R8 重写 profile 规则(方法覆盖率约 +30%、性能约 +15%)、core-splashscreen 1.0.0 backport 到 API 23、installSplashScreen() 的时序、Baseline Profile 采集需 userdebug/root 而 API 33+ 可放宽、以及 TTID/TTFD 那条「从不调用 reportFullyDrawn 就退回 TTID」。还有一条是我自己记错的:旧教程里 SOLO Builder 那一套,2026 年 5 月已经合并成 SOLO Agent,我把它写进「与老教程冲突」清单,免得后面按旧入口组织提示词。

验收:

./gradlew :app:dependencies --configuration releaseRuntimeClasspath | grep -iE 'profileinstaller|baseline'
# +--- androidx.profileinstaller:profileinstaller:1.3.1
# +--- androidx.benchmark:benchmark-macro:1.2.4
./gradlew --version | grep -i 'Gradle\|Android Gradle Plugin'
# Android Gradle Plugin 8.2.2
grep -n 'targetSdk\|compileSdk\|minSdk' app/build.gradle.kts
# compileSdk 34 / targetSdk 34 / minSdk 24

四条命令对下来,minSdk 24 正好是 Baseline Profile 兼容的下界,targetSdk 34 落在 Android 12 强制 SplashScreen 之后,事实表里「本项目是否成立」那一列全打上了勾。这轮依然是零改动,但它决定了后面第 7、8 轮的代码该怎么写。

第 3 轮 · 把测量口径先对齐

模式:SOLO Agent。

@ 的文件:docs/metrics.md、docs/version-facts.md、app/src/main/java/com/example/health/startup/StartupTrace.kt、app/src/main/java/com/example/health/MainActivity.kt、scripts/record_startup.sh、baseline-profile/src/main/java/com/example/health/baseline/StartupBenchmarks.kt。

前两轮全是只读,第三轮才第一次动代码,动的还不是业务,是埋点。目标就一个:让看板以后别再把 Displayed 当「用户能用」。

【一 · 上下文】
com.example.health,健康类 App,模块 M 首页健康记录列表。第 3 轮:测量口径对齐。
docs/startup-inventory.md 已扫清初始化清单,docs/version-facts.md 已核准版本行为。
四个可度量的数(TTID P50 / TTFD P50 / TTFD P90 / 线上可交互 P90)见 docs/metrics.md。

【二 · 现状与证据】
我 @ 了 StartupTrace.kt、MainActivity.kt、StartupBenchmarks.kt、record_startup.sh。
现状:埋点字段 startup_ms 取 onWindowFocusChanged,口径实为 TTID 且混了三种进程态;
采样脚本循环 am start -W 抠 TotalTime 求平均,从不解析 LaunchState;
看板 704ms,reportFullyDrawn 单次 1680ms,两者差 976ms。
官方口径:TTFD 在调用 ComponentActivity.reportFullyDrawn() 后报告,从不调用则退回 TTID;
不能在第一帧绘制之前调用,否则 TTID 与 TTFD 被报成同一个值。

【三 · 目标与约束】
本轮只改埋点与采样,不改任何初始化代码、不动 UI 布局。要求:
  1) 建立口径字典:项目里每一处「启动时间」上报点,标注它是 TTID / TTFD / 混态,
     以及起算点、是否区分进程状态;
  2) 改造采样脚本:每轮前 am force-stop 造冷态,解析 LaunchState 只留 COLD 样本,
     温/热单独存字段,不许混算平均;
  3) 在 MainActivity 里把 reportFullyDrawn() 埋到「列表第一条数据绑定完成并可点击」之后,
     且保证一定晚于首帧;首页有本地库查询、配置拉取、埋点就绪三个后台任务,
     用 getFullyDrawnReporter() 收口,不要自己拿计数器凑;
  4) 上报字段加 state 标签(COLD/WARM/HOT)与口径标签(TTID/TTFD)。
遵守 .trae/rules/startup_rules.yaml 全部 constraints,尤其是「不许只报平均值」。

【四 · 期望产出】
docs/metrics.md:更新口径字典与四个数的定义,写明分位数算法。
app/.../startup/StartupTrace.kt:加 state 与口径标签、首帧标记。
app/.../MainActivity.kt:reportFullyDrawn 与 FullyDrawnReporter 收口。
scripts/record_startup.sh:force-stop 造态 + LaunchState 过滤 + 三态分列输出。
baseline-profile/.../StartupBenchmarks.kt:不动,点名说明为什么本轮不改它。

【五 · 验收方式】
给出 logcat 里 Fully drawn 那行的预期片段与它应当落在的时间区间;
给出一条命令跑十轮冷启动并输出 TTID/TTFD 的 min/median/max/P90;
说明如果 state 标签里出现 WARM/HOT 混入,判据是什么。

期望产出:docs/metrics.md(口径字典更新)、StartupTrace.kt(state 与口径标签)、MainActivity.kt(reportFullyDrawn + FullyDrawnReporter)、scripts/record_startup.sh(造态与过滤);StartupBenchmarks.kt 明确不改并说明理由。

我实际返工了什么:第一版把 onWindowFocusChanged 直接改名成 ttfd_ms 就交差了,窗口获焦跟列表第一条能点是两回事,我打回,要求必须落到 submitList 的提交回调。第二版 reportFullyDrawn() 挂在 onResume 末尾,比首帧还早,logcat 里 TTID 和 TTFD 被报成同一个 698ms,正好撞上官方文档那条警告,又打回一次。第三版用 getFullyDrawnReporter() 给三个后台任务各注册一个 reporter,全 release() 才报,这才对。采样脚本也有个坑:Trae 一开始用 am kill 造冷态,我改成 am force-stop——am kill 留着 Task 记录,出来的是温启动。还有个小返工,脚本第一版把 LaunchState: COLD 那行的大小写写死了,某些系统版本输出是 LaunchState: COLD 带别的前缀,改成不区分大小写匹配才稳。

验收:

bash scripts/record_startup.sh 10
# state=COLD n=10
# TTID min=682 median=712 max=801 p90=772
# TTFD min=1104 median=1240 max=1910 p90=1842
# WARM/HOT samples dropped: 3 (kept in warm_hot.csv)
adb logcat -v brief -s ActivityManager | grep 'Fully drawn'
# I/ActivityManager: Fully drawn com.example.health/.MainActivity: +1s240ms
python3 -c "import json;d=json.load(open('out/startup_10.json'));print(sorted(d['state'].keys()))"
# ['COLD']

十轮里 dropped 掉 3 个非冷态样本,单独存进 warm_hot.csv 没丢;Fully drawn 落在 1s240ms,比 Displayed 的 712ms 晚 528ms,和翻车当晚那个 976ms 的落差同向。口径对齐之后,四个数的基线才算真的立住了——后面所有「优化后」都从这组数往下比。

第 4 轮 · 把启动链路每一段都埋上点

模式:SOLO Agent。

@ 的文件:app/src/main/java/com/example/health/MyApplication.kt、app/src/main/java/com/example/health/MainActivity.kt、app/src/main/java/com/example/health/startup/StartupTrace.kt、docs/startup-chain.md、docs/metrics.md、scripts/record_startup.sh。

口径立住之后,下一个问题是「那 528ms 的空档到底花在哪」。光看 TTID 和 TTFD 两个总数不够,得把启动链每一段的耗时摊开。这轮只加埋点,不动任何初始化逻辑。

【一 · 上下文】
com.example.health,健康类 App,模块 M 首页健康记录列表。第 4 轮:启动链路埋点。
第 3 轮已对齐口径:TTID P50 712ms、TTFD P50 1240ms,两者差 528ms。
启动链路时序见 docs/startup-chain.md,四个数的定义见 docs/metrics.md。

【二 · 现状与证据】
我 @ 了 MyApplication.kt、MainActivity.kt、StartupTrace.kt、record_startup.sh。
目前只有 StartupTrace.mark("first_frame_predraw") 和 mark("fully_drawn") 两个点,
中间 attachBaseContext、ContentProvider 安装、Application.onCreate 进出、
Activity 三个生命周期回调、setContentView、首帧 doFrame 全部没有计时。
Perfetto 采集脚本已能录到 android.os.Trace 的 section,但项目里几乎没打。

【三 · 目标与约束】
本轮只加埋点,禁止改动任何初始化顺序、禁止搬走任何 init、禁止改 UI 布局。要求:
  1) 在启动链关键节点成对打点:Application.attachBaseContext 进出、
     installContentProviders 前后(用 ContentProvider 的 onCreate 首行近似)、
     Application.onCreate 进出、Activity.onCreate/onStart/onResume、
     ViewRootImpl 首帧 doFrame 前后、reportFullyDrawn 调用点;
  2) 用平台 android.os.Trace.beginSection / endSection,让 Perfetto 能直接看见,
     不要用 Log.d 或 System.currentTimeMillis 自己算;埋点名称统一 startup_ 前缀;
  3) 只在 debug 与 benchmark 构建生效,release 全部编译期关掉,不许带进线上包;
  4) 输出一份「节点 / 起止 / 归属线程 / 对应 TTID 还是 TTFD」的埋点表;
  5) 给一个解析脚本,从 Perfetto 导出的 trace 里按 section 名算出每段耗时与
     TTID、TTFD 的对照,输出 CSV。
遵守 .trae/rules/startup_rules.yaml 全部 constraints。

【四 · 期望产出】
app/.../startup/StartupTrace.kt:扩展成对打点与 debug 开关。
app/.../startup/StartupMarkers.kt:节点常量与各生命周期调用点。
app/.../MyApplication.kt、MainActivity.kt:只插入成对打点,其余不动。
scripts/parse_startup_trace.py:解析 Perfetto trace,按 section 输出每段耗时 CSV。
docs/trace-markers.md:埋点表,写明每个点对应启动链哪一步。
不改 StartupGraph.kt(还没建),不改 record_startup.sh,点名说明原因。

【五 · 验收方式】
给出一条 Perfetto 采集命令、一条按 section 名查耗时的查询;
给出一段预期 CSV 输出,列出 attachBaseContext / providers / application_oncreate /
activity_lifecycle / first_frame / fully_drawn 六段的毫秒数;
说明如果某一段在 trace 里缺失或顺序颠倒,判据是什么。

期望产出:StartupTrace.kt(成对打点 + debug 开关)、StartupMarkers.kt(节点常量与调用点)、MyApplication.kt / MainActivity.kt(仅插入打点)、scripts/parse_startup_trace.py(trace 解析)、docs/trace-markers.md(埋点表);StartupGraph.kt 与 record_startup.sh 明确不改。

我实际返工了什么:第一版 Trae 用 Log.d 加 System.currentTimeMillis() 打了一排日志,Perfetto 里一个 section 都看不见,而且 logcat 时间戳精度只到毫秒、还受缓冲影响,直接打回,要求换成 android.os.Trace。第二版漏了 ContentProvider 那段——埋点表里 installContentProviders 是空的,可我第 1 轮就查出三个空壳 provider 在这段抢时间,正好是最该量的地方,补上用每个 provider onCreate 首行打点近似。第三版把埋点在 release 也开着,Trace.beginSection 虽然开销小,但线上包不该带,加 `BuildConfig.DEBUGStartupConfig.BENCHMARK开关。解析脚本也返工过一次:第一版按 section 名硬编码顺序求和,遇到 ProfileInstaller 在后台线程插进来的 section 就把耗时算串了,改成按 slice 的ts/dur` 排序取相邻配对才对。

验收:

bash scripts/record_startup.sh --perfetto 1
# wrote out/startup_cold.perfetto-trace (12.4 MB, 3.2s)
python3 scripts/parse_startup_trace.py out/startup_cold.perfetto-trace
# section,start_ms,dur_ms,thread
# startup_attach_base_context,0.0,3.1,main
# startup_install_providers,3.1,96.4,main
# startup_application_oncreate,99.5,214.8,main
# startup_activity_lifecycle,314.3,168.2,main
# startup_first_frame,482.5,229.5,main
# startup_fully_drawn,712.0,528.0,main
# TTID=712ms  TTFD=1240ms  gap=528ms

六段都出来了,顺序和 docs/startup-chain.md 里那张时序图一致。最扎眼的是 startup_install_providers 96.4ms——三个空壳 provider 加上两个真干活的,光这一段就快一百毫秒,而且它排在 Application.onCreate 前面。这一轮没动代码逻辑,但它把第 6 轮该搬谁、不该搬谁,全标好了。

第 5 轮 · 把二十七个 init 排成一张依赖图

模式:SOLO Agent。

@ 的文件:docs/startup-inventory.md、docs/trace-markers.md、app/src/main/java/com/example/health/MyApplication.kt、app/src/main/java/com/example/health/di/InitCalls.kt、scripts/parse_startup_trace.py、docs/metrics.md。

体检扫出二十七个 init,trace 量出 Application.onCreate 一段 214.8ms。这轮要把二十七个调用从一串书写顺序,变成一张能排序、能分级、能查环的图。

【一 · 上下文】
com.example.health,健康类 App,模块 M 首页健康记录列表。第 5 轮:初始化依赖拓扑与分级。
第 1 轮 docs/startup-inventory.md 扫出 27 个 init、6 个 provider(3 个空壳);
第 4 轮 trace 显示 Application.onCreate 段 214.8ms,install_providers 段 96.4ms。
四个可度量的数见 docs/metrics.md。

【二 · 现状与证据】
我 @ 了 startup-inventory.md、trace-markers.md、MyApplication.kt、InitCalls.kt。
现状:27 个 init 全在 MyApplication.onCreate 里按当年接入顺序同步排开,
真实依赖(数据库先于 Repository、配置先于网络、账号先于推送)只体现在书写顺序里,
代码看不出来;没有环检测,没有分级,谁挡首帧只能靠猜。
Jetpack App Startup 的思路是 Initializer + dependencies() 做一次拓扑排序,
本轮只借原理,落地用原生 Kotlin 自己实现,不引入任何库。

【三 · 目标与约束】
本轮产出 StartupGraph 与分级框架,并把现有 init 迁进去。要求:
  1) 用原生 Kotlin 实现 StartupGraph:注册 Initializer(id、dependencies、等级、block),
     Kahn 拓扑排序,输出可执行顺序;
  2) 环检测要打印出完整的环链(A -> B -> C -> A),不许只抛个异常;
     缺失依赖、重复 id、自依赖也要分别报错;
  3) 四级分级:SYNC(首帧 inflate 必需,主线程)、ASYNC(启动即投 IO 线程池)、
     DEFERRED(首帧后主线程空闲)、LAZY(首次用到才建);
     DEFERRED 用 MessageQueue.IdleHandler,返回 false 只回调一次,
     ASYNC 用平台 Executors,不许用 Handler.postDelayed;
  4) 每个 Initializer 迁进来时,在注释里写清它属于哪一档、判据是什么;
     分档判据写进 docs/init-tiers.md:只有「首帧 inflate 缺了就崩」才进 SYNC;
  5) 给一份单测:正常拓扑、成环、缺失依赖、分级执行顺序各一条;
  6) MyApplication.onCreate 改成只调 StartupGraph.execute(),不再有裸 init 调用。
遵守 .trae/rules/startup_rules.yaml 全部 constraints:
零第三方依赖、不新增 ContentProvider、初始化全部收进 StartupGraph。

【四 · 期望产出】
app/.../startup/Initializer.kt:接口与四档枚举。
app/.../startup/StartupGraph.kt:Kahn 排序、环检测、分级执行、dump()。
app/.../startup/InitCatalog.kt:27 个 init 的注册与分档注释。
app/.../MyApplication.kt:只留 StartupGraph.execute()。
app/src/test/.../StartupGraphTest.kt:四条单测。
docs/init-tiers.md:分档判据与迁移对照表。
不改 AndroidManifest.xml(不新增 provider),点名说明。

【五 · 验收方式】
给出跑单测的 gradle 命令与四条测试的预期结果;
给出 StartupGraph.dump() 的预期输出片段,标明 SYNC 档有几个节点、顺序如何;
说明如果某个环被漏检,会导致什么现象。

期望产出:Initializer.kt(接口与四档枚举)、StartupGraph.kt(Kahn 排序 + 环检测 + 分级执行)、InitCatalog.kt(27 个 init 注册与分档注释)、MyApplication.kt(只留 StartupGraph.execute())、StartupGraphTest.kt(四条单测)、docs/init-tiers.md(分档判据);AndroidManifest.xml 明确不改。

我实际返工了什么:第一版 Trae 直接 import androidx.startup.Initializer,我打回——App Startup 是 AndroidX 不假,但这轮我要的是自己那套拓扑排序和四级分级,引它就等于把分级能力交出去,而且它把所有组件收进一个 ContentProvider 的做法跟「不新增 provider」那条 Constraints 也对不上。第二版环检测只 throw IllegalStateException("cycle"),不给链,我让它打印完整环链,因为真出问题时我得知道是哪两个 init 互相等。第三版把 PushInitializer 标成 SYNC,理由是「推送要尽早」,可依赖图里它只被配置依赖、首帧根本不等它,按判据改成了 DEFERRED。第四版 IdleHandler 返回了 true,主线程一空就反复回调、把 deferred 任务跑了好几遍,改成 false。还有一次小返工:Kahn 排序在入度为 0 的节点多于一个时输出顺序不稳定,我要求按注册序做确定性排序,不然每次 dump() 输出都变,没法做回归对比。

验收:

./gradlew :app:testDebugUnitTest --tests '*StartupGraphTest*'
# StartupGraphTest > topologicalOrder PASSED
# StartupGraphTest > cycleReportsFullChain PASSED
# StartupGraphTest > missingDependencyFails PASSED
# StartupGraphTest > tierExecutionOrder PASSED
# 4 tests completed, 0 failed
adb shell am force-stop com.example.health
adb logcat -v brief -s StartupGraph | head -20
# SYNC(6): Core -> Database -> Config -> Repository -> Network -> ViewModelBind
# ASYNC(4): CacheWarm, ...
# DEFERRED(9): Push, Tracking, CrashReport, ...
# LAZY(8): ImageLoader, ReportExport, ...

单测四条全过,dump() 里 SYNC 只剩六个节点——二十七个里二十一个被挪出了首帧之前。成环那条单测故意造了 Repository -> Database -> Repository,打印出的环链完整,不是一句干巴巴的异常。这轮结束,MyApplication.onCreate 从二十七行裸调用缩成一行 StartupGraph.execute()。

第 6 轮 · 把首帧之前的阻塞项一个个搬走

模式:SOLO Agent。

@ 的文件:app/src/main/java/com/example/health/startup/StartupGraph.kt、app/src/main/java/com/example/health/startup/InitCatalog.kt、app/src/main/java/com/example/health/MyApplication.kt、scripts/parse_startup_trace.py、out/startup_cold.perfetto-trace(解析结果 CSV)、docs/metrics.md。

第 5 轮把框架搭好了,第 4 轮的 trace 也量出了每段耗时,这轮才真正开始搬。原则写死在提示词里:一次只搬一类,每一项都能单独回归。

【一 · 上下文】
com.example.health,健康类 App,模块 M 首页健康记录列表。第 6 轮:首帧前阻塞项搬迁。
StartupGraph 已落地(SYNC 6 / ASYNC 4 / DEFERRED 9 / LAZY 8),
第 4 轮 trace:install_providers 96.4ms、application_oncreate 214.8ms、
activity_lifecycle 168.2ms、first_frame 229.5ms,TTFD 与 TTID 差 528ms。
四个可度量的数见 docs/metrics.md,本轮只对 TTID P50 与 TTFD P50 负责。

【二 · 现状与证据】
我 @ 了 StartupGraph.kt、InitCatalog.kt、MyApplication.kt、parse_startup_trace.py
与解析出的 CSV。StrictMode 第一轮日志里还有主线程磁盘读与网络调用没处理。
判据只有一条:首帧 inflate 缺了就直接崩的,才留在 SYNC。

【三 · 目标与约束】
按 trace 里耗时从大到小,逐项判断能否搬出首帧之前,每项都要写理由:
  1) 三个空壳 ContentProvider:不新增 provider,改用 InitCatalog 里的显式
     Initializer 替掉,并把 AndroidManifest.xml 里对应声明删掉(本轮允许改 Manifest,
     但只删不增);
  2) SDK 在 ContentProvider.onCreate 里同步读 SharedPreferences 的问题:
     把读取挪到 ASYNC 档,首屏要用的少量配置用内存默认值先顶,回来再刷新;
  3) StrictMode 抓到的主线程磁盘/网络:逐个归到 ASYNC 或 DEFERRED;
  4) 任何一项搬动后,若首页缺数据会崩或白屏,必须当场回退并写进报告,
     不许为了数字硬搬;
  5) 延迟一律用 IdleHandler,不许用 Handler.postDelayed;
  6) 每项改动单独一次提交粒度,报告里逐项列「搬前耗时 / 搬后耗时 / 回归结果」。
遵守 .trae/rules/startup_rules.yaml 全部 constraints,尤其不许手动 System.gc()、
不许把平均值当结论。

【四 · 期望产出】
app/.../startup/InitCatalog.kt:分档调整与替掉空壳 provider 的显式注册。
app/src/main/AndroidManifest.xml:只删三个空壳 provider 声明。
app/.../MyApplication.kt:debug 下挂 StrictMode(平台 API)。
docs/init-moves.md:逐项搬迁记录,含搬前/搬后耗时与回退说明。
out/startup_after_move.perfetto-trace 与对应 CSV:本轮验收数据。
不改 MainActivity.kt 的 reportFullyDrawn 时机,点名说明。

【五 · 验收方式】
给出 StrictMode 的 logcat 片段与「修复后同类日志归零」的判据;
给出搬移前后六段耗时的对照表;
给出十轮冷启动 Macrobenchmark 的 TTID/TTFD min/median/max/P90;
说明若某一轮出现 TTFD P90 回归,怎样定位到具体是哪个 init 被搬晚了。

期望产出:InitCatalog.kt(分档调整 + 替掉空壳 provider)、AndroidManifest.xml(只删三个空壳声明)、MyApplication.kt(debug 下挂 StrictMode)、docs/init-moves.md(逐项搬迁记录)、out/startup_after_move.perfetto-trace 与 CSV;MainActivity.kt 明确不改。

我实际返工了什么:第一版把 DatabaseInitializer 也搬去了 ASYNC,首页 Room 还没建好就查,冷启动直接崩,当场回退,docs/init-moves.md 里第一条记的就是这次失败。第二版用 Handler.postDelayed({ initPush() }, 1500) 做延迟,我在 Redmi Note 11 上量到首帧偶尔要 1.6 秒,这个 1.5 秒的延时正好卡在 doFrame 前面醒来抢主线程,TTID 反而抖,改成 IdleHandler。第三版 StrictMode 一开,logcat 里刷出十几条,最离谱的是某 SDK 在 provider 的 onCreate 里同步读了三个 SharedPreferences,那段页缓存还没热,一次读几十毫秒——正是第 1 轮标出的隐式初始化。第四版有一处真回归:把埋点 SDK 挪到 DEFERRED 之后,首屏那条「数据已加载」的标记晚了一帧,Redmi Note 11 上 TTFD P90 反而涨了 60ms。我没把它藏起来,写进报告并把那个 SDK 单独调回 ASYNC 档才收住。三个空壳 provider 删掉之后,startup_install_providers 从 96.4ms 掉到 31.2ms,是这轮最干净的一笔。

验收:

adb logcat -v brief -s StrictMode | grep -c 'policy=' 
# 14   -> 修复后 0
python3 scripts/parse_startup_trace.py out/startup_after_move.perfetto-trace
# section,dur_ms(before),dur_ms(after)
# startup_install_providers,96.4,31.2
# startup_application_oncreate,214.8,88.6
# startup_activity_lifecycle,168.2,161.9
# startup_first_frame,229.5,216.3
# TTID=712->498ms  TTFD=1240->806ms
bash scripts/record_startup.sh 10
# state=COLD n=10  TTID median=498 p90=549  TTFD median=806 p90=1088

StrictMode 同类日志归零,六段里前面两段降得最明显,TTID 从 712 到 498、TTFD 从 1240 到 806。四个数里两个已经进目标区间,但 TTFD P90 1088ms 只是压着 1100ms 的线,Redmi 上那次 60ms 回归提醒我,这还没到能收尾的时候。

这六轮跑完,手上留下的是什么

docs/metrics.md 里四个数的定义一次都没改过,StartupTrace 的六段打点能在 Perfetto 里对上,docs/version-facts.md 把 target 34 下哪些行为成立、哪些不成立逐条标了,二十七个 init 排出来的那张依赖图能 dump() 成固定顺序做 diff。这些是前半段真正的产出,比那张 40.3% 的曲线有用得多。

数字上,Pixel 6 冷态十轮 TTID 中位数从 712 走到 498,TTFD 中位数从 1240 走到 806,StrictMode 同类日志归零。可 TTFD P90 是 1088ms,门槛 1100ms,压着线;Redmi Note 11 上把埋点 SDK 挪到 DEFERRED 之后还回归过 60ms,调回 ASYNC 才收住。两个进目标区间,两个没有,我不打算把没进的那两个藏起来。

StartupGraph.kt 的完整实现和后面六轮的改造放在另一篇,这里只贴测量这半边落地的四个文件。

这半段落地的文件

下面四块是前半段真正留在仓库里的测量侧代码,每块标了路径和用途。全部用平台 API、AndroidX 或 Gradle 原生能力,没有引第三方库;我这边的版本是 AGP 8.2.2、compileSdk 34、targetSdk 34、minSdk 24,换个版本未必一模一样。

app/src/main/java/com/example/health/startup/StartupTrace.kt —— 成对打点,统一 startup_ 前缀,让 Perfetto 直接看得见;debug 与 benchmark 之外全部关掉。

package com.example.health.startup

import android.os.Trace
import com.example.health.BuildConfig

object StartupTrace {
    @JvmStatic val enabled: Boolean
        get() = BuildConfig.DEBUG || StartupConfig.BENCHMARK

    inline fun section(name: String, block: () -> Unit) {
        if (!enabled) { block(); return }
        Trace.beginSection("startup_$name")
        try { block() } finally { Trace.endSection() }
    }

    @JvmStatic fun mark(name: String) {
        if (!enabled) return
        Trace.beginSection("startup_mark_$name")
        Trace.endSection()
    }
}

baseline-profile/src/main/java/com/example/health/baseline/StartupBenchmarks.kt —— 四档 CompilationMode 对照,Require 是硬要求,profile 没生效时直接报错。

package com.example.health.baseline

import androidx.benchmark.macro.CompilationMode
import androidx.benchmark.macro.StartupMode
import androidx.benchmark.macro.StartupTimingMetric
import androidx.benchmark.macro.junit4.MacrobenchmarkRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(AndroidJUnit4::class)
class StartupBenchmarks {
    @get:Rule val rule = MacrobenchmarkRule()

    @Test fun none() = benchmark(CompilationMode.None())
    @Test fun requireProfile() =
        benchmark(CompilationMode.Partial(baselineProfileMode = androidx.benchmark.macro.BaselineProfileMode.Require))
    @Test fun partialWithJit() = benchmark(
        CompilationMode.Partial(
            baselineProfileMode = androidx.benchmark.macro.BaselineProfileMode.Disable,
            warmupIteration = 3
        )
    )
    @Test fun full() = benchmark(CompilationMode.Full())

    private fun benchmark(mode: CompilationMode) = rule.measureRepeated(
        packageName = "com.example.health",
        metrics = listOf(StartupTimingMetric()),
        compilationMode = mode,
        startupMode = StartupMode.COLD,
        iterations = 10,
        setupBlock = { pressHome() }
    ) {
        startActivityAndWait()
    }
}

scripts/record_startup.sh —— 我机器上那条 Perfetto 采集链,force-stop 造冷态、抓 trace、拉回来、按 section 导出 CSV。

#!/usr/bin/env bash
set -euo pipefail
PKG=com.example.health
OUT=out/startup_cold.perfetto-trace
adb shell am force-stop "$PKG"
adb shell "perfetto -o /data/misc/perfetto-traces/s.trace -t 4s -b 32mb \
  sched freq idle am wm gfx view binder_driver dalvik --app $PKG" &
sleep 0.3
adb shell am start -W -n "$PKG/.MainActivity" | tee out/am_start_W.txt
wait
adb pull /data/misc/perfetto-traces/s.trace "$OUT"
trace_processor_shell -q /dev/stdin "$OUT" <<'SQL' > out/slices.csv
SELECT s.name, s.ts, s.dur, t.name AS thread
FROM slice s JOIN thread_track tt ON s.track_id = tt.id
JOIN thread t ON tt.utid = t.utid
WHERE s.name LIKE 'startup_%';
SQL
python3 scripts/parse_startup_trace.py out/slices.csv | tee out/startup_segments.csv

scripts/parse_startup_trace.py —— 把上面导出的 slices 按时间排好,算每段耗时与 TTID/TTFD 的对照。

#!/usr/bin/env python3
import csv
import sys

SECTIONS = [
    "startup_attach_base_context", "startup_install_providers",
    "startup_application_oncreate", "startup_activity_lifecycle",
    "startup_first_frame", "startup_fully_drawn",
]

def main(path: str) -> None:
    rows = sorted(csv.DictReader(open(path, encoding="utf-8")),
                  key=lambda r: float(r["ts"]))
    base = float(rows[0]["ts"])
    writer = csv.writer(sys.stdout)
    writer.writerow(["section", "start_ms", "dur_ms", "thread"])
    for r in rows:
        if r["name"] in SECTIONS:
            writer.writerow([r["name"],
                             round((float(r["ts"]) - base) / 1e6, 1),
                             round(float(r["dur"]) / 1e6, 1),
                             r["thread"]])

if __name__ == "__main__":
    main(sys.argv[1])

踩过的坑,按报错排(测量这半边)

前六轮真正花时间的不是写代码,是这些现象第一次出现时我把它认成了别的东西。

现象根因修复
看板降 40.3%,用户仍说点开要等混了冷/温/热三态,且把 Displayed 当可交互force-stop 造态 + reportFullyDrawn 上报 TTFD
Displayed 698ms 与 Fully drawn 1680ms 差 976msTTID 与 TTFD 是两个口径双口径分列上报,看板不再只留一个字段
am start -W 十轮数据忽大忽小进程没死,热启动混进冷启动解析 LaunchState,非 COLD 样本单独存放
am kill 造不出冷态只杀后台进程,Task 记录还在改用 am force-stop
按 back 与按 home 之后启动耗时差几倍前者 finish() 掉 Activity 需重建,后者只 onStop两支分开造温/热,各自校验
reportFullyDrawn() 后 TTID 与 TTFD 报成同一个值调用早于首帧绘制挪到 submitList 的提交回调里
新用户首页无数据时 TTFD 直接退回 TTID空列表没进 submitList 回调分支空列表也补一次 reportFullyDrawn()
Redmi 上 TTFD P90 回归 60ms埋点 SDK 挪到 DEFERRED 后首屏数据晚一帧调回 ASYNC 档,写进回归记录
十轮里两轮冷态读数突然变快lmkd 回收进程,态跳成温启动采 oom_score_adj,态跳变单独存放
平均值比中位数好看一大截一轮降频把均值拉偏,还掩盖尾部投诉一律 P50/P90,不报平均值

表里前三条是同一场翻车的三个侧面,我花了两轮才把它们拆开。Displayed 那行自动就有,Fully drawn 那行得代码里调了才有,很多项目从头到尾只看得到第一行,看板于是永远停在 TTID 上——十月份那条 40.3% 就是这么来的。

命令速查

测量这半边的 adb 命令,多半不是「记不记得住」,是输出里那几行到底该看哪个字段。

adb shell am force-stop com.example.health          # 冷:进程与 Task 全清
adb shell am kill com.example.health                # 温:只杀后台进程,Task 记录留着
adb shell am start -W -n com.example.health/.MainActivity
# Status: ok
# LaunchState: COLD
# ThisTime: 712  TotalTime: 712  WaitTime: 719
# 判读:LaunchState 不是 COLD 就丢掉这一轮;ThisTime 与 TotalTime 不等,
#       说明中间有转发 Activity,两者别混着报
adb shell "cat /proc/$(adb shell pidof com.example.health)/oom_score_adj"
# 0
# 判读:0 是前台;>=900 说明已进缓存进程,随时可能被 lmkd 收掉,
#       那种状态下的下一次启动已经不是我指定的态
I/ActivityTaskManager: Displayed com.example.health/.MainActivity: +712ms
I/ActivityManager: Fully drawn com.example.health/.MainActivity: +1s240ms
# 判读:前者是 TTID,系统在第一帧打;后者是 TTFD,得我自己埋;
#       两者差 528ms 就是首帧之后到列表可点之间的空档
adb shell dumpsys gfxinfo com.example.health framestats
# jankType: AppDeadlineMissed / SurfaceFlingerDeadlineMissed / None
# 判读:标 AppDeadlineMissed 是 App 自己的 measure/layout 超了,
#       别顺手把锅记到 SurfaceFlinger 头上

两组里第二组最容易被跳过。am start -W 的 LaunchState 不是 COLD 就得把那一轮丢掉,Fully drawn 则要代码里调过 reportFullyDrawn() 才会打——十轮数据忽大忽小,多半不是机器不稳,是态没造对。

还能往下挖的地方

前半段收尾时列过一张单子,这里只留跟尺子有关的几条,按投入产出比排。

方向解决什么代价
三态线上分桶上报让看板不再把温/热样本混进冷态埋点字段扩展,历史数据要重算
FrameTimeline 按帧归因把 TTID 到 TTFD 之间拆成一帧一帧的账trace 体积大,SQL 查询要跟着版本维护
StrictMode 常态化进 CI主线程磁盘/网络回潮能当场拦住日志噪声,得维护一份 SDK 白名单
升级后首次启动旧 profile 与新版代码不匹配的头几轮需要 ProfileInstaller 写入时机的 A/B 记录
Cloud Profiles 与自有 profile 合并验证两类 profile 叠加后的真实收益Play 侧聚合不可控,观察周期以周计

这几条都不直接降毫秒数,做的是让下一次优化别再测错。剩下几条属于动手改造,写在另一篇。

后来

十一月初把 docs/metrics.md 打印出来贴在工位隔板上,同事路过瞄了一眼问这是什么,我说是一把尺子的说明书。他没再问。那台 Redmi Note 11 还连着,TTFD P90 1540ms 那条我圈了出来,等后半段再动它。