HarmonyOS APP开发：温度传感器与热管理

核心要点：本文系统讲解HarmonyOS温度传感器的数据采集、热管理策略设计、设备温控降频机制以及基于温度感知的应用自适应调节方案，涵盖从底层传感器订阅到上层热管理策略的完整技术链路。

一、背景与动机

1.1 为什么需要温度传感器

移动设备的散热问题一直是制约性能释放的核心瓶颈。随着芯片集成度不断提高，SoC功耗密度持续攀升，温度管理已经从简单的硬件保护演变为系统级智能调度：

• 性能与温度的博弈：高性能模式产生更多热量，需要温度传感器实时监控以决定何时降频
• 用户舒适度保障：设备表面温度超过45°C会引起不适，超过50°C可能造成低温烫伤
• 电池安全：锂电池在0°C~45°C范围内工作最佳，超出范围需要限制充放电
• 应用自适应：根据温度动态调整应用行为（如降低视频分辨率、减少后台刷新）

1.2 HarmonyOS热管理架构

HarmonyOS构建了从硬件温控到应用自适应的完整热管理体系：

flowchart TB
    subgraph HW["硬件层"]
        H1["SoC温度传感器<br/>CPU/GPU/NPU"]
        H2["电池温度传感器<br/>电芯NTC"]
        H3["主板温度传感器<br/>PCB热敏电阻"]
        H4["环境温度传感器<br/>外部NTC"]
    end

    subgraph Kernel["内核层"]
        K1["Thermal Zone<br/>温度区域管理"]
        K2["Thermal Governor<br/>温控策略引擎"]
        K3["Cooling Device<br/>冷却设备驱动"]
    end

    subgraph FW["框架层"]
        F1["Thermal Manager<br/>热管理服务"]
        F2["温控等级判定<br/>Level 0-6"]
        F3["降频策略<br/>CPU/GPU频率调节"]
        F4["充电控制<br/>限充/停充"]
    end

    subgraph APP["应用层"]
        A1["@ohos.thermal API"]
        A2["应用自适应策略"]
        A3["用户温控通知"]
    end

    H1 --> K1
    H2 --> K1
    H3 --> K1
    H4 --> K1
    K1 --> K2 --> K3
    K1 --> F1
    K2 --> F2
    F2 --> F3
    F2 --> F4
    F1 --> A1
    F2 --> A2
    F2 --> A3

    classDef hwStyle fill:#1a1a2e,stroke:#e94560,color:#eee,stroke-width:2px
    classDef kernelStyle fill:#16213e,stroke:#0f3460,color:#eee,stroke-width:2px
    classDef fwStyle fill:#0f3460,stroke:#533483,color:#eee,stroke-width:2px
    classDef appStyle fill:#533483,stroke:#e94560,color:#eee,stroke-width:2px

    class H1,H2,H3,H4 hwStyle
    class K1,K2,K3 kernelStyle
    class F1,F2,F3,F4 fwStyle
    class A1,A2,A3 appStyle

1.3 HarmonyOS温控等级体系

HarmonyOS定义了7个温控等级，每个等级对应不同的降频和限制策略：

二、核心原理

2.1 温度传感器工作原理

HarmonyOS设备中常见的温度传感器类型：

NTC热敏电阻（Negative Temperature Coefficient）

• 原理：电阻值随温度升高而降低
• 特点：精度高（±0.5°C）、响应快、成本低
• 应用：电池温度、主板温度监测

数字温度传感器（如TMP103）

• 原理：基于硅带隙基准的温度-数字转换
• 特点：直接输出数字值、I2C接口
• 应用：SoC温度、环境温度监测

热电偶（Thermocouple）

• 原理：两种不同金属的接点产生温差电动势
• 特点：测温范围宽、响应极快
• 应用：极端环境温度监测

2.2 温度数据融合

设备上存在多个温度传感器，需要融合处理以获得准确的温度估计：

