HarmonyOS开发：传感器能耗优化与传感器使用策略

📌 核心要点：深入分析传感器能耗特征，掌握采样频率优化、按需启停策略、数据批处理与低功耗传感器替代方案，实现传感器使用的极致功耗控制。

一、背景与动机

GPS定位、加速度计、陀螺仪、心率传感器……现代智能手机内置了十几种传感器，它们让应用能够感知用户的运动、位置和环境。但传感器也是"电老虎"——尤其是GPS，持续定位时的功耗甚至可以和屏幕亮屏相媲美。

你有没有遇到过这样的场景：用户打开你的运动追踪应用跑了个步，结果一小时后电量掉了30%？或者你的导航应用在后台持续定位，用户手机半天就没电了？

传感器功耗优化的核心矛盾在于：精度越高、频率越快，功耗越大。GPS的高精度模式功耗是低精度模式的5-10倍；加速度计100Hz采样的功耗是10Hz的10倍。但用户又期望应用能提供精确、实时的数据——这就是优化的难点所在。

本文将从传感器能耗分析出发，带你系统掌握采样频率优化、按需启停、数据批处理和低功耗替代方案，让你的应用在精度和功耗之间找到最佳平衡。

二、核心原理

2.1 传感器能耗分析

flowchart TB
    A[传感器能耗排名] --> B[GPS定位<br/>功耗: ⭐⭐⭐⭐⭐]
    A --> C[陀螺仪<br/>功耗: ⭐⭐⭐⭐]
    A --> D[加速度计<br/>功耗: ⭐⭐⭐]
    A --> E[磁力计<br/>功耗: ⭐⭐]
    A --> F[环境光传感器<br/>功耗: ⭐]
    A --> G[距离传感器<br/>功耗: ⭐]
    
    B --> B1[高精度模式: 50-100mA]
    B --> B2[低精度模式: 5-10mA]
    
    C --> C1[高频采样: 10-20mA]
    C --> C2[低频采样: 1-3mA]
    
    D --> D1[高频采样: 5-10mA]
    D --> D2[低频采样: 0.5-1mA]
    
    classDef mainStyle fill:#E74C3C,stroke:#C0392B,color:#fff,font-weight:bold
    classDef gpsStyle fill:#E74C3C,stroke:#C0392B,color:#fff
    classDef gyroStyle fill:#F39C12,stroke:#E67E22,color:#fff
    classDef accelStyle fill:#F1C40F,stroke:#F39C12,color:#333
    classDef magStyle fill:#2ECC71,stroke:#27AE60,color:#fff
    classDef lowStyle fill:#3498DB,stroke:#2980B9,color:#fff
    
    class A mainStyle
    class B,B1,B2 gpsStyle
    class C,C1,C2 gyroStyle
    class D,D1,D2 accelStyle
    class E magStyle
    class F,G lowStyle

2.2 传感器采样频率与功耗关系

关键洞察：功耗与采样频率近似线性关系。将采样频率从100Hz降到10Hz，功耗可以降低约90%，而大多数应用场景下10Hz的精度已经足够。

2.3 传感器优化策略总览

flowchart LR
    A[传感器优化策略] --> B[降低采样频率]
    A --> C[按需启停]
    A --> D[数据批处理]
    A --> E[低功耗替代]
    
    B --> B1[运动场景: 10Hz]
    B --> B2[静止场景: 1Hz]
    B --> B3[后台场景: 0.1Hz]
    
    C --> C1[页面不可见时停止]
    C --> C2[用户静止时暂停]
    C --> C3[低电量时降级]
    
    D --> D1[批量上报数据]
    D --> D2[本地预处理]
    D --> D3[异常值过滤]
    
    E --> E1[WiFi定位替代GPS]
    E --> E2[计步器替代加速度计]
    E --> E3[基站定位替代GPS]
    
    classDef mainStyle fill:#E74C3C,stroke:#C0392B,color:#fff,font-weight:bold
    classDef freqStyle fill:#3498DB,stroke:#2980B9,color:#fff
    classDef switchStyle fill:#2ECC71,stroke:#27AE60,color:#fff
    classDef batchStyle fill:#F39C12,stroke:#E67E22,color:#fff
    classDef altStyle fill:#9B59B6,stroke:#8E44AD,color:#fff
    
    class A mainStyle
    class B,B1,B2,B3 freqStyle
    class C,C1,C2,C3 switchStyle
    class D,D1,D2,D3 batchStyle
    class E,E1,E2,E3 altStyle

