HarmonyOS APP开发：能耗分析与功耗优化

📌 核心要点：系统掌握移动端能耗模型，利用HarmonyOS功耗分析工具精准定位功耗热点，从CPU/GPU/屏幕/网络/传感器五大维度实现全方位功耗优化。

一、背景与动机

你有没有遇到过用户反馈"你的应用太费电了"？或者应用商店的评分被一条"耗电严重，一星差评"拉低？

在移动设备上，电量就是生命线。用户对耗电的容忍度极低——一个应用如果在后台偷偷消耗电量，很快就会被卸载。HarmonyOS的应用市场甚至会展示应用的耗电等级，高耗电应用的下载转化率会显著下降。

但功耗优化有一个根本性的难点：你很难直观地"看到"电量的消耗。不像UI卡顿肉眼可见、内存泄漏可以监控，功耗问题往往是"温水煮青蛙"——用户可能用了好几天才察觉到电量消耗异常，而开发者更难在开发阶段发现功耗问题。

要解决功耗问题，首先要理解移动设备的能耗模型：CPU、GPU、屏幕、网络、传感器——哪些组件最耗电？你的应用在哪些场景下功耗最高？如何精准定位功耗热点？

本文将从能耗模型出发，带你掌握HarmonyOS的功耗分析工具链和优化策略，让你的应用成为"省电小能手"。

二、核心原理

2.1 移动端能耗模型

flowchart TB
    A[移动设备总能耗] --> B[CPU能耗<br/>约30%-40%]
    A --> C[屏幕能耗<br/>约20%-35%]
    A --> D[网络能耗<br/>约10%-25%]
    A --> E[GPU能耗<br/>约5%-15%]
    A --> F[传感器能耗<br/>约2%-10%]
    
    B --> B1[计算密集型任务]
    B --> B2[频繁唤醒]
    B --> B3[后台持续运行]
    
    C --> C1[屏幕亮度]
    C --> C2[刷新率]
    C --> C3[显示时长]
    
    D --> D1[频繁网络请求]
    D --> D2[大数据传输]
    D --> D3[网络切换]
    
    E --> E1[复杂动画]
    E --> E2[3D渲染]
    E --> E3[视频编解码]
    
    F --> F1[GPS定位]
    F --> F2[加速度计]
    F --> F3[陀螺仪]
    
    classDef totalStyle fill:#E74C3C,stroke:#C0392B,color:#fff,font-weight:bold
    classDef cpuStyle fill:#3498DB,stroke:#2980B9,color:#fff
    classDef screenStyle fill:#2ECC71,stroke:#27AE60,color:#fff
    classDef networkStyle fill:#F39C12,stroke:#E67E22,color:#fff
    classDef gpuStyle fill:#9B59B6,stroke:#8E44AD,color:#fff
    classDef sensorStyle fill:#1ABC9C,stroke:#16A085,color:#fff
    
    class A totalStyle
    class B,B1,B2,B3 cpuStyle
    class C,C1,C2,C3 screenStyle
    class D,D1,D2,D3 networkStyle
    class E,E1,E2,E3 gpuStyle
    class F,F1,F2,F3 sensorStyle

2.2 各组件能耗占比与优化方向

2.3 功耗分析的核心方法论

功耗优化遵循一个核心原则：先测量，再优化。没有数据支撑的优化都是盲目的。完整的功耗优化流程如下：

1. 建立基线：在标准场景下测量应用的功耗数据
2. 热点定位：找出功耗最高的组件和场景
3. 根因分析：深入分析功耗热点的具体原因
4. 实施优化：针对性地优化功耗热点
5. 验证效果：重新测量，确认优化效果
6. 持续监控：建立长效监控机制，防止功耗回归

三、代码实战

3.1 基础示例：功耗数据采集器

// power_monitor.ets - 功耗数据采集器
import { batteryInfo } from '@ohos.batteryInfo'
import { thermal } from '@ohos.thermal'