flowchart LR
    subgraph Sensors["多温度传感器"]
        S1["SoC温度<br/>T₁"]
        S2["电池温度<br/>T₂"]
        S3["主板温度<br/>T₃"]
        S4["环境温度<br/>T₄"]
    end

    subgraph Fusion["温度融合引擎"]
        F1["异常值过滤<br/>3σ准则"]
        F2["加权平均<br/>W₁T₁+W₂T₂+..."]
        F3["热模型补偿<br/>传导延迟修正"]
    end

    subgraph Output["输出"]
        O1["设备综合温度"]
        O2["温控等级判定"]
        O3["趋势预测"]
    end

    S1 --> F1
    S2 --> F1
    S3 --> F1
    S4 --> F1
    F1 --> F2 --> F3
    F3 --> O1
    F3 --> O2
    F3 --> O3

    classDef sensorStyle fill:#1a1a2e,stroke:#e94560,color:#eee,stroke-width:2px
    classDef fusionStyle fill:#0f3460,stroke:#533483,color:#eee,stroke-width:2px
    classDef outputStyle fill:#533483,stroke:#e94560,color:#eee,stroke-width:2px

    class S1,S2,S3,S4 sensorStyle
    class F1,F2,F3 fusionStyle
    class O1,O2,O3 outputStyle

2.3 热传导模型

设备内部的热传导遵循傅里叶热传导定律。简化的一维热传导方程为：

dT/dt = α · d²T/dx² + Q/(ρ·c·V)

其中：

• T：温度，t：时间，x：空间坐标
• α：热扩散率，Q：热源功率
• ρ：材料密度，c：比热容，V：体积

在实际应用中，我们使用简化的集总参数模型来描述SoC温度变化：

T(t+Δt) = T(t) + [Q(t) - (T(t) - T_ambient) / R_thermal] · Δt / C_thermal

• R_thermal：热阻（°C/W），表征散热能力
• C_thermal：热容（J/°C），表征储热能力
• Q(t)：当前功耗（W）

三、代码实战

3.1 温度传感器数据订阅与监控

// TemperatureMonitor.ets - 温度传感器数据订阅与实时监控
import sensor from '@ohos.sensor';
import thermal from '@ohos.thermal';
import { BusinessError } from '@ohos.base';

// 温度传感器数据接口
interface TemperatureSensorData {
  temperature: number;  // 温度值（°C）
  timestamp: number;    // 时间戳（纳秒）
}

// 温度等级枚举（与系统温控等级对应）
enum ThermalLevel {
  NORMAL = 'NORMAL',
  WARM = 'WARM',
  HOT = 'HOT',
  OVERHEATED = 'OVERHEATED',
  WARNING = 'WARNING',
  ESCAPE = 'ESCAPE',
  EMERGENCY = 'EMERGENCY'
}

// 温度数据记录
interface TemperatureRecord {
  value: number;        // 温度值
  timestamp: number;    // 记录时间
  level: ThermalLevel;  // 温控等级
}

@Entry
@Component
struct TemperatureMonitorPage {
  // 当前温度
  @State currentTemp: number = 25;
  // 系统温控等级
  @State thermalLevel: ThermalLevel = ThermalLevel.NORMAL;
  // 温度历史记录
  @State tempHistory: TemperatureRecord[] = [];
  // 最高温度记录
  @State maxTemp: number = -Infinity;
  // 最低温度记录
  @State minTemp: number = Infinity;
  // 温度趋势（上升/稳定/下降）
  @State tempTrend: string = '稳定';
  // 是否监控中
  @State isMonitoring: boolean = false;
  // 告警信息
  @State alerts: string[] = [];

  // 传感器订阅ID
  private subscriberId: number = -1;
  // 温度滑动窗口（用于趋势计算）
  private tempWindow: number[] = [];
  // 窗口大小
  private readonly WINDOW_SIZE: number = 20;

  aboutToAppear() {
    this.startMonitoring();
  }

  aboutToDisappear() {
    this.stopMonitoring();
  }

  /**
   * 启动温度监控
   */
  private startMonitoring(): void {
    try {
      // 订阅环境温度传感器
      if (sensor.isSensorAvailable(sensor.SensorType.AMBIENT_TEMPERATURE)) {
        this.subscriberId = sensor.on(
          sensor.SensorType.AMBIENT_TEMPERATURE,
          (data: TemperatureSensorData) => {
            this.onTemperatureUpdate(data.temperature);
          },
          { interval: 1000000000 } // 1秒采样间隔
        );
      }

      // 同时订阅系统温控等级变化
      this.subscribeThermalLevel();

      this.isMonitoring = true;
    } catch (error) {
      const err = error as BusinessError;
      this.addAlert(`温度监控启动失败: ${err.message}`);
    }
  }

  /**
   * 停止温度监控
   */
  private stopMonitoring(): void {
    if (this.subscriberId !== -1) {
      try {
        sensor.off(sensor.SensorType.AMBIENT_TEMPERATURE, this.subscriberId);
        this.subscriberId = -1;
      } catch (e) {
        // 忽略
      }
    }
    this.isMonitoring = false;
  }

