HarmonyOS APP开发：电量监控与电量消耗追踪

📌 核心要点：掌握HarmonyOS电量监控API，实现模块级电量追踪、电量消耗告警与优化建议生成，构建完整的电量监控面板，让应用的电量消耗"看得见、管得住"。

一、背景与动机

你有没有想过，你的应用每小时到底消耗多少电量？哪个模块最费电？用户在什么场景下耗电最快？

这些问题，你能回答吗？

大多数开发者的答案是"不知道"。因为电量消耗是一个"黑盒"——你只能看到电池百分比在下降，却不知道是哪个功能、哪段代码、哪个模块在"偷电"。这种"看不见"的问题，让功耗优化变成了"盲人摸象"——你可能在优化一个不耗电的模块，而真正费电的模块却被忽略了。

电量监控的目标就是让功耗"看得见"——通过精确的电量采集、模块级追踪、异常告警和优化建议，让你对应用的电量消耗了如指掌。

想象一下，如果你的应用有一个电量监控面板，能实时显示：

• 当前每小时的耗电率
• 各模块的电量消耗占比
• 异常耗电的告警信息
• 针对性的优化建议

那功耗优化就不再是"猜测"，而是"数据驱动"的精确工程。

本文将带你从电量监控API到完整的监控面板实现，全面掌握电量消耗追踪技术。

二、核心原理

2.1 电量监控体系架构

flowchart TB
    A[电量监控体系] --> B[数据采集层]
    A --> C[数据分析层]
    A --> D[告警与建议层]
    A --> E[可视化展示层]
    
    B --> B1[系统电量API]
    B --> B2[模块级埋点]
    B --> B3[场景级追踪]
    
    C --> C1[电量消耗计算]
    C --> C2[模块消耗归因]
    C --> C3[趋势分析]
    
    D --> D1[阈值告警]
    D --> D2[异常检测]
    D --> D3[优化建议]
    
    E --> E1[实时仪表盘]
    E --> E2[历史趋势图]
    E --> E3[模块排行]
    
    classDef mainStyle fill:#E74C3C,stroke:#C0392B,color:#fff,font-weight:bold
    classDef collectStyle fill:#3498DB,stroke:#2980B9,color:#fff
    classDef analysisStyle fill:#2ECC71,stroke:#27AE60,color:#fff
    classDef alertStyle fill:#F39C12,stroke:#E67E22,color:#fff
    classDef visualStyle fill:#9B59B6,stroke:#8E44AD,color:#fff
    
    class A mainStyle
    class B,B1,B2,B3 collectStyle
    class C,C1,C2,C3 analysisStyle
    class D,D1,D2,D3 alertStyle
    class E,E1,E2,E3 visualStyle

2.2 电量消耗计算模型

电量消耗的核心计算公式：

电量消耗(%) = (起始电量% - 结束电量%) / 监控时长(小时) × 1小时

但这个公式只能计算整体耗电率，无法归因到具体模块。模块级电量追踪需要结合以下方法：

2.3 模块级电量追踪原理

模块级追踪的核心思想是：记录每个模块的活跃时间和操作次数，结合预定义的功耗系数，估算各模块的电量消耗。

模块电量消耗 = 活跃时间 × 基础功耗系数 + 操作次数 × 单次操作功耗

例如：

• 网络模块：活跃5分钟 × 10%/h + 请求100次 × 0.01%/次 = 0.83% + 1% = 1.83%
• 定位模块：活跃10分钟 × 5%/h = 0.83%
• UI渲染模块：活跃30分钟 × 3%/h = 1.5%

三、代码实战

3.1 基础示例：电量监控API封装

// battery_monitor.ets - 电量监控API封装
import { batteryInfo } from '@ohos.batteryInfo'
import { thermal } from '@ohos.thermal'

// 电量采样数据
interface BatterySample {
  timestamp: number             // 时间戳
  level: number                 // 电量百分比(0-100)
  voltage: number               // 电压(微伏)
  current: number               // 电流(微安)
  temperature: number           // 温度(0.1°C)
  status: string                // 充电状态
  health: string                // 电池健康状态
  thermalLevel: string          // 热管理等级
}

// 电量变化事件
interface BatteryChangeEvent {
  timestamp: number
  previousLevel: number
  currentLevel: number
  delta: number                 // 电量变化值（负数表示消耗）
  drainRate: number             // 每小时耗电率
}