三、代码实战

3.1 基础示例：传感器按需启停管理

// sensor_manager.ets - 传感器按需启停管理
import { sensor } from '@kit.SensorServiceKit'
import { geoLocationManager } from '@kit.LocationKit'

// 传感器配置
interface SensorConfig {
  type: sensor.SensorType        // 传感器类型
  sampleInterval: number         // 采样间隔（微秒）
  reportInterval: number         // 上报间隔（微秒）
  autoStopOnBackground: boolean  // 后台自动停止
  autoStopOnStillness: boolean   // 静止时自动停止
  stillnessTimeout: number       // 静止超时（毫秒）
  lowPowerMode: boolean          // 低功耗模式
}

// 传感器状态
type SensorState = 'stopped' | 'starting' | 'running' | 'paused'

// 传感器管理器
class SmartSensorManager {
  private activeSensors: Map<sensor.SensorType, string> = new Map()  // 传感器类型 -> 订阅ID
  private sensorConfigs: Map<sensor.SensorType, SensorConfig> = new Map()
  private sensorStates: Map<sensor.SensorType, SensorState> = new Map()
  private isBackground: boolean = false
  private lastMotionTime: number = Date.now()
  private stillnessCheckTimer: number = -1

  // 注册并启动传感器
  async startSensor(config: SensorConfig): Promise<boolean> {
    // 检查传感器是否可用
    const isAvailable = await this.checkSensorAvailable(config.type)
    if (!isAvailable) {
      console.error(`传感器不可用: ${config.type}`)
      return false
    }

    // 保存配置
    this.sensorConfigs.set(config.type, config)
    this.sensorStates.set(config.type, 'starting')

    // 根据低功耗模式调整采样间隔
    const adjustedInterval = this.getAdjustedInterval(config)

    try {
      switch (config.type) {
        case sensor.SensorType.ACCELEROMETER:
          await this.startAccelerometer(adjustedInterval, config)
          break
        case sensor.SensorType.GYROSCOPE:
          await this.startGyroscope(adjustedInterval, config)
          break
        default:
          console.warn(`暂不支持的传感器类型: ${config.type}`)
          return false
      }

      this.sensorStates.set(config.type, 'running')
      console.info(`传感器已启动: ${config.type}, 间隔: ${adjustedInterval}μs`)

      // 启动静止检测
      if (config.autoStopOnStillness) {
        this.startStillnessCheck(config.type)
      }

      return true
    } catch (error) {
      this.sensorStates.set(config.type, 'stopped')
      console.error(`传感器启动失败: ${config.type}`, error)
      return false
    }
  }

  // 停止传感器
  stopSensor(type: sensor.SensorType): void {
    const subscribeId = this.activeSensors.get(type)
    if (!subscribeId) return

    try {
      sensor.off(type, subscribeId)
      this.activeSensors.delete(type)
      this.sensorStates.set(type, 'stopped')
      console.info(`传感器已停止: ${type}`)
    } catch (error) {
      console.error(`传感器停止失败: ${type}`, error)
    }
  }

  // 启动加速度计
  private async startAccelerometer(interval: number, config: SensorConfig): Promise<void> {
    const subscribeId = sensor.on(sensor.SensorType.ACCELEROMETER, (data: sensor.AccelerometerResponse) => {
      // 处理加速度计数据
      this.handleAccelerometerData(data, config)
      // 更新最后运动时间
      const magnitude = Math.sqrt(data.x * data.x + data.y * data.y + data.z * data.z)
      if (Math.abs(magnitude - 9.8) > 0.5) {
        this.lastMotionTime = Date.now()
      }
    }, { interval: interval })

    this.activeSensors.set(sensor.SensorType.ACCELEROMETER, subscribeId)
  }