  /**
   * 订阅系统温控等级变化
   */
  private subscribeThermalLevel(): void {
    try {
      thermal.subscribeThermalLevel((level: thermal.ThermalLevel) => {
        this.thermalLevel = this.mapThermalLevel(level);
        this.addAlert(`温控等级变更: ${this.thermalLevel}`);
      });
    } catch (error) {
      // 温控等级订阅失败，使用本地判定
      this.addAlert('系统温控等级订阅失败，使用本地判定');
    }
  }

  /**
   * 映射系统温控等级到应用枚举
   */
  private mapThermalLevel(level: thermal.ThermalLevel): ThermalLevel {
    const levelMap: Record<number, ThermalLevel> = {
      0: ThermalLevel.NORMAL,
      1: ThermalLevel.WARM,
      2: ThermalLevel.HOT,
      3: ThermalLevel.OVERHEATED,
      4: ThermalLevel.WARNING,
      5: ThermalLevel.ESCAPE,
      6: ThermalLevel.EMERGENCY
    };
    return levelMap[level] || ThermalLevel.NORMAL;
  }

  /**
   * 温度更新回调
   */
  private onTemperatureUpdate(temperature: number): void {
    this.currentTemp = Math.round(temperature * 10) / 10;

    // 更新极值
    if (this.currentTemp > this.maxTemp) {
      this.maxTemp = this.currentTemp;
    }
    if (this.currentTemp < this.minTemp) {
      this.minTemp = this.currentTemp;
    }

    // 更新滑动窗口
    this.tempWindow.push(this.currentTemp);
    if (this.tempWindow.length > this.WINDOW_SIZE) {
      this.tempWindow.shift();
    }

    // 计算温度趋势
    this.tempTrend = this.calculateTrend();

    // 记录历史
    const record: TemperatureRecord = {
      value: this.currentTemp,
      timestamp: Date.now(),
      level: this.thermalLevel
    };
    this.tempHistory.push(record);
    if (this.tempHistory.length > 200) {
      this.tempHistory.shift();
    }

    // 本地温控等级判定（当系统订阅不可用时）
    this.evaluateThermalLevelLocally(temperature);
  }

  /**
   * 计算温度趋势
   */
  private calculateTrend(): string {
    if (this.tempWindow.length < 5) return '数据不足';

    const recent = this.tempWindow.slice(-5);
    const older = this.tempWindow.slice(-10, -5);

    if (older.length === 0) return '稳定';

    const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;
    const olderAvg = older.reduce((a, b) => a + b, 0) / older.length;
    const diff = recentAvg - olderAvg;

    if (diff > 1.0) return '↑ 上升';
    if (diff < -1.0) return '↓ 下降';
    return '→ 稳定';
  }

  /**
   * 本地温控等级判定
   */
  private evaluateThermalLevelLocally(temp: number): void {
    let level: ThermalLevel;
    if (temp < 35) level = ThermalLevel.NORMAL;
    else if (temp < 40) level = ThermalLevel.WARM;
    else if (temp < 45) level = ThermalLevel.HOT;
    else if (temp < 48) level = ThermalLevel.OVERHEATED;
    else if (temp < 52) level = ThermalLevel.WARNING;
    else if (temp < 55) level = ThermalLevel.ESCAPE;
    else level = ThermalLevel.EMERGENCY;

    if (level !== this.thermalLevel) {
      this.thermalLevel = level;
    }
  }

  /**
   * 添加告警
   */
  private addAlert(message: string): void {
    const time = new Date().toLocaleTimeString();
    this.alerts.unshift(`[${time}] ${message}`);
    if (this.alerts.length > 30) this.alerts.pop();
  }

  /**
   * 获取温控等级对应颜色
   */
  private getLevelColor(level: ThermalLevel): string {
    const colorMap: Record<string, string> = {
      'NORMAL': '#4caf50',
      'WARM': '#ff9800',
      'HOT': '#ff5722',
      'OVERHEATED': '#f44336',
      'WARNING': '#d32f2f',
      'ESCAPE': '#b71c1c',
      'EMERGENCY': '#880e4f'
    };
    return colorMap[level] || '#4caf50';
  }