// 电量监控器
class BatteryMonitor {
  private samples: BatterySample[] = []
  private events: BatteryChangeEvent[] = []
  private lastLevel: number = 100
  private monitoringInterval: number = -1
  private sampleIntervalMs: number = 10000  // 默认10秒采样
  private isMonitoring: boolean = false
  private onLevelChange: ((event: BatteryChangeEvent) => void) | null = null

  // 开始监控
  start(intervalMs: number = 10000): void {
    if (this.isMonitoring) return

    this.sampleIntervalMs = intervalMs
    this.samples = []
    this.events = []
    this.lastLevel = batteryInfo.batterySOC
    this.isMonitoring = true

    // 立即采集一次
    this.collectSample()

    // 定时采集
    this.monitoringInterval = setInterval(() => {
      this.collectSample()
    }, this.sampleIntervalMs)

    console.info(`电量监控已启动，采样间隔: ${intervalMs}ms`)
  }

  // 停止监控
  stop(): BatterySample[] {
    if (!this.isMonitoring) return this.samples

    clearInterval(this.monitoringInterval)
    this.isMonitoring = false

    // 最后采集一次
    this.collectSample()
    console.info('电量监控已停止')

    return [...this.samples]
  }

  // 采集一次数据
  private collectSample(): void {
    const currentLevel = batteryInfo.batterySOC

    const sample: BatterySample = {
      timestamp: Date.now(),
      level: currentLevel,
      voltage: batteryInfo.voltage,
      current: batteryInfo.currentNow,
      temperature: batteryInfo.batteryTemperature,
      status: this.getBatteryStatus(),
      health: this.getBatteryHealth(),
      thermalLevel: this.getThermalLevel()
    }

    this.samples.push(sample)

    // 检测电量变化
    if (currentLevel !== this.lastLevel) {
      const event: BatteryChangeEvent = {
        timestamp: Date.now(),
        previousLevel: this.lastLevel,
        currentLevel: currentLevel,
        delta: currentLevel - this.lastLevel,
        drainRate: this.calculateDrainRate()
      }

      this.events.push(event)
      this.onLevelChange?.(event)
      this.lastLevel = currentLevel
    }
  }

  // 计算当前耗电率
  private calculateDrainRate(): number {
    if (this.samples.length < 2) return 0

    const first = this.samples[0]
    const last = this.samples[this.samples.length - 1]
    const durationHours = (last.timestamp - first.timestamp) / (1000 * 3600)

    if (durationHours <= 0) return 0

    return (first.level - last.level) / durationHours
  }

  // 获取当前耗电率
  getCurrentDrainRate(): number {
    return this.calculateDrainRate()
  }

  // 获取平均耗电率
  getAverageDrainRate(windowMinutes: number = 30): number {
    const cutoff = Date.now() - windowMinutes * 60 * 1000
    const recentSamples = this.samples.filter(s => s.timestamp >= cutoff)

    if (recentSamples.length < 2) return 0

    const first = recentSamples[0]
    const last = recentSamples[recentSamples.length - 1]
    const durationHours = (last.timestamp - first.timestamp) / (1000 * 3600)

    if (durationHours <= 0) return 0

    return (first.level - last.level) / durationHours
  }

  // 设置电量变化回调
  onBatteryLevelChange(callback: (event: BatteryChangeEvent) => void): void {
    this.onLevelChange = callback
  }

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

  // 获取电池健康状态
  private getBatteryHealth(): string {
    switch (batteryInfo.healthState) {
      case batteryInfo.BatteryHealthState.GOOD: return '良好'
      case batteryInfo.BatteryHealthState.OVERHEAT: return '过热'
      case batteryInfo.BatteryHealthState.OVERVOLTAGE: return '过压'
      case batteryInfo.BatteryHealthState.COLD: return '过冷'
      default: return '未知'
    }
  }

  // 获取热管理等级
  private getThermalLevel(): string {
    try {
      const level = thermal.getThermalLevel()
      const levelMap: Map<number, string> = new Map([
        [0, 'NORMAL'],
        [1, 'COOL'],
        [2, 'WARM'],
        [3, 'HOT'],
        [4, 'OVERHEATED']
      ])
      return levelMap.get(level) || 'UNKNOWN'
    } catch (e) {
      return 'UNKNOWN'
    }
  }

  // 获取所有采样数据
  getSamples(): BatterySample[] {
    return [...this.samples]
  }