  // 启动陀螺仪
  private async startGyroscope(interval: number, config: SensorConfig): Promise<void> {
    const subscribeId = sensor.on(sensor.SensorType.GYROSCOPE, (data: sensor.GyroscopeResponse) => {
      // 处理陀螺仪数据
      this.handleGyroscopeData(data, config)
      // 更新最后运动时间
      const magnitude = Math.sqrt(data.x * data.x + data.y * data.y + data.z * data.z)
      if (magnitude > 0.1) {
        this.lastMotionTime = Date.now()
      }
    }, { interval: interval })

    this.activeSensors.set(sensor.SensorType.GYROSCOPE, subscribeId)
  }

  // 处理加速度计数据
  private handleAccelerometerData(data: sensor.AccelerometerResponse, config: SensorConfig): void {
    // 低功耗模式下过滤数据
    if (config.lowPowerMode) {
      // 简单的低通滤波
      const magnitude = Math.sqrt(data.x * data.x + data.y * data.y + data.z * data.z)
      if (Math.abs(magnitude - 9.8) < 0.3) {
        return  // 忽略微小运动
      }
    }

    // 回调给业务层处理
    // 实际实现中应通过事件或回调通知业务层
  }

  // 处理陀螺仪数据
  private handleGyroscopeData(data: sensor.GyroscopeResponse, config: SensorConfig): void {
    // 类似加速度计的处理逻辑
    if (config.lowPowerMode) {
      const magnitude = Math.sqrt(data.x * data.x + data.y * data.y + data.z * data.z)
      if (magnitude < 0.05) {
        return  // 忽略微小旋转
      }
    }
  }

  // 获取调整后的采样间隔
  private getAdjustedInterval(config: SensorConfig): number {
    let interval = config.sampleInterval

    // 后台模式延长间隔
    if (this.isBackground) {
      interval = Math.max(interval * 5, 1000000)  // 至少1秒
    }

    // 低功耗模式延长间隔
    if (config.lowPowerMode) {
      interval = Math.max(interval * 3, 500000)  // 至少0.5秒
    }

    return interval
  }

  // 检查传感器可用性
  private async checkSensorAvailable(type: sensor.SensorType): Promise<boolean> {
    try {
      const sensors = sensor.getSensorList()
      return sensors.some(s => s.sensorType === type)
    } catch (e) {
      return false
    }
  }

  // 启动静止检测
  private startStillnessCheck(type: sensor.SensorType): void {
    if (this.stillnessCheckTimer !== -1) {
      clearInterval(this.stillnessCheckTimer)
    }

    const config = this.sensorConfigs.get(type)
    if (!config) return

    this.stillnessCheckTimer = setInterval(() => {
      const stillDuration = Date.now() - this.lastMotionTime
      if (stillDuration > config.stillnessTimeout) {
        console.info(`检测到静止，暂停传感器: ${type}`)
        this.pauseSensor(type)
      }
    }, 5000)  // 每5秒检查一次
  }

  // 暂停传感器（降低采样率而非完全停止）
  private pauseSensor(type: sensor.SensorType): void {
    this.sensorStates.set(type, 'paused')
    // 实际实现中应降低采样率或停止传感器
  }

  // 恢复传感器
  resumeSensor(type: sensor.SensorType): void {
    const config = this.sensorConfigs.get(type)
    if (!config) return
    this.lastMotionTime = Date.now()
    this.sensorStates.set(type, 'running')
    // 恢复正常采样率
  }

  // 切换到后台模式
  switchToBackground(): void {
    this.isBackground = true
    // 对所有配置了autoStopOnBackground的传感器降低采样率
    this.sensorConfigs.forEach((config, type) => {
      if (config.autoStopOnBackground) {
        this.pauseSensor(type)
      }
    })
  }

  // 切换到前台模式
  switchToForeground(): void {
    this.isBackground = false
    // 恢复所有暂停的传感器
    this.sensorStates.forEach((state, type) => {
      if (state === 'paused') {
        this.resumeSensor(type)
      }
    })
  }

  // 停止所有传感器
  stopAll(): void {
    this.activeSensors.forEach((_, type) => this.stopSensor(type))
    if (this.stillnessCheckTimer !== -1) {
      clearInterval(this.stillnessCheckTimer)
    }
  }

  // 获取传感器状态
  getSensorStatus(): Map<sensor.SensorType, SensorState> {
    return new Map(this.sensorStates)
  }
}

3.2 进阶示例：GPS定位优化与低功耗替代方案