  build() {
    Scroll() {
      Column() {
        // 标题
        Text('温度传感器与热管理')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor('#e0e0e0')
          .margin({ bottom: 24 })

        // 当前温度卡片
        Column() {
          Text('当前设备温度')
            .fontSize(14)
            .fontColor('#888888')
          Row() {
            Text(`${this.currentTemp}`)
              .fontSize(56)
              .fontWeight(FontWeight.Bold)
              .fontColor(this.getLevelColor(this.thermalLevel))
            Text('°C')
              .fontSize(24)
              .fontColor('#aaaaaa')
              .margin({ left: 4, bottom: 8 })
          }
          .alignItems(VerticalAlign.Bottom)

          // 温控等级标签
          Row() {
            Text(this.thermalLevel)
              .fontSize(16)
              .fontWeight(FontWeight.Bold)
              .fontColor('#ffffff')
              .padding({ left: 12, right: 12, top: 4, bottom: 4 })
              .borderRadius(12)
              .backgroundColor(this.getLevelColor(this.thermalLevel))
            Text(`  趋势: ${this.tempTrend}`)
              .fontSize(14)
              .fontColor('#888888')
          }
          .margin({ top: 8 })
        }
        .width('90%')
        .padding(24)
        .borderRadius(16)
        .backgroundColor('#1a1a2e')
        .margin({ bottom: 16 })

        // 温度统计
        Row() {
          Column() {
            Text('最低温度')
              .fontSize(12)
              .fontColor('#888888')
            Text(`${this.minTemp === Infinity ? '--' : this.minTemp}°C`)
              .fontSize(20)
              .fontWeight(FontWeight.Bold)
              .fontColor('#4caf50')
          }
          .layoutWeight(1)

          Column() {
            Text('最高温度')
              .fontSize(12)
              .fontColor('#888888')
            Text(`${this.maxTemp === -Infinity ? '--' : this.maxTemp}°C`)
              .fontSize(20)
              .fontWeight(FontWeight.Bold)
              .fontColor('#f44336')
          }
          .layoutWeight(1)

          Column() {
            Text('温差')
              .fontSize(12)
              .fontColor('#888888')
            Text(`${this.maxTemp !== -Infinity && this.minTemp !== Infinity ?
              (this.maxTemp - this.minTemp).toFixed(1) : '--'}°C`)
              .fontSize(20)
              .fontWeight(FontWeight.Bold)
              .fontColor('#533483')
          }
          .layoutWeight(1)
        }
        .width('90%')
        .padding(16)
        .borderRadius(12)
        .backgroundColor('#1a1a2e')
        .margin({ bottom: 16 })

        // 告警日志
        Column() {
          Text('温控日志')
            .fontSize(14)
            .fontColor('#888888')
            .margin({ bottom: 8 })
          ForEach(this.alerts.slice(0, 8), (alert: string) => {
            Text(alert)
              .fontSize(11)
              .fontColor('#666666')
              .width('100%')
              .margin({ bottom: 2 })
          })
        }
        .width('90%')
        .padding(16)
        .borderRadius(12)
        .backgroundColor('#1a1a2e')
        .alignItems(HorizontalAlign.Start)
      }
      .width('100%')
      .padding(16)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0a0a1a')
  }
}

3.2 智能热管理策略引擎

// ThermalManager.ets - 智能热管理策略引擎

/**
 * 热管理策略配置
 */
interface ThermalPolicy {
  level: ThermalLevel;           // 温控等级
  maxCpuFreq: number;            // CPU最大频率（MHz）
  maxGpuFreq: number;            // GPU最大频率（MHz）
  maxBrightness: number;         // 最大屏幕亮度（0-255）
  chargingEnabled: boolean;      // 是否允许充电
  maxChargingCurrent: number;    // 最大充电电流（mA）
  backgroundRefreshInterval: number; // 后台刷新间隔（秒）
  videoMaxResolution: number;    // 视频最大分辨率（p）
  thermalAlertMessage: string;   // 温控告警消息
}

/**
 * 温控等级枚举
 */
enum ThermalLevel {
  NORMAL = 'NORMAL',
  WARM = 'WARM',
  HOT = 'HOT',
  OVERHEATED = 'OVERHEATED',
  WARNING = 'WARNING',
  ESCAPE = 'ESCAPE',
  EMERGENCY = 'EMERGENCY'
}

/**
 * 热管理策略引擎
 * 根据温度等级自动调整设备行为
 */
export class ThermalPolicyEngine {
  // 策略配置表
  private readonly policies: Map<ThermalLevel, ThermalPolicy> = new Map([
    [ThermalLevel.NORMAL, {
      level: ThermalLevel.NORMAL,
      maxCpuFreq: 3200,
      maxGpuFreq: 900,
      maxBrightness: 255,
      chargingEnabled: true,
      maxChargingCurrent: 5000,
      backgroundRefreshInterval: 30,
      videoMaxResolution: 2160,
      thermalAlertMessage: ''
    }],
    [ThermalLevel.WARM, {
      level: ThermalLevel.WARM,
      maxCpuFreq: 2800,
      maxGpuFreq: 750,
      maxBrightness: 230,
      chargingEnabled: true,
      maxChargingCurrent: 4000,
      backgroundRefreshInterval: 60,
      videoMaxResolution: 1440,
      thermalAlertMessage: '设备温度偏高，已轻微降频'
    }],
    [ThermalLevel.HOT, {
      level: ThermalLevel.HOT,
      maxCpuFreq: 2200,
      maxGpuFreq: 600,
      maxBrightness: 200,
      chargingEnabled: true,
      maxChargingCurrent: 2500,
      backgroundRefreshInterval: 120,
      videoMaxResolution: 1080,
      thermalAlertMessage: '设备温度较高，已中度降频'
    }],
    [ThermalLevel.OVERHEATED, {
      level: ThermalLevel.OVERHEATED,
      maxCpuFreq: 1800,
      maxGpuFreq: 450,
      maxBrightness: 160,
      chargingEnabled: false,
      maxChargingCurrent: 0,
      backgroundRefreshInterval: 300,
      videoMaxResolution: 720,
      thermalAlertMessage: '⚠️ 设备过热，已大幅降频并停止充电'
    }],
    [ThermalLevel.WARNING, {
      level: ThermalLevel.WARNING,
      maxCpuFreq: 1200,
      maxGpuFreq: 300,
      maxBrightness: 120,
      chargingEnabled: false,
      maxChargingCurrent: 0,
      backgroundRefreshInterval: 600,
      videoMaxResolution: 480,
      thermalAlertMessage: '🔴 设备严重过热，已限制性能'
    }],
    [ThermalLevel.ESCAPE, {
      level: ThermalLevel.ESCAPE,
      maxCpuFreq: 800,
      maxGpuFreq: 200,
      maxBrightness: 80,
      chargingEnabled: false,
      maxChargingCurrent: 0,
      backgroundRefreshInterval: 0, // 禁用后台刷新
      videoMaxResolution: 360,
      thermalAlertMessage: '🚨 紧急降温模式，仅保留核心功能'
    }],
    [ThermalLevel.EMERGENCY, {
      level: ThermalLevel.EMERGENCY,
      maxCpuFreq: 600,
      maxGpuFreq: 100,
      maxBrightness: 50,
      chargingEnabled: false,
      maxChargingCurrent: 0,
      backgroundRefreshInterval: 0,
      videoMaxResolution: 0, // 禁用视频播放
      thermalAlertMessage: '⛔ 设备即将关机以保护硬件'
    }]
  ]);