  // 获取所有变化事件
  getEvents(): BatteryChangeEvent[] {
    return [...this.events]
  }

  // 获取监控状态
  isRunning(): boolean {
    return this.isMonitoring
  }
}

3.2 进阶示例：模块级电量追踪

// module_tracker.ets - 模块级电量追踪
import { batteryInfo } from '@ohos.batteryInfo'

// 模块功耗系数（%/小时）
const MODULE_POWER_COEFFICIENTS: Record<string, { base: number; perOperation: number }> = {
  'network': { base: 8, perOperation: 0.005 },       // 网络模块
  'location': { base: 12, perOperation: 0.01 },      // 定位模块
  'sensor_accel': { base: 3, perOperation: 0.001 },  // 加速度计
  'sensor_gyro': { base: 5, perOperation: 0.002 },   // 陀螺仪
  'sensor_gps': { base: 15, perOperation: 0.02 },    // GPS
  'ui_render': { base: 4, perOperation: 0 },         // UI渲染
  'animation': { base: 6, perOperation: 0 },         // 动画
  'audio': { base: 5, perOperation: 0 },             // 音频
  'video': { base: 10, perOperation: 0 },            // 视频
  'bluetooth': { base: 4, perOperation: 0.003 },     // 蓝牙
  'storage': { base: 1, perOperation: 0.0005 },      // 存储
  'compute': { base: 8, perOperation: 0.002 },       // 计算
}

// 模块追踪记录
interface ModuleTrackRecord {
  moduleName: string            // 模块名称
  activeStartTime: number       // 活跃开始时间
  activeEndTime: number         // 活跃结束时间
  operationCount: number        // 操作次数
  estimatedPowerPercent: number // 估算电量消耗(%)
}

// 模块追踪状态
interface ModuleTrackState {
  moduleName: string
  isActive: boolean
  startTime: number
  operationCount: number
  totalActiveTime: number       // 累计活跃时间(毫秒)
  totalOperations: number       // 累计操作次数
}

// 模块级电量追踪器
class ModulePowerTracker {
  private moduleStates: Map<string, ModuleTrackState> = new Map()
  private trackHistory: ModuleTrackRecord[] = []
  private batteryMonitor: BatteryMonitor

  constructor(batteryMonitor: BatteryMonitor) {
    this.batteryMonitor = batteryMonitor
  }

  // 模块开始活跃
  moduleActivated(moduleName: string): void {
    if (this.moduleStates.has(moduleName) && this.moduleStates.get(moduleName)!.isActive) {
      return  // 已经活跃
    }

    const state: ModuleTrackState = {
      moduleName: moduleName,
      isActive: true,
      startTime: Date.now(),
      operationCount: 0,
      totalActiveTime: this.moduleStates.get(moduleName)?.totalActiveTime || 0,
      totalOperations: this.moduleStates.get(moduleName)?.totalOperations || 0
    }

    this.moduleStates.set(moduleName, state)
    console.info(`模块激活: ${moduleName}`)
  }

  // 模块停止活跃
  moduleDeactivated(moduleName: string): void {
    const state = this.moduleStates.get(moduleName)
    if (!state || !state.isActive) return

    // 记录本次活跃时长
    const activeDuration = Date.now() - state.startTime
    state.totalActiveTime += activeDuration
    state.isActive = false

    // 估算电量消耗
    const coefficients = MODULE_POWER_COEFFICIENTS[moduleName] || { base: 2, perOperation: 0.001 }
    const activeHours = activeDuration / (1000 * 3600)
    const estimatedPower = activeHours * coefficients.base + state.operationCount * coefficients.perOperation

    // 保存追踪记录
    const record: ModuleTrackRecord = {
      moduleName: moduleName,
      activeStartTime: state.startTime,
      activeEndTime: Date.now(),
      operationCount: state.operationCount,
      estimatedPowerPercent: estimatedPower
    }
    this.trackHistory.push(record)

    // 重置操作计数
    state.totalOperations += state.operationCount
    state.operationCount = 0

    console.info(`模块停用: ${moduleName}, 活跃${(activeDuration / 1000).toFixed(0)}秒, 估算耗电${estimatedPower.toFixed(3)}%`)
  }

  // 记录模块操作
  recordOperation(moduleName: string, count: number = 1): void {
    const state = this.moduleStates.get(moduleName)
    if (!state) return

    state.operationCount += count
  }