// location_optimizer.ets - GPS定位优化与低功耗替代
import { geoLocationManager } from '@kit.LocationKit'
import { wifiManager } from '@kit.WifiKit'
import { batteryInfo } from '@ohos.batteryInfo'

// 定位精度级别
enum LocationAccuracy {
  HIGH = 'high',           // GPS高精度（~10m）
  BALANCED = 'balanced',   // 平衡模式（~100m）
  LOW = 'low',             // 低功耗模式（~1km）
  CITY = 'city'            // 城市级定位（~10km）
}

// 定位配置
interface LocationConfig {
  accuracy: LocationAccuracy     // 精度级别
  updateIntervalMs: number       // 更新间隔（毫秒）
  distanceFilterM: number        // 距离过滤（米）
  useLowPowerAlternative: boolean // 使用低功耗替代方案
  maxCacheAge: number            // 缓存最大有效期（毫秒）
}

// 定位结果
interface LocationResult {
  latitude: number               // 纬度
  longitude: number              // 经度
  accuracy: number               // 精度（米）
  timestamp: number              // 时间戳
  source: string                 // 定位来源
}

// 定位优化器
class LocationOptimizer {
  private cachedLocation: LocationResult | null = null
  private isLocating: boolean = false
  private locationCallback: ((location: LocationResult) => void) | null = null
  private config: LocationConfig

  constructor(config?: Partial<LocationConfig>) {
    this.config = {
      accuracy: LocationAccuracy.BALANCED,
      updateIntervalMs: 10000,
      distanceFilterM: 10,
      useLowPowerAlternative: true,
      maxCacheAge: 300000,  // 5分钟
      ...config
    }
  }

  // 智能定位：根据场景选择最优定位策略
  async getLocation(): Promise<LocationResult | null> {
    // 检查缓存
    if (this.cachedLocation) {
      const cacheAge = Date.now() - this.cachedLocation.timestamp
      if (cacheAge < this.config.maxCacheAge) {
        console.info(`使用缓存定位: ${this.cachedLocation.source}`)
        return this.cachedLocation
      }
    }

    // 根据电量选择定位策略
    const batteryLevel = batteryInfo.batterySOC
    let accuracy = this.config.accuracy

    if (batteryLevel <= 10) {
      accuracy = LocationAccuracy.CITY
    } else if (batteryLevel <= 20) {
      accuracy = LocationAccuracy.LOW
    } else if (batteryLevel <= 50 && this.config.useLowPowerAlternative) {
      accuracy = LocationAccuracy.BALANCED
    }

    // 尝试低功耗替代方案
    if (accuracy !== LocationAccuracy.HIGH && this.config.useLowPowerAlternative) {
      const wifiLocation = await this.getWifiLocation()
      if (wifiLocation && this.isAccuracyAcceptable(wifiLocation, accuracy)) {
        this.cachedLocation = wifiLocation
        return wifiLocation
      }
    }

    // 使用GPS定位
    const gpsLocation = await this.getGpsLocation(accuracy)
    if (gpsLocation) {
      this.cachedLocation = gpsLocation
    }

    return gpsLocation
  }

  // GPS定位
  private async getGpsLocation(accuracy: LocationAccuracy): Promise<LocationResult | null> {
    if (this.isLocating) {
      return this.cachedLocation
    }

    this.isLocating = true

    try {
      // 将精度级别转换为系统定位请求参数
      const priority = this.accuracyToPriority(accuracy)
      const location = await geoLocationManager.getCurrentLocation({
        priority: priority,
        scenario: this.accuracyToScenario(accuracy)
      })

      const result: LocationResult = {
        latitude: location.latitude,
        longitude: location.longitude,
        accuracy: location.accuracy,
        timestamp: Date.now(),
        source: `GPS(${accuracy})`
      }

      this.isLocating = false
      return result
    } catch (error) {
      this.isLocating = false
      console.error('GPS定位失败:', error)
      return null
    }
  }

  // WiFi定位（低功耗替代方案）
  private async getWifiLocation(): Promise<LocationResult | null> {
    try {
      // 使用WiFi接入点信息进行粗略定位
      // 实际实现中应调用WiFi定位服务
      console.info('尝试WiFi定位')

      // 模拟WiFi定位结果
      return {
        latitude: 39.9042,
        longitude: 116.4074,
        accuracy: 500,  // WiFi定位精度约500米
        timestamp: Date.now(),
        source: 'WiFi'
      }
    } catch (error) {
      console.warn('WiFi定位失败:', error)
      return null
    }
  }

