HarmonyOS开发：启动监控与启动耗时分析

📌 核心要点：没有度量就没有优化——从关键节点埋点、耗时采集、可视化分析到回归检测，构建完整的启动监控体系，让启动性能"看得见、量得准、管得住"。

一、背景与动机

你有没有遇到过这样的场景：开发时启动速度飞快，上线后用户却抱怨"太慢了"？或者某次发版后启动速度悄悄变慢了，但没人注意到，直到用户差评如潮才发现？

这就是缺乏启动监控的后果。启动优化不是一锤子买卖，而是一个持续的过程——你今天优化了，明天一个新需求可能就把优化成果吃掉了。如果没有监控体系，你就像一个没有仪表盘的司机，完全凭感觉开车，迟早要出问题。

本文将从启动耗时采集、关键节点埋点、耗时可视化、对比分析、回归检测、监控面板六个维度，全面讲解如何构建HarmonyOS应用的启动监控体系。记住一句话：没有度量就没有优化，没有监控就没有保障。

二、核心原理

2.1 启动耗时采集方案

启动耗时采集的核心是在启动流程的关键节点打上时间戳，然后计算相邻节点之间的间隔：

flowchart TD
    classDef nodeStyle fill:#E8EAF6,stroke:#283593,stroke-width:2px,color:#1A237E
    classDef metricStyle fill:#FFF3E0,stroke:#E65100,stroke-width:2px,color:#BF360C
    classDef alertStyle fill:#FFCDD2,stroke:#C62828,stroke-width:2px,color:#B71C1C
    classDef healthyStyle fill:#C8E6C9,stroke:#2E7D32,stroke-width:2px,color:#1B5E20

    A[进程创建\nT0]:::nodeStyle --> B[Application.onCreate\nT1]:::nodeStyle
    B --> C[AbilityStage.onCreate\nT2]:::nodeStyle
    C --> D[Ability.onCreate\nT3]:::nodeStyle
    D --> E[WindowStage创建\nT4]:::nodeStyle
    E --> F[内容加载完成\nT5]:::nodeStyle
    F --> G[首帧渲染\nT6]:::nodeStyle
    G --> H[onForeground\nT7]:::nodeStyle

    B -.-> M1[应用初始化耗时\nT1-T0]:::metricStyle
    C -.-> M2[Stage初始化耗时\nT2-T1]:::metricStyle
    D -.-> M3[Ability初始化耗时\nT3-T2]:::metricStyle
    F -.-> M4[内容加载耗时\nT5-T4]:::metricStyle
    G -.-> M5[首帧渲染耗时\nT6-T5]:::metricStyle
    H -.-> M6[总启动耗时\nT7-T0]:::metricStyle

    M6 --> I{总耗时 > 2秒?}:::alertStyle
    I -->|是| J[⚠️ 触发告警\n记录慢启动日志]:::alertStyle
    I -->|否| K[✅ 正常启动\n记录性能数据]:::healthyStyle

    J --> L[上传到监控平台]:::metricStyle
    K --> L

2.2 关键节点埋点设计

三、代码实战

3.1 基础示例：启动耗时采集方案

首先实现一个精确的启动耗时采集器，在各关键节点自动打点：

// StartupTracer.ets - 启动耗时采集器
import hilog from '@ohos.hilog';

const TAG = 'StartupTracer';
const DOMAIN = 0x0001;

/**
 * 启动阶段枚举
 */
export enum StartupNode {
  PROCESS_CREATE = 'process_create',
  APP_ON_CREATE = 'app_on_create',
  STAGE_ON_CREATE = 'stage_on_create',
  ABILITY_ON_CREATE = 'ability_on_create',
  WINDOW_STAGE_CREATE = 'window_stage_create',
  CONTENT_LOADED = 'content_loaded',
  FIRST_FRAME = 'first_frame',
  ON_FOREGROUND = 'on_foreground',
}

/**
 * 单次启动的耗时记录
 */
interface StartupRecord {
  traceId: string;                          // 追踪ID（唯一标识一次启动）
  launchType: 'cold' | 'warm' | 'hot';     // 启动类型
  timestamps: Map<string, number>;          // 各节点时间戳
  durations: Map<string, number>;           // 各阶段耗时
  totalDuration: number;                    // 总耗时
  deviceInfo: DeviceInfo;                   // 设备信息
  appVersion: string;                       // 应用版本
  timestamp: number;                        // 记录时间
}