  // 获取模块电量消耗报告
  getModulePowerReport(): ModulePowerReport {
    const modulePowers: Map<string, number> = new Map()

    // 计算已完成记录的电量消耗
    for (const record of this.trackHistory) {
      const current = modulePowers.get(record.moduleName) || 0
      modulePowers.set(record.moduleName, current + record.estimatedPowerPercent)
    }

    // 计算当前活跃模块的电量消耗
    this.moduleStates.forEach((state, moduleName) => {
      if (!state.isActive) return

      const coefficients = MODULE_POWER_COEFFICIENTS[moduleName] || { base: 2, perOperation: 0.001 }
      const activeDuration = Date.now() - state.startTime
      const activeHours = activeDuration / (1000 * 3600)
      const estimatedPower = activeHours * coefficients.base + state.operationCount * coefficients.perOperation

      const current = modulePowers.get(moduleName) || 0
      modulePowers.set(moduleName, current + estimatedPower)
    })

    // 排序
    const sortedModules = Array.from(modulePowers.entries())
      .sort((a, b) => b[1] - a[1])

    const totalPower = sortedModules.reduce((sum, [_, power]) => sum + power, 0)

    return {
      totalEstimatedPower: totalPower,
      moduleBreakdown: sortedModules.map(([name, power]) => ({
        moduleName: name,
        estimatedPower: power,
        percentage: totalPower > 0 ? (power / totalPower * 100) : 0
      })),
      activeModules: Array.from(this.moduleStates.entries())
        .filter(([_, state]) => state.isActive)
        .map(([name]) => name)
    }
  }

  // 获取模块活跃时间统计
  getModuleTimeStats(): Map<string, { activeTime: number; operationCount: number }> {
    const stats: Map<string, { activeTime: number; operationCount: number }> = new Map()

    this.moduleStates.forEach((state, moduleName) => {
      let activeTime = state.totalActiveTime
      let opCount = state.totalOperations

      if (state.isActive) {
        activeTime += Date.now() - state.startTime
        opCount += state.operationCount
      }

      stats.set(moduleName, { activeTime: activeTime, operationCount: opCount })
    })

    return stats
  }

  // 重置追踪数据
  reset(): void {
    this.moduleStates.clear()
    this.trackHistory = []
  }
}

// 模块电量报告
interface ModulePowerReport {
  totalEstimatedPower: number
  moduleBreakdown: {
    moduleName: string
    estimatedPower: number
    percentage: number
  }[]
  activeModules: string[]
}

3.3 完整示例：电量监控面板与告警系统

// power_dashboard.ets - 电量监控面板与告警系统
import { batteryInfo } from '@ohos.batteryInfo'

// 告警级别
enum AlertLevel {
  INFO = 'info',
  WARNING = 'warning',
  CRITICAL = 'critical'
}

// 告警事件
interface AlertEvent {
  level: AlertLevel
  title: string
  message: string
  timestamp: number
  suggestion: string
}

// 告警规则
interface AlertRule {
  name: string
  level: AlertLevel
  condition: (context: AlertContext) => boolean
  message: string
  suggestion: string
}

// 告警上下文
interface AlertContext {
  currentLevel: number
  drainRate: number
  activeModules: string[]
  temperature: number
  thermalLevel: string
  duration: number
}

// 优化建议
interface OptimizationSuggestion {
  category: string
  priority: number
  description: string
  estimatedSaving: string
  action: string
}

// 电量监控面板
@Entry
@Component
struct PowerDashboardPage {
  @State currentBatteryLevel: number = 100
  @State drainRate: number = 0
  @State drainLevel: string = '🟢 低功耗'
  @State activeModules: string[] = []
  @State moduleBreakdown: { moduleName: string; estimatedPower: number; percentage: number }[] = []
  @State alerts: AlertEvent[] = []
  @State suggestions: OptimizationSuggestion[] = []
  @State monitoringDuration: string = '0分钟'
  @State temperature: number = 25

  private batteryMonitor: BatteryMonitor = new BatteryMonitor()
  private moduleTracker: ModulePowerTracker = new ModulePowerTracker(this.batteryMonitor)
  private alertRules: AlertRule[] = []
  private dashboardTimer: number = -1