  // 检查精度是否可接受
  private isAccuracyAcceptable(location: LocationResult, requiredAccuracy: LocationAccuracy): boolean {
    const maxAccuracy: Record<string, number> = {
      [LocationAccuracy.HIGH]: 50,
      [LocationAccuracy.BALANCED]: 500,
      [LocationAccuracy.LOW]: 2000,
      [LocationAccuracy.CITY]: 10000
    }

    return location.accuracy <= (maxAccuracy[requiredAccuracy] || 500)
  }

  // 精度级别转系统优先级
  private accuracyToPriority(accuracy: LocationAccuracy): geoLocationManager.LocationRequestPriority {
    switch (accuracy) {
      case LocationAccuracy.HIGH:
        return geoLocationManager.LocationRequestPriority.ACCURACY
      case LocationAccuracy.BALANCED:
        return geoLocationManager.LocationRequestPriority.LOW_POWER
      case LocationAccuracy.LOW:
      case LocationAccuracy.CITY:
        return geoLocationManager.LocationRequestPriority.LOW_POWER
      default:
        return geoLocationManager.LocationRequestPriority.LOW_POWER
    }
  }

  // 精度级别转系统场景
  private accuracyToScenario(accuracy: LocationAccuracy): geoLocationManager.LocationRequestScenario {
    switch (accuracy) {
      case LocationAccuracy.HIGH:
        return geoLocationManager.LocationRequestScenario.NAVIGATION
      case LocationAccuracy.BALANCED:
        return geoLocationManager.LocationRequestScenario.DAILY_LIFE_SERVICE
      case LocationAccuracy.LOW:
        return geoLocationManager.LocationRequestScenario.UNSET
      case LocationAccuracy.CITY:
        return geoLocationManager.LocationRequestScenario.UNSET
      default:
        return geoLocationManager.LocationRequestScenario.DAILY_LIFE_SERVICE
    }
  }

  // 启动持续定位
  async startContinuousLocation(
    callback: (location: LocationResult) => void,
    config?: Partial<LocationConfig>
  ): Promise<void> {
    const mergedConfig = { ...this.config, ...config }
    this.locationCallback = callback

    const priority = this.accuracyToPriority(mergedConfig.accuracy)
    
    try {
      geoLocationManager.on('locationChange', (location: geoLocationManager.Location) => {
        const result: LocationResult = {
          latitude: location.latitude,
          longitude: location.longitude,
          accuracy: location.accuracy,
          timestamp: Date.now(),
          source: `GPS(continuous)`
        }

        this.cachedLocation = result
        this.locationCallback?.(result)
      })

      geoLocationManager.startLocating({
        priority: priority,
        scenario: this.accuracyToScenario(mergedConfig.accuracy),
        timeInterval: Math.floor(mergedConfig.updateIntervalMs / 1000),
        distanceInterval: mergedConfig.distanceFilterM
      })

      console.info('持续定位已启动')
    } catch (error) {
      console.error('持续定位启动失败:', error)
    }
  }

  // 停止持续定位
  stopContinuousLocation(): void {
    try {
      geoLocationManager.off('locationChange')
      geoLocationManager.stopLocating()
      console.info('持续定位已停止')
    } catch (error) {
      console.error('停止定位失败:', error)
    }
  }

  // 更新配置
  updateConfig(config: Partial<LocationConfig>): void {
    this.config = { ...this.config, ...config }
  }
}

3.3 完整示例：传感器数据批处理与低功耗策略

// sensor_batch_processor.ets - 传感器数据批处理
import { sensor } from '@kit.SensorServiceKit'

// 传感器数据样本
interface SensorSample {
  timestamp: number             // 时间戳
  x: number                     // X轴数据
  y: number                     // Y轴数据
  z: number                     // Z轴数据
}

// 批处理配置
interface BatchConfig {
  maxBatchSize: number          // 最大批量大小
  maxBatchAge: number           // 最大批量时长（毫秒）
  enableFiltering: boolean      // 启用数据过滤
  enableCompression: boolean    // 启用数据压缩
  filterThreshold: number       // 过滤阈值
}