  // 当前策略
  private currentPolicy: ThermalPolicy | null = null;
  // 策略变更回调
  private onPolicyChange?: (policy: ThermalPolicy) => void;

  /**
   * 设置策略变更回调
   */
  public setOnPolicyChange(callback: (policy: ThermalPolicy) => void): void {
    this.onPolicyChange = callback;
  }

  /**
   * 根据温控等级获取策略
   */
  public getPolicy(level: ThermalLevel): ThermalPolicy {
    const policy = this.policies.get(level);
    if (!policy) {
      return this.policies.get(ThermalLevel.NORMAL)!;
    }
    return policy;
  }

  /**
   * 应用温控策略
   * 当温控等级变化时调用
   */
  public applyPolicy(level: ThermalLevel): ThermalPolicy {
    const newPolicy = this.getPolicy(level);

    // 检查策略是否发生变化
    if (this.currentPolicy && this.currentPolicy.level === level) {
      return this.currentPolicy; // 无变化
    }

    const oldLevel = this.currentPolicy?.level || 'NONE';
    console.info(`[ThermalManager] 策略变更: ${oldLevel} → ${level}`);

    this.currentPolicy = newPolicy;

    // 通知策略变更
    if (this.onPolicyChange) {
      this.onPolicyChange(newPolicy);
    }

    return newPolicy;
  }

  /**
   * 获取当前策略
   */
  public getCurrentPolicy(): ThermalPolicy | null {
    return this.currentPolicy;
  }