// 功耗采样数据
interface PowerSample {
  timestamp: number           // 采样时间戳
  batteryLevel: number        // 电量百分比
  batteryStatus: string       // 充电状态
  voltage: number             // 电压（微伏）
  current: number             // 电流（微安）
  temperature: number         // 电池温度
  thermalLevel: string        // 热管理等级
  cpuUsage: number            // CPU使用率
  screenBrightness: number    // 屏幕亮度
  networkType: string         // 网络类型
}

// 功耗分析报告
interface PowerAnalysisReport {
  duration: number            // 监控时长（秒）
  batteryDrain: number        // 电量消耗（百分比）
  drainRate: number           // 每小时耗电率
  avgCpuUsage: number         // 平均CPU使用率
  maxCpuUsage: number         // 最高CPU使用率
  avgTemperature: number      // 平均温度
  maxTemperature: number      // 最高温度
  thermalThrottlingCount: number  // 热降频次数
  samples: PowerSample[]      // 原始采样数据
}

// 功耗监控器
class PowerMonitor {
  private samples: PowerSample[] = []
  private intervalId: number = -1
  private sampleInterval: number = 5000  // 默认5秒采样一次
  private startBatteryLevel: number = 0
  private isMonitoring: boolean = false

  // 开始监控
  start(intervalMs: number = 5000): void {
    if (this.isMonitoring) {
      console.warn('功耗监控已在运行中')
      return
    }

    this.sampleInterval = intervalMs
    this.samples = []
    this.startBatteryLevel = batteryInfo.batterySOC
    this.isMonitoring = true

    // 定时采样
    this.intervalId = setInterval(() => {
      this.collectSample()
    }, this.sampleInterval)

    // 立即采集一次
    this.collectSample()
    console.info(`功耗监控已启动，采样间隔: ${intervalMs}ms`)
  }

  // 停止监控
  stop(): PowerAnalysisReport {
    if (!this.isMonitoring) {
      console.warn('功耗监控未启动')
      return this.generateReport()
    }

    clearInterval(this.intervalId)
    this.isMonitoring = false
    console.info('功耗监控已停止')

    return this.generateReport()
  }

  // 采集一次数据
  private collectSample(): void {
    const sample: PowerSample = {
      timestamp: Date.now(),
      batteryLevel: batteryInfo.batterySOC,
      batteryStatus: this.getBatteryStatus(),
      voltage: batteryInfo.voltage,
      current: batteryInfo.chargingStatus === batteryInfo.BatteryChargeState.ENABLE ? 
        Math.abs(batteryInfo.currentNow) : -Math.abs(batteryInfo.currentNow),
      temperature: batteryInfo.batteryTemperature / 10,  // 转为摄氏度
      thermalLevel: this.getThermalLevel(),
      cpuUsage: this.estimateCpuUsage(),
      screenBrightness: this.getScreenBrightness(),
      networkType: this.getNetworkType()
    }

    this.samples.push(sample)
  }

  // 生成分析报告
  private generateReport(): PowerAnalysisReport {
    const duration = this.samples.length > 1
      ? (this.samples[this.samples.length - 1].timestamp - this.samples[0].timestamp) / 1000
      : 0

    const batteryDrain = this.startBatteryLevel - 
      (this.samples.length > 0 ? this.samples[this.samples.length - 1].batteryLevel : this.startBatteryLevel)

    const drainRate = duration > 0 ? (batteryDrain / duration * 3600) : 0

    const cpuUsages = this.samples.map(s => s.cpuUsage)
    const temperatures = this.samples.map(s => s.temperature)
    const thermalThrottlingCount = this.samples.filter(
      s => s.thermalLevel !== 'NORMAL'
    ).length

    return {
      duration: duration,
      batteryDrain: batteryDrain,
      drainRate: drainRate,
      avgCpuUsage: cpuUsages.length > 0 ? cpuUsages.reduce((a, b) => a + b, 0) / cpuUsages.length : 0,
      maxCpuUsage: cpuUsages.length > 0 ? Math.max(...cpuUsages) : 0,
      avgTemperature: temperatures.length > 0 ? temperatures.reduce((a, b) => a + b, 0) / temperatures.length : 0,
      maxTemperature: temperatures.length > 0 ? Math.max(...temperatures) : 0,
      thermalThrottlingCount: thermalThrottlingCount,
      samples: [...this.samples]
    }
  }