  aboutToAppear(): void {
    // 初始化告警规则
    this.initAlertRules()

    // 启动监控
    this.batteryMonitor.start(5000)
    this.batteryMonitor.onBatteryLevelChange((event) => {
      this.handleBatteryChange(event)
    })

    // 模拟模块激活（实际应用中由业务逻辑触发）
    this.moduleTracker.moduleActivated('network')
    this.moduleTracker.moduleActivated('ui_render')

    // 启动面板刷新
    this.dashboardTimer = setInterval(() => {
      this.refreshDashboard()
    }, 3000)

    // 首次刷新
    this.refreshDashboard()
  }

  aboutToDisappear(): void {
    this.batteryMonitor.stop()
    this.moduleTracker.moduleDeactivated('network')
    this.moduleTracker.moduleDeactivated('ui_render')
    clearInterval(this.dashboardTimer)
  }

  build() {
    Scroll() {
      Column() {
        // 顶部电量概览
        this.BatteryOverview()

        // 模块电量排行
        this.ModuleBreakdown()

        // 告警列表
        this.AlertList()

        // 优化建议
        this.OptimizationSuggestions()
      }
      .width('100%')
      .padding(16)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
  }

  // 电量概览
  @Builder
  BatteryOverview() {
    Column() {
      Text('电量监控面板')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ bottom: 20 })

      // 电量圆环
      Stack() {
        // 背景圆环
        Progress({ value: 100, total: 100, type: ProgressType.Ring })
          .width(150)
          .height(150)
          .color('#E0E0E0')

        // 电量圆环
        Progress({ value: this.currentBatteryLevel, total: 100, type: ProgressType.Ring })
          .width(150)
          .height(150)
          .color(this.getBatteryColor())
          .style({ strokeWidth: 12 })

        // 电量文字
        Column() {
          Text(`${this.currentBatteryLevel}%`)
            .fontSize(36)
            .fontWeight(FontWeight.Bold)
          Text(this.drainLevel)
            .fontSize(14)
            .margin({ top: 4 })
        }
      }
      .margin({ bottom: 20 })

      // 关键指标
      Row() {
        this.MetricCard('耗电率', `${this.drainRate.toFixed(1)}%/h`, this.getDrainRateColor())
        this.MetricCard('温度', `${this.temperature.toFixed(0)}°C`, this.temperature > 40 ? '#E74C3C' : '#2ECC71')
        this.MetricCard('监控时长', this.monitoringDuration, '#3498DB')
      }
      .width('100%')
      .justifyContent(FlexAlign.SpaceAround)
    }
    .width('100%')
    .padding(20)
    .backgroundColor(Color.White)
    .borderRadius(16)
  }

  // 指标卡片
  @Builder
  MetricCard(title: string, value: string, color: string) {
    Column() {
      Text(title)
        .fontSize(12)
        .fontColor('#999999')
      Text(value)
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
        .fontColor(color)
        .margin({ top: 4 })
    }
    .alignItems(HorizontalAlign.Center)
  }

  // 模块电量排行
  @Builder
  ModuleBreakdown() {
    Column() {
      Text('模块电量排行')
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
        .margin({ bottom: 12 })

      if (this.moduleBreakdown.length === 0) {
        Text('暂无数据')
          .fontSize(14)
          .fontColor('#999999')
      }

      ForEach(this.moduleBreakdown, (item: { moduleName: string; estimatedPower: number; percentage: number }) => {
        Row() {
          Text(this.getModuleDisplayName(item.moduleName))
            .fontSize(14)
            .width(80)

          Progress({ value: item.percentage, total: 100, type: ProgressType.Linear })
            .width('50%')
            .height(8)
            .color(this.getModuleColor(item.moduleName))

          Text(`${item.percentage.toFixed(1)}%`)
            .fontSize(12)
            .fontColor('#666666')
            .width(50)
            .textAlign(TextAlign.End)
        }
        .width('100%')
        .margin({ bottom: 8 })
      })
    }
    .width('100%')
    .padding(16)
    .backgroundColor(Color.White)
    .borderRadius(16)
    .margin({ top: 12 })
  }

  // 告警列表
  @Builder
  AlertList() {
    Column() {
      Text('告警信息')
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
        .margin({ bottom: 12 })

      if (this.alerts.length === 0) {
        Row() {
          Text('✅')
            .fontSize(16)
          Text('暂无告警')
            .fontSize(14)
            .fontColor('#999999')
            .margin({ left: 8 })
        }
      }

      ForEach(this.alerts.slice(0, 5), (alert: AlertEvent) => {
        Row() {
          Text(alert.level === AlertLevel.CRITICAL ? '🔴' : alert.level === AlertLevel.WARNING ? '🟡' : '🟢')
            .fontSize(16)
          Column() {
            Text(alert.title)
              .fontSize(14)
              .fontWeight(FontWeight.Medium)
            Text(alert.message)
              .fontSize(12)
              .fontColor('#666666')
              .margin({ top: 2 })
          }
          .alignItems(HorizontalAlign.Start)
          .margin({ left: 8 })
          .layoutWeight(1)
        }
        .width('100%')
        .padding(8)
        .backgroundColor('#FFF8E1')
        .borderRadius(8)
        .margin({ bottom: 8 })
      })
    }
    .width('100%')
    .padding(16)
    .backgroundColor(Color.White)
    .borderRadius(16)
    .margin({ top: 12 })
  }

  // 优化建议
  @Builder
  OptimizationSuggestions() {
    Column() {
      Text('优化建议')
        .fontSize(18)
        .fontWeight(FontWeight.Bold)
        .margin({ bottom: 12 })

      ForEach(this.suggestions, (suggestion: OptimizationSuggestion) => {
        Row() {
          Column() {
            Text(suggestion.description)
              .fontSize(14)
            Text(`预计节省: ${suggestion.estimatedSaving}`)
              .fontSize(12)
              .fontColor('#4CAF50')
              .margin({ top: 4 })
          }
          .alignItems(HorizontalAlign.Start)
          .layoutWeight(1)
        }
        .width('100%')
        .padding(12)
        .backgroundColor('#E8F5E9')
        .borderRadius(8)
        .margin({ bottom: 8 })
      })
    }
    .width('100%')
    .padding(16)
    .backgroundColor(Color.White)
    .borderRadius(16)
    .margin({ top: 12 })
  }

  // 初始化告警规则
  private initAlertRules(): void {
    this.alertRules = [
      {
        name: '高耗电率',
        level: AlertLevel.CRITICAL,
        condition: (ctx) => ctx.drainRate > 10,
        message: `当前耗电率${ctx.drainRate.toFixed(1)}%/h，远超正常水平`,
        suggestion: '检查后台任务、网络请求和传感器使用'
      },
      {
        name: '中等耗电率',
        level: AlertLevel.WARNING,
        condition: (ctx) => ctx.drainRate > 5 && ctx.drainRate <= 10,
        message: `当前耗电率${ctx.drainRate.toFixed(1)}%/h，偏高`,
        suggestion: '考虑降低网络请求频率或传感器采样率'
      },
      {
        name: '设备过热',
        level: AlertLevel.WARNING,
        condition: (ctx) => ctx.temperature > 40,
        message: `设备温度${ctx.temperature.toFixed(0)}°C，偏高`,
        suggestion: '减少CPU密集型操作，降低动画帧率'
      },
      {
        name: '低电量',
        level: AlertLevel.WARNING,
        condition: (ctx) => ctx.currentLevel <= 20,
        message: `电量仅剩${ctx.currentLevel}%`,
        suggestion: '建议启用低功耗模式，暂停非关键功能'
      },
      {
        name: '多模块同时活跃',
        level: AlertLevel.INFO,
        condition: (ctx) => ctx.activeModules.length > 3,
        message: `${ctx.activeModules.length}个模块同时活跃`,
        suggestion: '检查是否可以按需启停部分模块'
      }
    ]
  }

  // 处理电量变化
  private handleBatteryChange(event: BatteryChangeEvent): void {
    this.currentBatteryLevel = event.currentLevel
    this.drainRate = Math.abs(event.delta)

    // 检查告警
    this.checkAlerts()
  }

  // 检查告警
  private checkAlerts(): void {
    const report = this.moduleTracker.getModulePowerReport()
    const context: AlertContext = {
      currentLevel: this.currentBatteryLevel,
      drainRate: this.drainRate,
      activeModules: report.activeModules,
      temperature: this.temperature,
      thermalLevel: 'NORMAL',
      duration: 0
    }

    const newAlerts: AlertEvent[] = []
    for (const rule of this.alertRules) {
      if (rule.condition(context)) {
        newAlerts.push({
          level: rule.level,
          title: rule.name,
          message: rule.message.replace('ctx.drainRate', String(context.drainRate))
            .replace('ctx.currentLevel', String(context.currentLevel))
            .replace('ctx.temperature', String(context.temperature))
            .replace('ctx.activeModules.length', String(context.activeModules.length)),
          timestamp: Date.now(),
          suggestion: rule.suggestion
        })
      }
    }

    this.alerts = newAlerts

    // 生成优化建议
    this.generateSuggestions(context, report)
  }

  // 生成优化建议
  private generateSuggestions(context: AlertContext, report: ModulePowerReport): void {
    const suggestions: OptimizationSuggestion[] = []

    // 根据模块排行生成建议
    for (const module of report.moduleBreakdown) {
      if (module.percentage > 30) {
        switch (module.moduleName) {
          case 'network':
            suggestions.push({
              category: '网络',
              priority: 1,
              description: '网络模块是最大功耗来源，建议合并请求、启用缓存',
              estimatedSaving: '30%-50%网络功耗',
              action: '启用请求批处理和智能缓存'
            })
            break
          case 'location':
            suggestions.push({
              category: '定位',
              priority: 1,
              description: '定位模块功耗较高，建议降低精度或使用WiFi定位',
              estimatedSaving: '50%-70%定位功耗',
              action: '切换到低功耗定位模式'
            })
            break
          case 'sensor_gps':
            suggestions.push({
              category: 'GPS',
              priority: 1,
              description: 'GPS持续运行功耗极高，建议按需启停',
              estimatedSaving: '60%-80%GPS功耗',
              action: '使用距离过滤和按需启停策略'
            })
            break
        }
      }
    }

    // 通用建议
    if (context.drainRate > 5) {
      suggestions.push({
        category: '通用',
        priority: 2,
        description: '整体耗电率偏高，建议检查后台任务和定时器',
        estimatedSaving: '20%-40%总功耗',
        action: '审查后台行为，清理不必要的定时任务'
      })
    }

    this.suggestions = suggestions.sort((a, b) => a.priority - b.priority)
  }

  // 刷新面板数据
  private refreshDashboard(): void {
    this.currentBatteryLevel = batteryInfo.batterySOC
    this.drainRate = this.batteryMonitor.getCurrentDrainRate()
    this.temperature = batteryInfo.batteryTemperature / 10

    // 更新耗电等级
    if (this.drainRate < 2) {
      this.drainLevel = '🟢 低功耗'
    } else if (this.drainRate < 5) {
      this.drainLevel = '🟡 中等功耗'
    } else if (this.drainRate < 10) {
      this.drainLevel = '🟠 较高功耗'
    } else {
      this.drainLevel = '🔴 高功耗'
    }

    // 更新模块数据
    const report = this.moduleTracker.getModulePowerReport()
    this.moduleBreakdown = report.moduleBreakdown
    this.activeModules = report.activeModules

    // 检查告警
    this.checkAlerts()
  }

  // 辅助方法
  private getBatteryColor(): string {
    if (this.currentBatteryLevel > 50) return '#4CAF50'
    if (this.currentBatteryLevel > 20) return '#FF9800'
    return '#E74C3C'
  }

  private getDrainRateColor(): string {
    if (this.drainRate < 2) return '#4CAF50'
    if (this.drainRate < 5) return '#FF9800'
    return '#E74C3C'
  }

  private getModuleDisplayName(name: string): string {
    const displayNames: Record<string, string> = {
      'network': '网络',
      'location': '定位',
      'sensor_accel': '加速度计',
      'sensor_gyro': '陀螺仪',
      'sensor_gps': 'GPS',
      'ui_render': 'UI渲染',
      'animation': '动画',
      'audio': '音频',
      'video': '视频',
      'bluetooth': '蓝牙',
      'storage': '存储',
      'compute': '计算'
    }
    return displayNames[name] || name
  }

  private getModuleColor(name: string): string {
    const colors: Record<string, string> = {
      'network': '#3498DB',
      'location': '#E74C3C',
      'sensor_accel': '#2ECC71',
      'sensor_gyro': '#F39C12',
      'sensor_gps': '#E74C3C',
      'ui_render': '#9B59B6',
      'animation': '#1ABC9C',
      'audio': '#3498DB',
      'video': '#E74C3C',
      'bluetooth': '#2ECC71',
      'storage': '#95A5A6',
      'compute': '#F39C12'
    }
    return colors[name] || '#3498DB'
  }
}