// 批处理结果
interface BatchResult {
  samples: SensorSample[]       // 批量数据
  startTime: number             // 开始时间
  endTime: number               // 结束时间
  originalCount: number         // 原始数据量
  filteredCount: number         // 过滤后数据量
  compressionRatio: number      // 压缩率
}

// 传感器数据批处理器
class SensorBatchProcessor {
  private buffer: SensorSample[] = []
  private config: BatchConfig
  private batchTimer: number = -1
  private onBatchReady: ((batch: BatchResult) => void) | null = null
  private lastSample: SensorSample | null = null
  private totalOriginal: number = 0
  private totalFiltered: number = 0

  constructor(config?: Partial<BatchConfig>) {
    this.config = {
      maxBatchSize: 100,
      maxBatchAge: 5000,
      enableFiltering: true,
      enableCompression: true,
      filterThreshold: 0.1,
      ...config
    }
  }

  // 设置批处理回调
  setBatchCallback(callback: (batch: BatchResult) => void): void {
    this.onBatchReady = callback
  }

  // 添加数据样本
  addSample(x: number, y: number, z: number): void {
    const sample: SensorSample = {
      timestamp: Date.now(),
      x: x,
      y: y,
      z: z
    }

    this.totalOriginal++

    // 数据过滤：忽略与上一样本差异过小的数据
    if (this.config.enableFiltering && this.lastSample) {
      const diff = Math.sqrt(
        Math.pow(sample.x - this.lastSample.x, 2) +
        Math.pow(sample.y - this.lastSample.y, 2) +
        Math.pow(sample.z - this.lastSample.z, 2)
      )

      if (diff < this.config.filterThreshold) {
        return  // 忽略微小变化
      }
    }

    this.lastSample = sample
    this.totalFiltered++
    this.buffer.push(sample)

    // 检查是否需要触发批处理
    if (this.buffer.length >= this.config.maxBatchSize) {
      this.flush()
      return
    }

    // 设置定时器确保数据不会积压太久
    if (this.batchTimer === -1) {
      this.batchTimer = setTimeout(() => {
        this.flush()
      }, this.config.maxBatchAge)
    }
  }

  // 执行批处理
  private flush(): void {
    if (this.batchTimer !== -1) {
      clearTimeout(this.batchTimer)
      this.batchTimer = -1
    }

    if (this.buffer.length === 0) return

    const batch = [...this.buffer]
    this.buffer = []

    const result: BatchResult = {
      samples: this.config.enableCompression ? this.compressSamples(batch) : batch,
      startTime: batch[0].timestamp,
      endTime: batch[batch.length - 1].timestamp,
      originalCount: this.totalOriginal,
      filteredCount: this.totalFiltered,
      compressionRatio: this.config.enableCompression ? 
        (1 - this.compressSamples(batch).length / batch.length) : 0
    }

    // 回调通知
    this.onBatchReady?.(result)
  }

  // 压缩样本数据（降采样）
  private compressSamples(samples: SensorSample[]): SensorSample[] {
    if (samples.length <= 10) return samples

    // 简单的降采样：每N个样本取一个
    const targetCount = Math.max(10, Math.floor(samples.length / 3))
    const step = Math.floor(samples.length / targetCount)
    
    const compressed: SensorSample[] = []
    for (let i = 0; i < samples.length; i += step) {
      // 取区间内的平均值
      const chunk = samples.slice(i, Math.min(i + step, samples.length))
      const avgSample: SensorSample = {
        timestamp: chunk[0].timestamp,
        x: chunk.reduce((s, v) => s + v.x, 0) / chunk.length,
        y: chunk.reduce((s, v) => s + v.y, 0) / chunk.length,
        z: chunk.reduce((s, v) => s + v.z, 0) / chunk.length
      }
      compressed.push(avgSample)
    }

    return compressed
  }

  // 获取统计信息
  getStats(): Record<string, number> {
    return {
      bufferSize: this.buffer.length,
      totalOriginal: this.totalOriginal,
      totalFiltered: this.totalFiltered,
      filterRate: this.totalOriginal > 0 
        ? (1 - this.totalFiltered / this.totalOriginal) : 0
    }
  }