  // 获取充电状态
  private getBatteryStatus(): string {
    switch (batteryInfo.chargingStatus) {
      case batteryInfo.BatteryChargeState.ENABLE: return '充电中'
      case batteryInfo.BatteryChargeState.DISABLE: return '未充电'
      case batteryInfo.BatteryChargeState.FULL: return '已充满'
      default: return '未知'
    }
  }

  // 获取热管理等级
  private getThermalLevel(): string {
    try {
      const level = thermal.getThermalLevel()
      switch (level) {
        case thermal.ThermalLevel.NORMAL: return 'NORMAL'
        case thermal.ThermalLevel.COOL: return 'COOL'
        case thermal.ThermalLevel.WARM: return 'WARM'
        case thermal.ThermalLevel.HOT: return 'HOT'
        case thermal.ThermalLevel.OVERHEATED: return 'OVERHEATED'
        default: return 'UNKNOWN'
      }
    } catch (e) {
      return 'UNKNOWN'
    }
  }

  // 估算CPU使用率（简化实现）
  private estimateCpuUsage(): number {
    // 实际应通过@ohos.process获取进程CPU使用率
    return 0
  }

  // 获取屏幕亮度
  private getScreenBrightness(): number {
    // 实际应通过@ohos.screen获取
    return 0
  }

  // 获取网络类型
  private getNetworkType(): string {
    // 实际应通过@ohos.net.connection获取
    return 'unknown'
  }