四、踩坑与注意事项

坑点1：电量API的精度限制

batteryInfo.batterySOC返回的是整数百分比（0-100），精度只有1%。这意味着短时间内（几分钟）的电量变化可能无法被检测到。电量监控需要足够长的采样时间才能得到有意义的数据，建议至少监控30分钟以上。

坑点2：模块级功耗估算是近似值

本文实现的模块级功耗追踪基于"活跃时间 × 功耗系数"的估算模型，并非精确测量。不同设备、不同使用场景下的实际功耗可能与估算值有较大偏差。模块级追踪的目的是发现"功耗热点"，而非精确计量。

坑点3：电量监控本身也消耗电量

定时采样电池信息、计算耗电率、更新UI——监控面板本身也在消耗电量。在Release版本中，电量监控应该是按需启用的，而不是默认常驻。建议仅在开发者模式或用户主动开启时才启动监控。

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

充电时电池电量在增加，无法通过电量变化来衡量应用的功耗。电量监控功能应在未充电状态下使用，或在UI上明确提示"充电中，功耗数据不可用"。

坑点5：告警阈值设置不合理

告警阈值太低会导致频繁误报，让用户对告警"免疫"；阈值太高则可能遗漏真正的功耗问题。告警阈值应根据实际测试数据来设定，而不是凭经验猜测。建议先收集一段时间的基线数据，再根据统计分布设定阈值。