  /**
   * 根据温度值直接获取策略（便捷方法）
   */
  public getPolicyByTemperature(temp: number): ThermalPolicy {
    const level = this.temperatureToLevel(temp);
    return this.getPolicy(level);
  }

  /**
   * 温度值转温控等级
   */
  private temperatureToLevel(temp: number): ThermalLevel {
    if (temp < 35) return ThermalLevel.NORMAL;
    if (temp < 40) return ThermalLevel.WARM;
    if (temp < 45) return ThermalLevel.HOT;
    if (temp < 48) return ThermalLevel.OVERHEATED;
    if (temp < 52) return ThermalLevel.WARNING;
    if (temp < 55) return ThermalLevel.ESCAPE;
    return ThermalLevel.EMERGENCY;
  }
}

3.3 应用自适应温控组件

// AdaptiveThermalComponent.ets - 基于温度的应用自适应组件
import thermal from '@ohos.thermal';

@Entry
@Component
struct AdaptiveThermalPage {
  // 当前温控等级
  @State currentLevel: string = 'NORMAL';
  // 当前温度
  @State currentTemp: number = 25;
  // 视频分辨率
  @State videoResolution: string = '4K';
  // 刷新间隔
  @State refreshInterval: string = '30秒';
  // 是否允许充电
  @State chargingAllowed: boolean = true;
  // 最大亮度
  @State maxBrightness: number = 255;
  // 温控提示
  @State alertMessage: string = '';
  // 性能评分（0-100）
  @State performanceScore: number = 100;

  // 热管理引擎实例
  private thermalEngine: ThermalPolicyEngine = new ThermalPolicyEngine();

  aboutToAppear() {
    // 注册策略变更回调
    this.thermalEngine.setOnPolicyChange((policy) => {
      this.onThermalPolicyChange(policy);
    });

    // 订阅系统温控等级
    this.subscribeSystemThermalLevel();

    // 初始化策略
    this.thermalEngine.applyPolicy('NORMAL' as ThermalLevel);
  }

  /**
   * 订阅系统温控等级
   */
  private subscribeSystemThermalLevel(): void {
    try {
      thermal.subscribeThermalLevel((level: thermal.ThermalLevel) => {
        const levelStr = this.mapSystemLevel(level);
        this.currentLevel = levelStr;
        this.thermalEngine.applyPolicy(levelStr as ThermalLevel);
      });
    } catch (error) {
      // 系统温控订阅失败，使用本地模拟
      this.startLocalThermalSimulation();
    }
  }

  /**
   * 映射系统温控等级
   */
  private mapSystemLevel(level: thermal.ThermalLevel): string {
    const map: Record<number, string> = {
      0: 'NORMAL', 1: 'WARM', 2: 'HOT',
      3: 'OVERHEATED', 4: 'WARNING', 5: 'ESCAPE', 6: 'EMERGENCY'
    };
    return map[level] || 'NORMAL';
  }

  /**
   * 本地温控模拟（开发调试用）
   */
  private startLocalThermalSimulation(): void {
    // 模拟温度变化
    setInterval(() => {
      const simulatedTemp = 25 + Math.random() * 30;
      this.currentTemp = Math.round(simulatedTemp * 10) / 10;
      const policy = this.thermalEngine.getPolicyByTemperature(simulatedTemp);
      this.currentLevel = policy.level;
      this.onThermalPolicyChange(policy);
    }, 3000);
  }

  /**
   * 温控策略变更回调
   */
  private onThermalPolicyChange(policy: ThermalPolicy): void {
    // 更新UI状态
    this.videoResolution = this.resolutionToString(policy.videoMaxResolution);
    this.refreshInterval = policy.backgroundRefreshInterval > 0 ?
      `${policy.backgroundRefreshInterval}秒` : '已禁用';
    this.chargingAllowed = policy.chargingEnabled;
    this.maxBrightness = policy.maxBrightness;
    this.alertMessage = policy.thermalAlertMessage;

    // 计算性能评分
    this.performanceScore = this.calculatePerformanceScore(policy);
  }

  /**
   * 分辨率数字转字符串
   */
  private resolutionToString(res: number): string {
    if (res >= 2160) return '4K';
    if (res >= 1440) return '2K';
    if (res >= 1080) return '1080P';
    if (res >= 720) return '720P';
    if (res >= 480) return '480P';
    if (res > 0) return '360P';
    return '已禁用';
  }