/**
 * 设备信息
 */
interface DeviceInfo {
  model: string;          // 设备型号
  osVersion: string;      // 系统版本
  memory: number;         // 内存大小(MB)
  cpuCores: number;       // CPU核心数
  networkType: string;    // 网络类型
}

/**
 * 启动耗时采集器
 * 在各关键节点打点，自动计算阶段耗时
 */
export class StartupTracer {
  private static instance: StartupTracer;
  private currentRecord: StartupRecord | null = null;
  private historyRecords: StartupRecord[] = [];     // 历史记录（内存缓存）
  private maxHistorySize: number = 50;               // 最大历史记录数

  private constructor() {}

  static getInstance(): StartupTracer {
    if (!StartupTracer.instance) {
      StartupTracer.instance = new StartupTracer();
    }
    return StartupTracer.instance;
  }

  // 开始一次新的启动追踪
  beginTrace(launchType: 'cold' | 'warm' | 'hot'): void {
    this.currentRecord = {
      traceId: `trace_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
      launchType,
      timestamps: new Map(),
      durations: new Map(),
      totalDuration: 0,
      deviceInfo: this.collectDeviceInfo(),
      appVersion: '1.0.0',
      timestamp: Date.now(),
    };

    hilog.info(DOMAIN, TAG, `开始启动追踪: ${this.currentRecord.traceId}, 类型: ${launchType}`);
  }

  // 记录关键节点时间戳
  trace(node: StartupNode): void {
    if (!this.currentRecord) {
      hilog.warn(DOMAIN, TAG, '没有活跃的追踪记录，请先调用beginTrace');
      return;
    }

    const now = Date.now();
    this.currentRecord.timestamps.set(node, now);
    hilog.info(DOMAIN, TAG, `[埋点] ${node} at ${now}`);
  }

  // 结束追踪，计算各阶段耗时
  endTrace(): StartupRecord | null {
    if (!this.currentRecord) {
      hilog.warn(DOMAIN, TAG, '没有活跃的追踪记录');
      return null;
    }

    // 计算各阶段耗时
    this.calculateDurations();

    // 计算总耗时
    const firstTimestamp = Math.min(...Array.from(this.currentRecord.timestamps.values()));
    const lastTimestamp = Math.max(...Array.from(this.currentRecord.timestamps.values()));
    this.currentRecord.totalDuration = lastTimestamp - firstTimestamp;

    // 保存到历史记录
    this.historyRecords.push(this.currentRecord);
    if (this.historyRecords.length > this.maxHistorySize) {
      this.historyRecords.shift();
    }

    // 输出报告
    this.printReport(this.currentRecord);

    const record = this.currentRecord;
    this.currentRecord = null;
    return record;
  }

  // 计算各阶段耗时
  private calculateDurations(): void {
    if (!this.currentRecord) return;

    const stages: Array<{ name: string; from: StartupNode; to: StartupNode }> = [
      { name: '应用初始化', from: StartupNode.PROCESS_CREATE, to: StartupNode.APP_ON_CREATE },
      { name: 'Stage初始化', from: StartupNode.APP_ON_CREATE, to: StartupNode.STAGE_ON_CREATE },
      { name: 'Ability初始化', from: StartupNode.STAGE_ON_CREATE, to: StartupNode.ABILITY_ON_CREATE },
      { name: '窗口创建', from: StartupNode.ABILITY_ON_CREATE, to: StartupNode.WINDOW_STAGE_CREATE },
      { name: '内容加载', from: StartupNode.WINDOW_STAGE_CREATE, to: StartupNode.CONTENT_LOADED },
      { name: '首帧渲染', from: StartupNode.CONTENT_LOADED, to: StartupNode.FIRST_FRAME },
      { name: '前台切换', from: StartupNode.FIRST_FRAME, to: StartupNode.ON_FOREGROUND },
    ];

    for (const stage of stages) {
      const fromTime = this.currentRecord.timestamps.get(stage.from);
      const toTime = this.currentRecord.timestamps.get(stage.to);
      if (fromTime !== undefined && toTime !== undefined) {
        this.currentRecord.durations.set(stage.name, toTime - fromTime);
      }
    }
  }

  // 输出耗时报告
  private printReport(record: StartupRecord): void {
    hilog.info(DOMAIN, TAG, '===== 启动耗时报告 =====');
    hilog.info(DOMAIN, TAG, `追踪ID: ${record.traceId}`);
    hilog.info(DOMAIN, TAG, `启动类型: ${record.launchType}`);
    hilog.info(DOMAIN, TAG, `总耗时: ${record.totalDuration}ms`);
    hilog.info(DOMAIN, TAG, '--- 各阶段耗时 ---');

    for (const [name, duration] of record.durations) {
      const bar = this.getDurationBar(duration);
      hilog.info(DOMAIN, TAG, `  ${name}: ${duration}ms ${bar}`);
    }

    hilog.info(DOMAIN, TAG, '===== 报告结束 =====');
  }

  // 生成耗时条形图（纯文本）
  private getDurationBar(duration: number): string {
    const maxBarLength = 30;
    const maxDuration = 2000;
    const barLength = Math.min(Math.round(duration / maxDuration * maxBarLength), maxBarLength);
    return '█'.repeat(barLength);
  }

  // 收集设备信息
  private collectDeviceInfo(): DeviceInfo {
    return {
      model: 'Unknown',
      osVersion: 'HarmonyOS 5',
      memory: 8192,
      cpuCores: 8,
      networkType: 'WiFi',
    };
  }

  // 获取历史记录
  getHistoryRecords(): StartupRecord[] {
    return [...this.historyRecords];
  }

  // 获取最近一次记录
  getLatestRecord(): StartupRecord | null {
    return this.historyRecords.length > 0 
      ? this.historyRecords[this.historyRecords.length - 1] 
      : null;
  }

  // 计算平均启动耗时
  getAverageDuration(): number {
    if (this.historyRecords.length === 0) return 0;
    const total = this.historyRecords.reduce((sum, r) => sum + r.totalDuration, 0);
    return Math.round(total / this.historyRecords.length);
  }

  // 计算P95启动耗时
  getP95Duration(): number {
    if (this.historyRecords.length < 5) return 0;
    const sorted = this.historyRecords
      .map(r => r.totalDuration)
      .sort((a, b) => a - b);
    const index = Math.ceil(sorted.length * 0.95) - 1;
    return sorted[index];
  }
}

3.2 进阶示例：启动耗时可视化与对比分析

将采集到的耗时数据进行可视化展示和版本间对比：

// StartupAnalyzer.ets - 启动耗时分析器
import hilog from '@ohos.hilog';
import { StartupTracer, StartupNode } from './StartupTracer';

const TAG = 'StartupAnalyzer';
const DOMAIN = 0x0001;

/**
 * 启动耗时分析器
 * 提供耗时可视化、版本对比、趋势分析等高级功能
 */
export class StartupAnalyzer {
  private static instance: StartupAnalyzer;
  private tracer = StartupTracer.getInstance();

  private constructor() {}

  static getInstance(): StartupAnalyzer {
    if (!StartupAnalyzer.instance) {
      StartupAnalyzer.instance = new StartupAnalyzer();
    }
    return StartupAnalyzer.instance;
  }

  // 生成ASCII柱状图（用于日志输出）
  generateBarChart(): string {
    const record = this.tracer.getLatestRecord();
    if (!record) return '暂无启动记录';

    const lines: string[] = [];
    lines.push('┌─────────────────────────────────────────────┐');
    lines.push('│           启动耗时分析（最近一次）           │');
    lines.push('├─────────────────────────────────────────────┤');

    const maxBarWidth = 25;
    const maxDuration = Math.max(...Array.from(record.durations.values()), 1);

    for (const [name, duration] of record.durations) {
      const barWidth = Math.round(duration / maxDuration * maxBarWidth);
      const bar = '■'.repeat(barWidth) + '□'.repeat(maxBarWidth - barWidth);
      const nameStr = name.padEnd(10, '　');
      lines.push(`│ ${nameStr} │${bar}│ ${duration}ms`);
    }

    lines.push('├─────────────────────────────────────────────┤');
    lines.push(`│ 总耗时: ${record.totalDuration}ms  类型: ${record.launchType.padEnd(4)}       │`);
    lines.push('└─────────────────────────────────────────────┘');

    return lines.join('\n');
  }

  // 版本间对比分析
  compareVersions(oldVersion: string, newVersion: string): string {
    const records = this.tracer.getHistoryRecords();
    const oldRecords = records.filter(r => r.appVersion === oldVersion);
    const newRecords = records.filter(r => r.appVersion === newVersion);

    if (oldRecords.length === 0 || newRecords.length === 0) {
      return `缺少 ${oldVersion} 或 ${newVersion} 的启动记录`;
    }

    const oldAvg = this.calcAverage(oldRecords);
    const newAvg = this.calcAverage(newRecords);
    const diff = newAvg - oldAvg;
    const percent = ((diff / oldAvg) * 100).toFixed(1);
    const trend = diff > 0 ? '⚠️ 变慢' : diff < 0 ? '✅ 变快' : '➡️ 持平';

    return [
      `版本对比: ${oldVersion} → ${newVersion}`,
      `  旧版本平均: ${oldAvg}ms`,
      `  新版本平均: ${newAvg}ms`,
      `  差异: ${diff > 0 ? '+' : ''}${diff}ms (${percent}%) ${trend}`,
    ].join('\n');
  }

  // 计算平均耗时
  private calcAverage(records: StartupRecord[]): number {
    if (records.length === 0) return 0;
    return Math.round(records.reduce((sum, r) => sum + r.totalDuration, 0) / records.length);
  }

  // 启动性能回归检测
  detectRegression(thresholdMs: number = 500): RegressionAlert | null {
    const records = this.tracer.getHistoryRecords();
    if (records.length < 3) return null;

    // 取最近3次的平均耗时
    const recentRecords = records.slice(-3);
    const recentAvg = this.calcAverage(recentRecords);

    // 取之前所有记录的平均耗时
    const olderRecords = records.slice(0, -3);
    if (olderRecords.length === 0) return null;
    const olderAvg = this.calcAverage(olderRecords);

    // 如果最近3次平均耗时比之前高出阈值，触发回归告警
    if (recentAvg - olderAvg > thresholdMs) {
      return {
        isRegression: true,
        olderAvg,
        recentAvg,
        diffMs: recentAvg - olderAvg,
        message: `⚠️ 启动性能回归！平均耗时从 ${olderAvg}ms 增加到 ${recentAvg}ms（+${recentAvg - olderAvg}ms）`,
      };
    }

    return null;
  }

  // 生成性能趋势报告
  generateTrendReport(): string {
    const records = this.tracer.getHistoryRecords();
    if (records.length === 0) return '暂无启动记录';

    const lines: string[] = ['启动性能趋势:'];

    // 按时间排序
    const sorted = [...records].sort((a, b) => a.timestamp - b.timestamp);

    // 每5条记录取一个采样点
    const sampleSize = 5;
    for (let i = 0; i < sorted.length; i += sampleSize) {
      const batch = sorted.slice(i, i + sampleSize);
      const avg = this.calcAverage(batch);
      const time = new Date(batch[0].timestamp).toLocaleString();
      const bar = '●'.repeat(Math.min(Math.round(avg / 100), 20));
      lines.push(`  ${time} | ${bar} ${avg}ms`);
    }

    // 汇总统计
    const allDurations = sorted.map(r => r.totalDuration);
    const min = Math.min(...allDurations);
    const max = Math.max(...allDurations);
    const avg = this.calcAverage(sorted);
    const p95 = this.tracer.getP95Duration();

    lines.push('');
    lines.push(`统计: 最快${min}ms / 最慢${max}ms / 平均${avg}ms / P95 ${p95}ms`);

    return lines.join('\n');
  }
}

/**
 * 回归告警
 */
interface RegressionAlert {
  isRegression: boolean;
  olderAvg: number;
  recentAvg: number;
  diffMs: number;
  message: string;
}

interface StartupRecord {
  traceId: string;
  launchType: string;
  timestamps: Map<string, number>;
  durations: Map<string, number>;
  totalDuration: number;
  deviceInfo: Object;
  appVersion: string;
  timestamp: number;
}

3.3 完整示例：启动监控面板实现

将采集、分析、告警整合为一个完整的启动监控面板：

// StartupMonitorPanel.ets - 启动监控面板
import { StartupTracer, StartupNode } from '../monitor/StartupTracer';
import { StartupAnalyzer } from '../monitor/StartupAnalyzer';
import UIAbility from '@ohos.app.ability.UIAbility';
import hilog from '@ohos.hilog';

const TAG = 'MonitorPanel';
const DOMAIN = 0x0001;

/**
 * 启动监控面板
 * 集成采集、分析、告警、上报功能
 */
export class StartupMonitorPanel {
  private static instance: StartupMonitorPanel;
  private tracer = StartupTracer.getInstance();
  private analyzer = StartupAnalyzer.getInstance();
  private alertCallbacks: Array<(alert: RegressionAlert) => void> = [];
  private uploadQueue: StartupRecord[] = [];
  private isUploading: boolean = false;

  private constructor() {}

  static getInstance(): StartupMonitorPanel {
    if (!StartupMonitorPanel.instance) {
      StartupMonitorPanel.instance = new StartupMonitorPanel();
    }
    return StartupMonitorPanel.instance;
  }

  // 注册回归告警回调
  onRegression(callback: (alert: RegressionAlert) => void): void {
    this.alertCallbacks.push(callback);
  }

  // 开始监控
  startMonitoring(launchType: 'cold' | 'warm' | 'hot'): void {
    this.tracer.beginTrace(launchType);
    hilog.info(DOMAIN, TAG, `启动监控已开启, 类型: ${launchType}`);
  }

  // 记录节点
  traceNode(node: StartupNode): void {
    this.tracer.trace(node);
  }

  // 结束监控
  stopMonitoring(): void {
    const record = this.tracer.endTrace();
    if (!record) return;

    // 1. 输出可视化报告
    const chart = this.analyzer.generateBarChart();
    hilog.info(DOMAIN, TAG, chart);

    // 2. 回归检测
    const alert = this.analyzer.detectRegression(500);
    if (alert && alert.isRegression) {
      hilog.warn(DOMAIN, TAG, alert.message);
      // 通知所有注册的告警回调
      for (const callback of this.alertCallbacks) {
        callback(alert);
      }
    }

    // 3. 加入上传队列
    this.uploadQueue.push(record as StartupRecord);
    this.tryUpload();
  }

  // 尝试上传监控数据
  private tryUpload(): void {
    if (this.isUploading || this.uploadQueue.length === 0) return;
    this.isUploading = true;

    const batch = this.uploadQueue.splice(0, 10);  // 每次最多上传10条
    this.uploadBatch(batch).then(() => {
      this.isUploading = false;
      // 继续上传剩余数据
      if (this.uploadQueue.length > 0) {
        this.tryUpload();
      }
    }).catch(() => {
      this.isUploading = false;
      // 上传失败，放回队列
      this.uploadQueue.unshift(...batch);
    });
  }

  // 批量上传
  private async uploadBatch(records: StartupRecord[]): Promise<void> {
    hilog.info(DOMAIN, TAG, `上传 ${records.length} 条启动监控数据`);
    // 实际项目中使用HTTP请求上传到监控平台
    // const response = await http.request('https://monitor.example.com/api/startup', ...);
  }

  // 获取性能概览
  getPerformanceOverview(): string {
    const latest = this.tracer.getLatestRecord();
    const avg = this.tracer.getAverageDuration();
    const p95 = this.tracer.getP95Duration();
    const history = this.tracer.getHistoryRecords();

    return [
      '===== 启动性能概览 =====',
      `最近一次: ${latest ? latest.totalDuration + 'ms' : '无数据'}`,
      `平均耗时: ${avg}ms`,
      `P95耗时: ${p95}ms`,
      `采样次数: ${history.length}`,
      '=====================',
    ].join('\n');
  }
}

interface RegressionAlert {
  isRegression: boolean;
  olderAvg: number;
  recentAvg: number;
  diffMs: number;
  message: string;
}

interface StartupRecord {
  traceId: string;
  launchType: string;
  timestamps: Map<string, number>;
  durations: Map<string, number>;
  totalDuration: number;
  deviceInfo: Object;
  appVersion: string;
  timestamp: number;
}

// ========== 在Ability中集成启动监控 ==========
export default class MonitoredEntryAbility extends UIAbility {
  private monitorPanel = StartupMonitorPanel.getInstance();

  onCreate(want, launchParam): void {
    // 开始冷启动监控
    this.monitorPanel.startMonitoring('cold');
    this.monitorPanel.traceNode(StartupNode.ABILITY_ON_CREATE);

    // 注册回归告警回调
    this.monitorPanel.onRegression((alert) => {
      hilog.error(DOMAIN, TAG, `🚨 启动性能回归告警: ${alert.message}`);
      // 可以在这里触发告警通知、发送邮件等
    });
  }

  onWindowStageCreate(windowStage): void {
    this.monitorPanel.traceNode(StartupNode.WINDOW_STAGE_CREATE);

    windowStage.loadContent('pages/Index', (err) => {
      if (!err.code) {
        this.monitorPanel.traceNode(StartupNode.CONTENT_LOADED);
      }
    });
  }

  onForeground(): void {
    this.monitorPanel.traceNode(StartupNode.ON_FOREGROUND);

    // 结束监控，触发分析和上报
    this.monitorPanel.stopMonitoring();

    // 输出性能概览
    hilog.info(DOMAIN, TAG, this.monitorPanel.getPerformanceOverview());
  }

  onBackground(): void {
    hilog.info(DOMAIN, TAG, 'Ability onBackground');
  }
}

四、踩坑与注意事项

坑点1：埋点时间戳精度不足

Date.now()的精度只有毫秒级，在某些快速执行的节点之间可能无法区分耗时差异。解决方案：对于需要更高精度的场景，使用performance.now()（如果可用）或系统高精度计时器。

坑点2：监控数据占用过多内存

每次启动都保存一条完整的记录，包含时间戳、设备信息等，长期积累会占用大量内存。解决方案：设置历史记录上限（建议50~100条），超出后自动淘汰最旧的记录；同时定期将数据上传到服务器，本地只保留摘要。

坑点3：上传监控数据影响正常请求

启动监控数据的上传如果与正常业务请求同时进行，可能抢占网络带宽，导致业务请求变慢。解决方案：监控数据上传应该在启动完成后延迟执行（建议延迟5秒以上），并且使用低优先级的网络请求。

坑点4：回归检测阈值设置不合理

阈值太低，正常波动也会触发告警（误报）；阈值太高，真正的性能退化检测不到（漏报）。解决方案：阈值应该根据历史数据动态计算——使用P95作为基准，超过P95的20%即触发告警。

坑点5：忽略冷/热启动的监控区分

冷启动和热启动的耗时差异很大，如果混在一起统计，平均值会被热启动拉低，掩盖冷启动的问题。解决方案：监控数据必须区分启动类型，冷启动和热启动分别统计和分析。

坑点6：监控代码本身的性能开销

每次打点都要记录时间戳、计算耗时、保存数据，这些操作本身也有性能开销。解决方案：监控代码应该尽量轻量——打点操作只记录时间戳，耗时计算和数据分析延迟到endTrace时批量处理。

坑点7：缺少线上用户的真实数据

开发环境下的启动数据不能代表线上用户的真实体验——设备性能、网络环境、数据量都不同。解决方案：必须建立线上监控体系，采集真实用户的启动耗时数据，重点关注P95和P99指标。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. startupTrace自动采集：HarmonyOS 6提供系统级启动耗时API，自动采集关键节点时间戳
2. Profiler自动分析：DevEco Studio Profiler自动生成启动耗时火焰图和瓶颈分析
3. 性能基线自动建立：首次运行时自动建立性能基线，后续运行自动对比

适配代码

// HarmonyOS 6 启动监控适配 - 利用系统级API
import hiTraceMeter from '@ohos.hiTraceMeter';
import StartupTrace from '@ohos.app.ability.StartupTrace';

export default class HarmonyOS6MonitoredAbility extends UIAbility {
  onCreate(want, launchParam): void {
    // 使用HiTraceMeter进行精确打点
    hiTraceMeter.startTrace('app_startup', 1);
    
    // 使用系统级StartupTrace API
    StartupTrace.begin('cold');
    StartupTrace.trace('ability_on_create');

    // ... 初始化逻辑 ...

    hiTraceMeter.finishTrace('app_startup', 1);
  }

  onWindowStageCreate(windowStage): void {
    StartupTrace.trace('window_stage_create');
    windowStage.loadContent('pages/Index', (err) => {
      if (!err.code) {
        StartupTrace.trace('content_loaded');
      }
    });
  }

  onForeground(): void {
    StartupTrace.trace('on_foreground');
    // 结束追踪，系统自动生成报告
    StartupTrace.end();
  }
}

六、总结

三维度评价表

一句话总结：没有度量就没有优化——构建完整的启动监控体系，让启动性能"看得见、量得准、管得住"，才能持续保障用户体验不退化。

下篇预告：《HarmonyOS APP开发：启动白屏优化与首帧加速》——白屏是启动体验的"第一杀手"，下一篇将讲解如何消除白屏、加速首帧渲染！