坑点6：忽略系统省电模式的影响

系统省电模式会限制后台活动、降低CPU频率、缩短屏幕超时——这些都会影响你的功耗测量结果。在分析功耗数据时，要考虑设备是否处于省电模式，不同模式下的数据不应直接对比。

坑点7：电量监控数据未持久化

如果应用被杀死或设备重启，内存中的监控数据就会丢失。对于重要的功耗分析数据，应持久化到本地存储，便于后续分析和问题排查。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. 电量变化事件驱动：HarmonyOS 6新增了电量变化的回调机制，不再需要轮询batterySOC，系统会在电量变化时主动通知应用，减少了不必要的采样开销。

2. 应用级功耗统计：新增@ohos.powerStats模块，可以查询应用的CPU使用时间、网络流量、唤醒次数等功耗指标，比自行估算更准确。

3. 模块级功耗归因：新增@ohos.powerAttribution模块，系统可以告诉你应用中各子系统（网络、定位、传感器等）的功耗占比。

适配代码

// HarmonyOS 6电量变化事件驱动
import { batteryInfo } from '@ohos.batteryInfo'
import { powerStats } from '@ohos.powerStats'

// 监听电量变化（事件驱动，无需轮询）
function listenBatteryChange(): void {
  // HarmonyOS 6新增：电量变化回调
  batteryInfo.on('batteryLevelChange', (level: number) => {
    console.info(`电量变化: ${level}%`)
  })
}