  /**
   * 计算性能评分
   */
  private calculatePerformanceScore(policy: ThermalPolicy): number {
    let score = 100;
    // CPU降频扣分
    score -= (1 - policy.maxCpuFreq / 3200) * 30;
    // GPU降频扣分
    score -= (1 - policy.maxGpuFreq / 900) * 20;
    // 亮度限制扣分
    score -= (1 - policy.maxBrightness / 255) * 15;
    // 充电限制扣分
    if (!policy.chargingEnabled) score -= 15;
    // 后台刷新限制扣分
    if (policy.backgroundRefreshInterval === 0) score -= 20;
    else if (policy.backgroundRefreshInterval > 60) score -= 10;

    return Math.max(0, Math.round(score));
  }

  /**
   * 获取等级颜色
   */
  private getLevelColor(): string {
    const colors: Record<string, string> = {
      'NORMAL': '#4caf50', 'WARM': '#ff9800', 'HOT': '#ff5722',
      'OVERHEATED': '#f44336', 'WARNING': '#d32f2f',
      'ESCAPE': '#b71c1c', 'EMERGENCY': '#880e4f'
    };
    return colors[this.currentLevel] || '#4caf50';
  }

  build() {
    Scroll() {
      Column() {
        // 标题
        Text('智能热管理系统')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor('#e0e0e0')
          .margin({ bottom: 24 })

        // 温控等级与性能评分
        Row() {
          Column() {
            Text('温控等级')
              .fontSize(12)
              .fontColor('#888888')
            Text(this.currentLevel)
              .fontSize(22)
              .fontWeight(FontWeight.Bold)
              .fontColor(this.getLevelColor())
          }
          .layoutWeight(1)

          // 性能评分环形进度
          Column() {
            Text('性能评分')
              .fontSize(12)
              .fontColor('#888888')
            Text(`${this.performanceScore}`)
              .fontSize(28)
              .fontWeight(FontWeight.Bold)
              .fontColor(this.performanceScore > 70 ? '#4caf50' :
                this.performanceScore > 40 ? '#ff9800' : '#f44336')
          }
          .layoutWeight(1)
        }
        .width('90%')
        .padding(20)
        .borderRadius(16)
        .backgroundColor('#1a1a2e')
        .margin({ bottom: 16 })

        // 温控告警
        if (this.alertMessage) {
          Text(this.alertMessage)
            .fontSize(14)
            .fontColor('#f44336')
            .width('90%')
            .padding(12)
            .borderRadius(8)
            .backgroundColor('#2a1a1e')
            .margin({ bottom: 16 })
        }

        // 自适应参数面板
        Column() {
          Text('自适应参数')
            .fontSize(16)
            .fontWeight(FontWeight.Bold)
            .fontColor('#e0e0e0')
            .margin({ bottom: 12 })

          // 视频分辨率
          this.ParameterRow('视频最大分辨率', this.videoResolution)
          // 后台刷新间隔
          this.ParameterRow('后台刷新间隔', this.refreshInterval)
          // 充电状态
          this.ParameterRow('充电状态', this.chargingAllowed ? '允许' : '已停止')
          // 最大亮度
          this.ParameterRow('最大亮度', `${this.maxBrightness} / 255`)
        }
        .width('90%')
        .padding(20)
        .borderRadius(16)
        .backgroundColor('#1a1a2e')
        .alignItems(HorizontalAlign.Start)
        .margin({ bottom: 16 })
      }
      .width('100%')
      .padding(16)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0a0a1a')
  }

  @Builder
  ParameterRow(label: string, value: string) {
    Row() {
      Text(label)
        .fontSize(14)
        .fontColor('#888888')
        .layoutWeight(1)
      Text(value)
        .fontSize(14)
        .fontWeight(FontWeight.Bold)
        .fontColor('#e0e0e0')
    }
    .width('100%')
    .padding({ top: 8, bottom: 8 })
  }
}

四、踩坑与注意事项

4.1 传感器可用性问题

4.2 热管理策略设计陷阱

• 不要在应用层直接控制CPU/GPU频率：这是系统级操作，应用层只能通过@ohos.thermal感知等级并自适应
• 避免频繁查询温控等级：使用订阅模式而非轮询模式
• 温控降级应该是渐进的：不要从NORMAL直接跳到OVERHEATED，中间状态也要处理
• 注意温控恢复的滞后性：温度下降后，系统不会立即恢复性能，通常有30秒~2分钟的恢复期

4.3 电池温度特殊处理

// 电池温度监测与充电控制
import batteryInfo from '@ohos.batteryInfo';

class BatteryThermalGuard {
  // 电池安全温度范围
  private readonly SAFE_TEMP_MIN = 0;    // 最低安全温度
  private readonly SAFE_TEMP_MAX = 45;   // 最高安全温度
  private readonly CHARGE_TEMP_MAX = 40; // 充电最高温度