  // 格式化报告
  formatReport(report: PowerAnalysisReport): string {
    const lines: string[] = []
    lines.push('📊 功耗分析报告')
    lines.push('='.repeat(50))
    lines.push(`监控时长: ${(report.duration / 60).toFixed(1)}分钟`)
    lines.push(`电量消耗: ${report.batteryDrain.toFixed(1)}%`)
    lines.push(`每小时耗电率: ${report.drainRate.toFixed(2)}%/h`)
    lines.push('')
    lines.push(`平均CPU使用率: ${report.avgCpuUsage.toFixed(1)}%`)
    lines.push(`最高CPU使用率: ${report.maxCpuUsage.toFixed(1)}%`)
    lines.push(`平均温度: ${report.avgTemperature.toFixed(1)}°C`)
    lines.push(`最高温度: ${report.maxTemperature.toFixed(1)}°C`)
    lines.push(`热降频次数: ${report.thermalThrottlingCount}`)
    lines.push('')

    // 功耗等级评估
    if (report.drainRate < 2) {
      lines.push('功耗等级: 🟢 低功耗')
    } else if (report.drainRate < 5) {
      lines.push('功耗等级: 🟡 中等功耗')
    } else if (report.drainRate < 10) {
      lines.push('功耗等级: 🟠 较高功耗')
    } else {
      lines.push('功耗等级: 🔴 高功耗，需优化!')
    }

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

// 使用示例
const powerMonitor = new PowerMonitor()

// 开始监控
powerMonitor.start(3000)  // 3秒采样一次

// ... 执行业务操作 ...

// 停止监控并获取报告
// const report = powerMonitor.stop()
// console.info(powerMonitor.formatReport(report))

3.2 进阶示例：功耗热点定位器

// hotspot_locator.ets - 功耗热点定位器
import { batteryInfo } from '@ohos.batteryInfo'

// 功耗热点
interface PowerHotspot {
  category: string            // 热点分类
  severity: 'critical' | 'warning' | 'info'  // 严重程度
  description: string         // 热点描述
  estimatedDrain: number      // 预估耗电（%/h）
  suggestion: string          // 优化建议
}

// 场景功耗数据
interface ScenePowerData {
  sceneName: string           // 场景名称
  startTime: number           // 开始时间
  endTime: number             // 结束时间
  startBattery: number        // 开始电量
  endBattery: number          // 结束电量
  cpuUsageSamples: number[]   // CPU使用率采样
  networkRequestCount: number // 网络请求次数
  sensorActiveTime: number   // 传感器活跃时间（秒）
  screenOnTime: number        // 屏幕亮屏时间（秒）
}

// 功耗热点定位器
class PowerHotspotLocator {
  private sceneDataMap: Map<string, ScenePowerData> = new Map()
  private currentScene: string = ''
  private currentSceneStart: number = 0
  private currentSceneBattery: number = 0

  // 进入场景
  enterScene(sceneName: string): void {
    // 结束上一个场景
    if (this.currentScene) {
      this.exitScene()
    }

    this.currentScene = sceneName
    this.currentSceneStart = Date.now()
    this.currentSceneBattery = batteryInfo.batterySOC
  }

  // 退出场景
  exitScene(): void {
    if (!this.currentScene) return

    const data: ScenePowerData = {
      sceneName: this.currentScene,
      startTime: this.currentSceneStart,
      endTime: Date.now(),
      startBattery: this.currentSceneBattery,
      endBattery: batteryInfo.batterySOC,
      cpuUsageSamples: [],
      networkRequestCount: 0,
      sensorActiveTime: 0,
      screenOnTime: (Date.now() - this.currentSceneStart) / 1000
    }

    this.sceneDataMap.set(this.currentScene, data)
    this.currentScene = ''
  }

  // 分析功耗热点
  analyzeHotspots(): PowerHotspot[] {
    const hotspots: PowerHotspot[] = []

    // 分析各场景的功耗
    this.sceneDataMap.forEach((data, sceneName) => {
      const duration = (data.endTime - data.startTime) / 1000  // 秒
      if (duration < 10) return  // 忽略过短的场景

      const drain = data.startBattery - data.endBattery
      const drainRate = drain / duration * 3600  // %/h

      // 高功耗场景
      if (drainRate > 8) {
        hotspots.push({
          category: '高功耗场景',
          severity: 'critical',
          description: `场景"${sceneName}"每小时耗电${drainRate.toFixed(1)}%，属于高功耗`,
          estimatedDrain: drainRate,
          suggestion: '检查该场景中是否有不必要的CPU计算、网络请求或传感器使用'
        })
      } else if (drainRate > 4) {
        hotspots.push({
          category: '中等功耗场景',
          severity: 'warning',
          description: `场景"${sceneName}"每小时耗电${drainRate.toFixed(1)}%，功耗偏高`,
          estimatedDrain: drainRate,
          suggestion: '考虑优化该场景的计算逻辑和网络请求策略'
        })
      }
    })

    // 分析CPU使用模式
    this.analyzeCpuHotspots(hotspots)

    // 分析网络请求模式
    this.analyzeNetworkHotspots(hotspots)

    // 分析传感器使用
    this.analyzeSensorHotspots(hotspots)

    // 按严重程度排序
    return hotspots.sort((a, b) => {
      const order = { critical: 0, warning: 1, info: 2 }
      return order[a.severity] - order[b.severity]
    })
  }

  // 分析CPU热点
  private analyzeCpuHotspots(hotspots: PowerHotspot[]): void {
    // 检查是否有持续高CPU使用的场景
    this.sceneDataMap.forEach((data) => {
      if (data.cpuUsageSamples.length === 0) return

      const avgCpu = data.cpuUsageSamples.reduce((a, b) => a + b, 0) / data.cpuUsageSamples.length
      const maxCpu = Math.max(...data.cpuUsageSamples)

      if (avgCpu > 50) {
        hotspots.push({
          category: 'CPU功耗',
          severity: 'critical',
          description: `场景"${data.sceneName}"平均CPU使用率${avgCpu.toFixed(1)}%，峰值${maxCpu.toFixed(1)}%`,
          estimatedDrain: avgCpu * 0.1,
          suggestion: '减少不必要的计算，使用防抖/节流控制高频操作，将计算任务延迟到充电时执行'
        })
      } else if (avgCpu > 30) {
        hotspots.push({
          category: 'CPU功耗',
          severity: 'warning',
          description: `场景"${data.sceneName}"CPU使用率偏高: ${avgCpu.toFixed(1)}%`,
          estimatedDrain: avgCpu * 0.08,
          suggestion: '检查是否有频繁的UI重绘、动画或定时器导致的CPU占用'
        })
      }
    })
  }

  // 分析网络热点
  private analyzeNetworkHotspots(hotspots: PowerHotspot[]): void {
    this.sceneDataMap.forEach((data) => {
      const duration = (data.endTime - data.startTime) / 1000
      const requestRate = data.networkRequestCount / (duration / 60)  // 请求/分钟

      if (requestRate > 30) {
        hotspots.push({
          category: '网络功耗',
          severity: 'critical',
          description: `场景"${data.sceneName}"网络请求频率${requestRate.toFixed(1)}次/分钟，过于频繁`,
          estimatedDrain: requestRate * 0.05,
          suggestion: '合并网络请求、使用批量接口、增加请求间隔、启用本地缓存'
        })
      } else if (requestRate > 10) {
        hotspots.push({
          category: '网络功耗',
          severity: 'warning',
          description: `场景"${data.sceneName}"网络请求频率${requestRate.toFixed(1)}次/分钟`,
          estimatedDrain: requestRate * 0.03,
          suggestion: '考虑减少不必要的网络请求，使用缓存减少重复请求'
        })
      }
    })
  }

  // 分析传感器热点
  private analyzeSensorHotspots(hotspots: PowerHotspot[]): void {
    this.sceneDataMap.forEach((data) => {
      const duration = (data.endTime - data.startTime) / 1000
      const sensorUsageRatio = data.sensorActiveTime / duration

      if (sensorUsageRatio > 0.8 && duration > 60) {
        hotspots.push({
          category: '传感器功耗',
          severity: 'warning',
          description: `场景"${data.sceneName}"传感器持续活跃时间占比${(sensorUsageRatio * 100).toFixed(0)}%`,
          estimatedDrain: sensorUsageRatio * 2,
          suggestion: '降低传感器采样频率、使用按需启停策略、考虑使用低功耗传感器替代方案'
        })
      }
    })
  }

  // 格式化热点报告
  formatHotspotReport(hotspots: PowerHotspot[]): string {
    const lines: string[] = []
    lines.push('🔥 功耗热点报告')
    lines.push('='.repeat(50))

    if (hotspots.length === 0) {
      lines.push('未发现明显功耗热点 ✅')
      return lines.join('\n')
    }

    for (const hotspot of hotspots) {
      const icon = hotspot.severity === 'critical' ? '🔴' : 
                   hotspot.severity === 'warning' ? '🟡' : '🟢'
      lines.push(`${icon} [${hotspot.category}] ${hotspot.description}`)
      lines.push(`   预估耗电: ${hotspot.estimatedDrain.toFixed(1)}%/h`)
      lines.push(`   优化建议: ${hotspot.suggestion}`)
      lines.push('')
    }

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

3.3 完整示例：综合功耗优化策略

// power_optimizer.ets - 综合功耗优化策略
import { backgroundTaskManager } from '@kit.BackgroundTasksKit'
import { wifiManager } from '@kit.WifiKit'
import { screenLock } from '@kit.ScreenLockKit'

// 功耗优化策略配置
interface PowerOptimizeConfig {
  // CPU优化
  cpuOptimize: {
    throttleAnimation: boolean      // 降低动画帧率
    deferHeavyTask: boolean         // 延迟重计算任务
    batchTimerInterval: number      // 合并定时器间隔（毫秒）
  }
  // 屏幕优化
  screenOptimize: {
    autoDimEnabled: boolean         // 自动降低亮度
    autoDimTimeout: number          // 自动降亮度超时（秒）
    reduceRefreshRate: boolean      // 降低刷新率
  }
  // 网络优化
  networkOptimize: {
    batchRequests: boolean          // 合并网络请求
    requestInterval: number         // 请求最小间隔（毫秒）
    enableCache: boolean            // 启用本地缓存
    compressData: boolean           // 压缩传输数据
  }
  // 传感器优化
  sensorOptimize: {
    reduceSampleRate: boolean       // 降低采样率
    autoStopOnBackground: boolean   // 后台自动停止传感器
    sampleIntervalMs: number        // 采样间隔（毫秒）
  }
}

// 功耗优化管理器
class PowerOptimizer {
  private config: PowerOptimizeConfig
  private isLowPowerMode: boolean = false
  private pendingTasks: (() => void)[] = []
  private networkRequestQueue: NetworkRequest[] = []
  private batchTimer: number = -1

  constructor(config?: Partial<PowerOptimizeConfig>) {
    this.config = this.getDefaultConfig()
    if (config) {
      this.config = this.mergeConfig(this.config, config)
    }
  }

  // 根据电量状态自动调整优化策略
  adaptToBatteryLevel(batteryLevel: number): void {
    if (batteryLevel <= 10) {
      // 极低电量：激进优化
      this.enableLowPowerMode('aggressive')
    } else if (batteryLevel <= 20) {
      // 低电量：中等优化
      this.enableLowPowerMode('moderate')
    } else if (batteryLevel <= 50) {
      // 中等电量：轻度优化
      this.enableLowPowerMode('light')
    } else {
      // 电量充足：不优化
      this.disableLowPowerMode()
    }
  }

  // 启用低功耗模式
  private enableLowPowerMode(level: 'light' | 'moderate' | 'aggressive'): void {
    this.isLowPowerMode = true

    switch (level) {
      case 'light':
        // 轻度优化：降低动画帧率、合并定时器
        this.config.cpuOptimize.throttleAnimation = true
        this.config.cpuOptimize.batchTimerInterval = 1000
        this.config.networkOptimize.batchRequests = true
        break

      case 'moderate':
        // 中等优化：延迟重计算、降低采样率
        this.config.cpuOptimize.throttleAnimation = true
        this.config.cpuOptimize.deferHeavyTask = true
        this.config.cpuOptimize.batchTimerInterval = 2000
        this.config.networkOptimize.batchRequests = true
        this.config.networkOptimize.requestInterval = 5000
        this.config.sensorOptimize.reduceSampleRate = true
        this.config.sensorOptimize.sampleIntervalMs = 500
        break

      case 'aggressive':
        // 激进优化：全面降级
        this.config.cpuOptimize.throttleAnimation = true
        this.config.cpuOptimize.deferHeavyTask = true
        this.config.cpuOptimize.batchTimerInterval = 5000
        this.config.screenOptimize.autoDimEnabled = true
        this.config.screenOptimize.autoDimTimeout = 15
        this.config.networkOptimize.batchRequests = true
        this.config.networkOptimize.requestInterval = 10000
        this.config.networkOptimize.enableCache = true
        this.config.sensorOptimize.reduceSampleRate = true
        this.config.sensorOptimize.autoStopOnBackground = true
        this.config.sensorOptimize.sampleIntervalMs = 1000
        break
    }

    console.info(`低功耗模式已启用: ${level}`)
  }

  // 禁用低功耗模式
  private disableLowPowerMode(): void {
    if (!this.isLowPowerMode) return
    this.isLowPowerMode = false
    this.config = this.getDefaultConfig()
    console.info('低功耗模式已禁用')
  }

  // 执行延迟任务（低功耗模式下延迟执行）
  executeTask(task: () => void, isHeavy: boolean = false): void {
    if (this.isLowPowerMode && isHeavy && this.config.cpuOptimize.deferHeavyTask) {
      // 延迟执行
      this.pendingTasks.push(task)
      console.info('重计算任务已延迟执行')
    } else {
      task()
    }
  }

  // 执行延迟的任务（在充电时执行）
  executePendingTasks(): void {
    if (batteryInfo.chargingStatus === batteryInfo.BatteryChargeState.ENABLE) {
      const tasks = [...this.pendingTasks]
      this.pendingTasks = []
      for (const task of tasks) {
        task()
      }
      console.info(`已执行${tasks.length}个延迟任务`)
    }
  }

  // 获取动画帧率（根据功耗策略调整）
  getAnimationFrameRate(): number {
    if (this.config.cpuOptimize.throttleAnimation) {
      return this.isLowPowerMode ? 30 : 60  // 低功耗模式降到30fps
    }
    return 60
  }

  // 获取传感器采样间隔
  getSensorSampleInterval(): number {
    return this.config.sensorOptimize.sampleIntervalMs
  }

  // 是否应该执行网络请求
  shouldMakeNetworkRequest(): boolean {
    return !this.isLowPowerMode || this.config.networkOptimize.batchRequests
  }

  // 获取当前优化状态
  getOptimizationStatus(): Record<string, Object> {
    return {
      isLowPowerMode: this.isLowPowerMode,
      batteryLevel: batteryInfo.batterySOC,
      pendingTasks: this.pendingTasks.length,
      config: this.config
    }
  }

  // 获取默认配置
  private getDefaultConfig(): PowerOptimizeConfig {
    return {
      cpuOptimize: {
        throttleAnimation: false,
        deferHeavyTask: false,
        batchTimerInterval: 500
      },
      screenOptimize: {
        autoDimEnabled: false,
        autoDimTimeout: 30,
        reduceRefreshRate: false
      },
      networkOptimize: {
        batchRequests: false,
        requestInterval: 1000,
        enableCache: true,
        compressData: true
      },
      sensorOptimize: {
        reduceSampleRate: false,
        autoStopOnBackground: true,
        sampleIntervalMs: 200
      }
    }
  }

  // 合并配置
  private mergeConfig(defaults: PowerOptimizeConfig, override: Partial<PowerOptimizeConfig>): PowerOptimizeConfig {
    return { ...defaults, ...override } as PowerOptimizeConfig
  }
}

// 网络请求（用于批量处理）
interface NetworkRequest {
  url: string
  method: string
  data?: Object
  callback: (result: string) => void
}

// 全局功耗优化器实例
const powerOptimizer = new PowerOptimizer()

// 在应用入口初始化
@Entry
@Component
struct PowerAwareApp {
  @State batteryLevel: number = 100

  aboutToAppear(): void {
    // 监听电量变化
    this.batteryLevel = batteryInfo.batterySOC
    powerOptimizer.adaptToBatteryLevel(this.batteryLevel)
  }

  build() {
    Column() {
      Text(`电量: ${this.batteryLevel}%`)
        .fontSize(24)
        .fontWeight(FontWeight.Bold)

      if (this.batteryLevel <= 20) {
        Text('🔋 低电量模式已启用')
          .fontSize(16)
          .fontColor('#FF9800')
          .margin({ top: 10 })
      }
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

四、踩坑与注意事项

坑点1：功耗测试必须在真实设备上进行

模拟器无法模拟真实的功耗行为——它没有电池、没有真实的CPU功耗、没有网络模块的射频功耗。功耗测试必须在真实设备上进行，而且最好使用不同型号的设备，因为不同芯片的功耗特性差异很大。

坑点2：短时间测试无法准确反映功耗

功耗是一个"慢变量"——短时间内（几分钟）的电量变化可能很小，测量误差甚至比实际变化还大。建议每次功耗测试至少持续30分钟以上，最好1小时，才能得到可靠的功耗数据。

坑点3：充电状态下无法准确测量功耗

充电时电池的电流方向是反的，无法通过电流测量来评估应用的实际功耗。功耗测试必须在未充电状态下进行，测试前确保设备已断开充电器。

坑点4：忽略温度对功耗的影响

温度升高会导致电池内阻增大、CPU降频、屏幕亮度自动降低——这些都会影响功耗测量的准确性。功耗测试应在恒温环境中进行，避免阳光直射或靠近热源。

坑点5：后台应用干扰功耗测量

如果测试设备上还有其他应用在后台运行（如社交应用的消息推送、云同步等），它们的功耗会干扰你的测量结果。测试前应关闭所有不必要的应用，或者使用全新的测试设备。

坑点6：过度优化导致用户体验下降

功耗优化不是无底线的降级。如果把动画帧率降到15fps、网络请求间隔设为30秒、传感器采样率降到1Hz，虽然功耗降低了，但用户体验也会严重下降。功耗优化要在"省电"和"好用"之间找到平衡点，建议根据电量等级分级优化。

坑点7：功耗数据采集本身也耗电

定时采样电池信息、读取传感器数据、记录日志——功耗监控本身也会消耗电量。采样频率不要太高（建议不低于3秒一次），测试结束后立即停止监控。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. 应用级功耗统计：HarmonyOS 6新增了应用维度的功耗统计API，可以查询指定应用的CPU时间、网络流量、唤醒次数等功耗相关指标，不再需要依赖全局电池电量变化来推断功耗。

2. 省电模式适配：系统省电模式下，后台任务会受到更严格的限制。应用需要监听省电模式变化，主动调整行为。

3. 热管理回调：新增热等级变化回调，应用可以在设备过热时主动降低功耗，避免被系统强制降频。

适配代码

// HarmonyOS 6功耗统计与省电模式适配
import { powerStats } from '@ohos.powerStats'
import { powerMode } from '@ohos.powerMode'

// 查询应用功耗统计
async function queryAppPowerStats(): Promise<void> {
  try {
    // HarmonyOS 6新增：查询应用CPU使用时间
    const cpuTime = powerStats.getAppCpuTime()
    console.info(`应用CPU使用时间: ${cpuTime}ms`)

    // 查询应用网络流量
    const networkBytes = powerStats.getAppNetworkBytes()
    console.info(`应用网络流量: ${networkBytes}bytes`)

    // 查询应用唤醒次数
    const wakeUpCount = powerStats.getAppWakeUpCount()
    console.info(`应用唤醒次数: ${wakeUpCount}`)
  } catch (error) {
    console.error('查询功耗统计失败:', error)
  }
}

// 监听省电模式变化
function listenPowerModeChange(): void {
  // HarmonyOS 6新增：省电模式监听
  powerMode.on('powerModeChange', (mode: powerMode.PowerMode) => {
    switch (mode) {
      case powerMode.PowerMode.POWER_MODE_NORMAL:
        console.info('正常模式')
        break
      case powerMode.PowerMode.POWER_MODE_SAVE:
        console.info('省电模式，降低功耗策略')
        powerOptimizer.adaptToBatteryLevel(15)  // 触发激进优化
        break
      case powerMode.PowerMode.POWER_MODE_PERFORMANCE:
        console.info('性能模式')
        break
    }
  })
}

// 监听热等级变化
import { thermal } from '@ohos.thermal'

function listenThermalLevel(): void {
  thermal.on('thermalLevelChange', (level: thermal.ThermalLevel) => {
    if (level >= thermal.ThermalLevel.HOT) {
      console.warn('设备过热，主动降低功耗')
      // 降低动画帧率
      // 停止非必要计算
      // 降低网络请求频率
    }
  })
}

六、总结

三维度评价表

功耗优化是一项"良心工程"——用户可能不会因为你的应用省电而给你好评，但一定会因为你的应用费电而给你差评。建议在项目中建立功耗测试规范：每个版本发布前进行标准场景的功耗测试，设置功耗红线（如每小时耗电不超过3%），超标则必须优化。省电不是锦上添花，而是应用品质的基本要求。