// 查询应用功耗统计
async function queryPowerStats(): Promise<void> {
  try {
    // HarmonyOS 6新增：应用级功耗统计
    const stats = powerStats.getAppPowerStats()
    console.info(`CPU使用时间: ${stats.cpuTimeMs}ms`)
    console.info(`网络流量: ${stats.networkBytes}bytes`)
    console.info(`唤醒次数: ${stats.wakeUpCount}`)
    console.info(`GPS使用时间: ${stats.gpsTimeMs}ms`)
  } catch (error) {
    console.error('查询功耗统计失败:', error)
  }
}

// 查询模块级功耗归因
async function queryPowerAttribution(): Promise<void> {
  try {
    // HarmonyOS 6新增：模块级功耗归因
    const attribution = powerStats.getPowerAttribution()
    console.info(`网络功耗占比: ${attribution.network}%`)
    console.info(`定位功耗占比: ${attribution.location}%`)
    console.info(`传感器功耗占比: ${attribution.sensor}%`)
    console.info(`CPU功耗占比: ${attribution.cpu}%`)
    console.info(`屏幕功耗占比: ${attribution.screen}%`)
  } catch (error) {
    console.error('查询功耗归因失败:', error)
  }
}

六、总结

三维度评价表

电量监控是功耗优化的"基础设施"——没有监控，优化就是盲目的；有了监控，优化才能有的放矢。建议在项目中集成电量监控面板（至少在Debug模式下），持续跟踪应用的功耗表现。让功耗"看得见"，是功耗优化的第一步。当你能清楚地看到每个模块的电量消耗，优化就不再是猜测，而是精确的工程决策。