  /**
   * 检查电池温度是否安全
   */
  checkBatterySafety(): { safe: boolean; action: string } {
    const batteryTemp = batteryInfo.batteryInfo.temperature; // 单位：0.1°C

    const tempC = batteryTemp / 10; // 转换为°C

    if (tempC < this.SAFE_TEMP_MIN) {
      return { safe: false, action: '电池温度过低，请移至温暖环境' };
    }
    if (tempC > this.SAFE_TEMP_MAX) {
      return { safe: false, action: '电池温度过高，请停止使用并散热' };
    }
    if (tempC > this.CHARGE_TEMP_MAX) {
      return { safe: true, action: '建议暂停充电以降低电池温度' };
    }
    return { safe: true, action: '电池温度正常' };
  }
}

4.4 性能优化建议

• 使用@ohos.thermal代替直接读传感器：系统热管理服务已经融合了多传感器数据，更准确
• 温控策略变更时使用防抖：避免温度在阈值附近波动导致频繁切换策略
• 应用自适应应该是可逆的：温度恢复后应自动恢复性能，无需用户干预
• 记录温控事件日志：方便排查温度异常问题

五、HarmonyOS 6适配

5.1 新版热管理API变化

5.2 HarmonyOS 6多区域温度查询

// HarmonyOS 6 多区域温度查询适配
import thermalManager from '@ohos.thermalManager';

// 温度区域枚举
enum ThermalZone {
  CPU = 'cpu',
  GPU = 'gpu',
  BATTERY = 'battery',
  BOARD = 'board',
  AMBIENT = 'ambient',
  MODEM = 'modem',
  NPU = 'npu'
}

// 温度区域数据
interface ZoneTemperature {
  zone: ThermalZone;
  temperature: number;
  threshold: number;
}

class MultiZoneThermalMonitor {
  /**
   * 查询所有温度区域
   */
  async getAllZoneTemperatures(): Promise<ZoneTemperature[]> {
    const zones: ThermalZone[] = [
      ThermalZone.CPU, ThermalZone.GPU, ThermalZone.BATTERY,
      ThermalZone.BOARD, ThermalZone.AMBIENT, ThermalZone.MODEM, ThermalZone.NPU
    ];

    const results: ZoneTemperature[] = [];
    for (const zone of zones) {
      try {
        const temp = await thermalManager.getZoneTemperature(zone);
        const threshold = await thermalManager.getZoneThreshold(zone);
        results.push({ zone, temperature: temp, threshold });
      } catch (e) {
        // 该区域不可用，跳过
      }
    }
    return results;
  }

  /**
   * 获取最热区域
   */
  async getHottestZone(): Promise<ZoneTemperature | null> {
    const allZones = await this.getAllZoneTemperatures();
    if (allZones.length === 0) return null;
    return allZones.reduce((max, curr) =>
      curr.temperature > max.temperature ? curr : max
    );
  }
}

5.3 HarmonyOS 6 AI温控预测

HarmonyOS 6引入了基于机器学习的温度预测能力：

• 短期预测（5-30秒）：基于当前功耗和温度趋势，预测短期温度变化
• 场景识别：识别高负载场景（游戏、视频通话、导航），提前调整策略
• 个性化温控：学习用户使用习惯，优化温控策略的触发时机

六、总结

6.1 核心技术要点回顾

6.2 最佳实践清单

1. ✅ 优先使用@ohos.thermal获取系统温控等级，而非直接读传感器
2. ✅ 实现7级温控策略配置表，覆盖所有温控场景
3. ✅ 应用自适应应该是渐进的、可逆的
4. ✅ 温控策略变更使用防抖，避免频繁切换
5. ✅ 监测电池温度，在高温时停止充电
6. ✅ 记录温控事件日志，方便问题排查
7. ✅ 适配HarmonyOS 6多区域温度查询
8. ✅ 利用AI温控预测提前调整策略

6.3 扩展方向

• 跨设备热管理：分布式场景下，多设备协同温控
• 热管理可视化：设备热力图实时展示，帮助用户理解散热
• 游戏温控优化：游戏场景下的智能帧率-温度平衡策略
• 环境温度补偿：结合环境温度传感器修正设备内部温度估计