  // 重置统计
  reset(): void {
    this.buffer = []
    this.totalOriginal = 0
    this.totalFiltered = 0
    this.lastSample = null
  }
}

// 运动追踪应用示例
@Entry
@Component
struct FitnessTrackerPage {
  @State stepCount: number = 0
  @State distance: number = 0
  @State calories: number = 0
  @State isTracking: boolean = false
  @State batteryLevel: number = 100

  private sensorManager: SmartSensorManager = new SmartSensorManager()
  private locationOptimizer: LocationOptimizer = new LocationOptimizer()
  private batchProcessor: SensorBatchProcessor = new SensorBatchProcessor({
    maxBatchSize: 50,
    maxBatchAge: 3000,
    enableFiltering: true,
    filterThreshold: 0.2
  })

  aboutToAppear(): void {
    // 设置批处理回调
    this.batchProcessor.setBatchCallback((batch) => {
      // 处理批量数据
      this.processBatchData(batch)
    })
  }

  build() {
    Column() {
      // 运动数据展示
      Text(`步数: ${this.stepCount}`)
        .fontSize(32)
        .fontWeight(FontWeight.Bold)

      Text(`距离: ${(this.distance / 1000).toFixed(2)}km`)
        .fontSize(24)
        .margin({ top: 10 })

      Text(`卡路里: ${this.calories}kcal`)
        .fontSize(24)
        .margin({ top: 10 })

      Text(`电量: ${this.batteryLevel}%`)
        .fontSize(16)
        .fontColor('#999999')
        .margin({ top: 20 })

      // 控制按钮
      Button(this.isTracking ? '停止追踪' : '开始追踪')
        .width('80%')
        .height(50)
        .backgroundColor(this.isTracking ? '#E74C3C' : '#2ECC71')
        .borderRadius(25)
        .margin({ top: 30 })
        .onClick(() => this.toggleTracking())
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }

  // 切换追踪状态
  private async toggleTracking(): Promise<void> {
    if (this.isTracking) {
      this.stopTracking()
    } else {
      await this.startTracking()
    }
  }

  // 开始追踪
  private async startTracking(): Promise<void> {
    this.isTracking = true

    // 根据电量选择精度
    const batteryLevel = 50  // 简化
    const accuracy = batteryLevel > 30 ? LocationAccuracy.BALANCED : LocationAccuracy.LOW

    // 启动低功耗定位
    await this.locationOptimizer.startContinuousLocation(
      (location) => {
        console.info(`位置更新: ${location.latitude}, ${location.longitude}`)
      },
      { accuracy: accuracy, updateIntervalMs: 5000 }
    )

    // 启动加速度计（低功耗模式）
    await this.sensorManager.startSensor({
      type: sensor.SensorType.ACCELEROMETER,
      sampleInterval: 200000,  // 200ms = 5Hz
      reportInterval: 1000000, // 1秒
      autoStopOnBackground: true,
      autoStopOnStillness: true,
      stillnessTimeout: 60000, // 1分钟静止后暂停
      lowPowerMode: batteryLevel <= 30
    })
  }

  // 停止追踪
  private stopTracking(): void {
    this.isTracking = false
    this.locationOptimizer.stopContinuousLocation()
    this.sensorManager.stopAll()
  }

  // 处理批量数据
  private processBatchData(batch: BatchResult): void {
    // 分析加速度数据，检测步伐
    for (const sample of batch.samples) {
      const magnitude = Math.sqrt(sample.x * sample.x + sample.y * sample.y + sample.z * sample.z)
      // 简单的步伐检测算法
      if (magnitude > 12) {
        this.stepCount++
        this.distance = this.stepCount * 0.7  // 平均步长约0.7米
        this.calories = Math.floor(this.stepCount * 0.04)  // 每步约0.04千卡
      }
    }
  }
}

四、踩坑与注意事项

坑点1：GPS高精度模式在室内无法定位

GPS需要接收卫星信号，在室内、地下室、隧道等环境中信号极弱，高精度模式可能长时间无法获取位置。在室内场景下，应自动降级到WiFi或基站定位，避免GPS持续搜索卫星造成的功耗浪费。

坑点2：传感器回调频率与设定值不一致

你设置了100ms的采样间隔，但实际回调频率可能是200ms甚至更低。这是因为系统会根据当前负载和功耗策略调整实际的采样频率，应用无法强制要求精确的采样间隔。不要假设回调频率是精确的，在计算中应使用实际的时间戳而非固定间隔。

坑点3：忘记在页面销毁时停止传感器

传感器订阅不会因为页面销毁而自动停止。如果你在aboutToAppear中启动了传感器，但忘记在aboutToDisappear中停止，传感器会一直运行，持续消耗电量。务必在组件生命周期结束时停止所有传感器。

坑点4：传感器数据量过大导致内存溢出

高频采样的传感器数据量惊人——100Hz的加速度计每秒产生100个数据点，每个点3个float值，一分钟就是18000个float。如果全部缓存在内存中，长时间运行会导致内存溢出。使用批处理器及时消费和清理数据，不要无限缓存。

坑点5：多个传感器同时使用导致功耗叠加

加速度计+陀螺仪+磁力计同时高频采样，功耗是三者之和。对于运动追踪场景，不一定需要同时使用所有传感器。只启用当前功能必需的传感器，其他传感器按需启动。

坑点6：距离过滤设置不合理

GPS的距离过滤参数（distanceFilter）决定了位置变化多少米才触发回调。设置为0表示任何变化都触发，设置为100表示移动100米才触发。距离过滤太低会导致频繁回调，太高则无法及时更新位置，需要根据具体场景调整。

坑点7：忽略传感器的初始化延迟

传感器从启动到稳定输出数据需要一定的初始化时间，GPS尤其明显——冷启动可能需要30秒以上。在初始化期间，传感器功耗较高但不输出有效数据。避免频繁启停传感器，如果只是暂时不需要数据，降低采样率比完全停止更高效。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. 被动定位模式：HarmonyOS 6新增被动定位模式，应用可以监听其他应用触发的定位更新，无需自己启动GPS。这大幅降低了定位功耗——如果系统已经有其他应用在定位，你的应用可以"搭便车"。

2. 硬件FIFO批处理：支持硬件FIFO的传感器可以将数据缓存在传感器芯片中，批量上报给CPU，减少CPU唤醒次数。

3. 系统级活动识别：新增活动识别API，可以检测用户是步行、跑步、骑车还是静止，无需自己实现运动检测算法。

适配代码

// HarmonyOS 6被动定位与活动识别
import { geoLocationManager } from '@kit.LocationKit'
import { activityRecognition } from '@kit.ActivityRecognitionKit'

// 被动定位：监听其他应用的定位更新
function startPassiveLocation(): void {
  // HarmonyOS 6新增：被动定位模式
  geoLocationManager.on('locationChange', (location: geoLocationManager.Location) => {
    console.info(`被动定位更新: ${location.latitude}, ${location.longitude}`)
  })

  // 使用被动定位请求（不主动启动GPS）
  geoLocationManager.startLocating({
    priority: geoLocationManager.LocationRequestPriority.PASSIVE,
    scenario: geoLocationManager.LocationRequestScenario.DAILY_LIFE_SERVICE
  })
}

// 活动识别：检测用户运动状态
function startActivityRecognition(): void {
  // HarmonyOS 6新增：活动识别
  activityRecognition.on('activityChange', (event: activityRecognition.ActivityEvent) => {
    switch (event.activityType) {
      case activityRecognition.ActivityType.WALKING:
        console.info('用户正在步行')
        // 步行场景：降低GPS精度
        break
      case activityRecognition.ActivityType.RUNNING:
        console.info('用户正在跑步')
        // 跑步场景：提高GPS精度
        break
      case activityRecognition.ActivityType.STILL:
        console.info('用户静止')
        // 静止场景：暂停GPS
        break
      case activityRecognition.ActivityType.IN_VEHICLE:
        console.info('用户在车内')
        // 车内场景：使用导航级GPS
        break
    }
  })
}

六、总结

三维度评价表

传感器功耗优化是"精度与功耗的博弈"——没有绝对的最优解，只有最适合当前场景的策略。建议在项目中建立传感器使用规范：明确每个功能所需的最低精度、制定不同电量等级下的降级策略、定期审计传感器使用情况。最好的传感器优化，是不使用传感器——如果可以通过其他方式（如用户输入、缓存数据）获取信息，就不要启动传感器。