鸿蒙运动轨迹记录器开发指南

一、系统架构设计

基于HarmonyOS的分布式能力和位置服务，构建智能运动轨迹记录系统：

1. ​​感知层​​：GPS/北斗定位数据采集
2. ​​处理层​​：自适应采样与轨迹压缩
3. ​​存储层​​：分布式轨迹数据存储
4. ​​节能层​​：低电量模式降级策略

https://example.com/harmony-tracker-arch.png

二、核心代码实现

1. 自适应GPS采样控制器

// GpsSampler.ets
import geolocation from '@ohos.geolocation';
import powerManagement from '@ohos.powerManagement';

class GpsSampler {
  private static instance: GpsSampler = null;
  private currentInterval: number = 1000; // 默认1秒
  private lastLocation: geolocation.Location = null;
  private isActive: boolean = false;
  private powerManager: powerManagement.PowerManager;
  
  // 根据运动状态动态调整的采样间隔配置
  private intervalProfiles = {
    stationary: 5000,    // 静止状态5秒
    walking: 2000,       // 步行2秒
    running: 1000,       // 跑步1秒
    driving: 500,        // 驾驶500毫秒
    highSpeed: 300       // 高速运动300毫秒
  };
  
  private constructor() {
    this.powerManager = powerManagement.createPowerManager();
  }
  
  public static getInstance(): GpsSampler {
    if (!GpsSampler.instance) {
      GpsSampler.instance = new GpsSampler();
    }
    return GpsSampler.instance;
  }
  
  public startTracking(): void {
    if (this.isActive) return;
    
    this.isActive = true;
    this.requestLocationUpdates();
  }
  
  public stopTracking(): void {
    this.isActive = false;
    geolocation.off('locationChange');
  }
  
  private requestLocationUpdates(): void {
    geolocation.on('locationChange', (location: geolocation.Location) => {
      this.handleNewLocation(location);
      
      // 根据运动状态调整采样率
      this.adjustSamplingRate(location);
      
      // 重新设置监听，应用新的间隔时间
      if (this.isActive) {
        geolocation.off('locationChange');
        this.setLocationUpdateInterval();
      }
    });
    
    this.setLocationUpdateInterval();
  }
  
  private setLocationUpdateInterval(): void {
    // 根据电量状态调整采样率
    const powerMode = this.powerManager.getPowerMode();
    const adjustedInterval = powerMode === powerManagement.PowerMode.POWER_SAVE ? 
                          Math.max(this.currentInterval * 2, 10000) : // 省电模式最低10秒
                          this.currentInterval;
    
    geolocation.on('locationChange', {
      interval: adjustedInterval,
      priority: geolocation.LocationRequestPriority.FIRST_FIX,
      accuracy: geolocation.LocationAccuracy.BALANCED
    });
  }
  
  private handleNewLocation(location: geolocation.Location): void {
    this.lastLocation = location;
    // 触发轨迹处理逻辑...
  }
  
  private adjustSamplingRate(newLocation: geolocation.Location): void {
    if (!this.lastLocation) {
      this.currentInterval = this.intervalProfiles.walking;
      return;
    }
    
    // 计算移动速度(米/秒)
    const distance = this.calculateDistance(
      this.lastLocation.latitude,
      this.lastLocation.longitude,
      newLocation.latitude,
      newLocation.longitude
    );
    const timeDiff = (newLocation.timeStamp - this.lastLocation.timeStamp) / 1000;
    const speed = distance / timeDiff;
    
    // 根据速度调整采样间隔
    if (speed < 0.5) {
      this.currentInterval = this.intervalProfiles.stationary;
    } else if (speed < 2) {
      this.currentInterval = this.intervalProfiles.walking;
    } else if (speed < 5) {
      this.currentInterval = this.intervalProfiles.running;
    } else if (speed < 15) {
      this.currentInterval = this.intervalProfiles.driving;
    } else {
      this.currentInterval = this.intervalProfiles.highSpeed;
    }
  }
  
  private calculateDistance(lat1: number, lon1: number, lat2: number, lon2: number): number {
    // 简化的距离计算（实际应用应使用更精确的算法）
    const R = 6371000; // 地球半径(米)
    const dLat = this.toRad(lat2 - lat1);
    const dLon = this.toRad(lon2 - lon1);
    const a = 
      Math.sin(dLat / 2) * Math.sin(dLat / 2) +
      Math.cos(this.toRad(lat1)) * Math.cos(this.toRad(lat2)) * 
      Math.sin(dLon / 2) * Math.sin(dLon / 2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    return R * c;
  }
  
  private toRad(degrees: number): number {
    return degrees * Math.PI / 180;
  }
}

export const gpsSampler = GpsSampler.getInstance();

2. 轨迹压缩存储算法

// TrajectoryCompressor.ets
import distributedData from '@ohos.distributedData';

class TrajectoryCompressor {
  private static instance: TrajectoryCompressor = null;
  private dataManager: distributedData.DataManager;
  private compressionThreshold = 0.0001; // 压缩敏感度
  
  private constructor() {
    this.dataManager = distributedData.createDataManager({
      bundleName: 'com.example.tracker',
      area: distributedData.Area.GLOBAL,
      isEncrypted: true
    });
  }
  
  public static getInstance(): TrajectoryCompressor {
    if (!TrajectoryCompressor.instance) {
      TrajectoryCompressor.instance = new TrajectoryCompressor();
    }
    return TrajectoryCompressor.instance;
  }
  
  // 使用Douglas-Peucker算法压缩轨迹
  public compress(trajectory: Array<geolocation.Location>): Array<geolocation.Location> {
    if (trajectory.length <= 2) return trajectory;
    
    // 找到最大偏移点
    let maxDistance = 0;
    let index = 0;
    const end = trajectory.length - 1;
    
    for (let i = 1; i < end; i++) {
      const distance = this.perpendicularDistance(
        trajectory[i],
        trajectory[0],
        trajectory[end]
      );
      
      if (distance > maxDistance) {
        maxDistance = distance;
        index = i;
      }
    }
    
    // 如果最大距离大于阈值，递归压缩
    if (maxDistance > this.compressionThreshold) {
      const left = this.compress(trajectory.slice(0, index + 1));
      const right = this.compress(trajectory.slice(index));
      return left.slice(0, left.length - 1).concat(right);
    } else {
      return [trajectory[0], trajectory[end]];
    }
  }
  
  // 计算点到线的垂直距离
  private perpendicularDistance(
    point: geolocation.Location,
    lineStart: geolocation.Location,
    lineEnd: geolocation.Location
  ): number {
    const area = Math.abs(
      (lineEnd.longitude - lineStart.longitude) * (lineStart.latitude - point.latitude) -
      (lineStart.longitude - point.longitude) * (lineEnd.latitude - lineStart.latitude)
    );
    
    const lineLength = Math.sqrt(
      Math.pow(lineEnd.longitude - lineStart.longitude, 2) +
      Math.pow(lineEnd.latitude - lineStart.latitude, 2)
    );
    
    return area / lineLength;
  }
  
  // 存储压缩后的轨迹到分布式数据库
  public async storeCompressedTrajectory(
    trajectoryId: string,
    compressedTrajectory: Array<geolocation.Location>
  ): Promise<void> {
    try {
      await this.dataManager.put({
        key: `trajectory_${trajectoryId}`,
        value: JSON.stringify(compressedTrajectory)
      });
      
      // 同步到其他设备
      this.dataManager.syncData('trajectory_sync', {
        type: 'trajectory_update',
        trajectoryId,
        size: compressedTrajectory.length
      });
    } catch (err) {
      console.error('存储轨迹失败:', JSON.stringify(err));
    }
  }
}

export const trajectoryCompressor = TrajectoryCompressor.getInstance();

3. 低电量模式降级策略

// PowerSavingManager.ets
import powerManagement from '@ohos.powerManagement';
import featureAbility from '@ohos.ability.featureAbility';

class PowerSavingManager {
  private static instance: PowerSavingManager = null;
  private powerManager: powerManagement.PowerManager;
  private batteryLevel: number = 100;
  private isPowerSaveMode: boolean = false;
  
  private constructor() {
    this.powerManager = powerManagement.createPowerManager();
    this.initBatteryListener();
  }
  
  public static getInstance(): PowerSavingManager {
    if (!PowerSavingManager.instance) {
      PowerSavingManager.instance = new PowerSavingManager();
    }
    return PowerSavingManager.instance;
  }
  
  private initBatteryListener(): void {
    // 监听电量变化
    powerManagement.on('batteryLevelChange', (data) => {
      this.batteryLevel = data.batteryLevel;
      this.checkPowerStatus();
    });
    
    // 监听电源模式变化
    powerManagement.on('powerModeChange', (mode) => {
      this.isPowerSaveMode = (mode === powerManagement.PowerMode.POWER_SAVE);
      this.adjustFeatures();
    });
  }
  
  private checkPowerStatus(): void {
    // 当电量低于20%时自动进入节电模式
    if (this.batteryLevel < 20 && !this.isPowerSaveMode) {
      this.enablePowerSaving(true);
    } else if (this.batteryLevel > 30 && this.isPowerSaveMode) {
      this.enablePowerSaving(false);
    }
  }
  
  private enablePowerSaving(enable: boolean): void {
    this.isPowerSaveMode = enable;
    this.adjustFeatures();
    
    // 通知其他设备当前电源状态
    distributedData.syncData('power_status_sync', {
      type: 'power_mode_change',
      isPowerSave: enable,
      batteryLevel: this.batteryLevel
    });
  }
  
  // 根据电源状态调整功能
  private adjustFeatures(): void {
    const gpsSampler = GpsSampler.getInstance();
    const trajectoryCompressor = TrajectoryCompressor.getInstance();
    
    if (this.isPowerSaveMode) {
      // 节电模式下的降级策略
      gpsSampler.setMinInterval(15000); // 最低15秒采样
      trajectoryCompressor.setCompressionThreshold(0.0005); // 提高压缩率
      
      // 关闭非必要功能
      this.disableBackgroundSync();
      this.reduceLocationAccuracy();
    } else {
      // 恢复正常模式
      gpsSampler.resetInterval();
      trajectoryCompressor.resetCompressionThreshold();
      
      // 恢复功能
      this.enableBackgroundSync();
      this.restoreLocationAccuracy();
    }
  }
  
  private disableBackgroundSync(): void {
    // 实现后台同步禁用逻辑
  }
  
  private reduceLocationAccuracy(): void {
    // 降低定位精度以节省电量
    geolocation.off('locationChange');
    geolocation.on('locationChange', {
      priority: geolocation.LocationRequestPriority.LOW_POWER,
      accuracy: geolocation.LocationAccuracy.LOW
    });
  }
  
  // ...其他方法实现
}

export const powerSavingManager = PowerSavingManager.getInstance();

4. 主界面实现

// MainScreen.ets
import { gpsSampler } from './GpsSampler';
import { trajectoryCompressor } from './TrajectoryCompressor';
import { powerSavingManager } from './PowerSavingManager';

@Component
export struct MainScreen {
  @State isTracking: boolean = false;
  @State currentTrajectory: Array<geolocation.Location> = [];
  @State compressedSize: number = 0;
  @State batteryLevel: number = 100;
  @State isPowerSave: boolean = false;
  
  build() {
    Column() {
      // 状态显示区
      Row() {
        Text(this.isTracking ? '追踪中' : '已停止')
          .fontColor(this.isTracking ? '#4CAF50' : '#F44336')
          .layoutWeight(1)
        
        Text(`电量: ${this.batteryLevel}%`)
          .fontColor(this.isPowerSave ? '#FFC107' : '#2196F3')
        
        Text(this.isPowerSave ? '节电模式' : '正常模式')
          .margin({ left: 10 })
      }
      .padding(10)
      
      // 控制按钮
      Button(this.isTracking ? '停止记录' : '开始记录')
        .width(200)
        .height(50)
        .fontSize(18)
        .onClick(() => {
          this.toggleTracking();
        })
      
      // 轨迹信息
      if (this.currentTrajectory.length > 0) {
        Column() {
          Text(`轨迹点: ${this.currentTrajectory.length}`)
            .margin({ top: 20 })
          
          Text(`压缩后: ${this.compressedSize} (${Math.round((1 - this.compressedSize / this.currentTrajectory.length) * 100)}%节省)`)
            .margin({ top: 5 })
          
          // 显示简单轨迹图...
        }
      }
      
      // 节电模式控制
      Toggle({ type: ToggleType.Switch, isOn: this.isPowerSave })
        .onChange((isOn) => {
          powerSavingManager.enablePowerSaving(isOn);
        })
        .margin({ top: 20 })
    }
    .width('100%')
    .height('100%')
    .padding(20)
  }
  
  private toggleTracking(): void {
    this.isTracking = !this.isTracking;
    
    if (this.isTracking) {
      this.startNewTrajectory();
    } else {
      this.stopAndSaveTrajectory();
    }
  }
  
  private startNewTrajectory(): void {
    this.currentTrajectory = [];
    gpsSampler.startTracking();
    
    // 监听位置变化
    geolocation.on('locationChange', (location) => {
      this.currentTrajectory.push(location);
    });
  }
  
  private async stopAndSaveTrajectory(): Promise<void> {
    gpsSampler.stopTracking();
    geolocation.off('locationChange');
    
    // 压缩轨迹
    const compressed = trajectoryCompressor.compress(this.currentTrajectory);
    this.compressedSize = compressed.length;
    
    // 存储轨迹
    const trajectoryId = new Date().getTime().toString();
    await trajectoryCompressor.storeCompressedTrajectory(trajectoryId, compressed);
    
    prompt.showToast({ message: '轨迹已保存' });
  }
  
  aboutToAppear() {
    // 监听电量变化
    powerManagement.on('batteryLevelChange', (data) => {
      this.batteryLevel = data.batteryLevel;
    });
    
    // 监听电源模式变化
    powerManagement.on('powerModeChange', (mode) => {
      this.isPowerSave = (mode === powerManagement.PowerMode.POWER_SAVE);
    });
  }
}

三、项目配置与权限

1. 权限配置

// module.json5
{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.LOCATION",
        "reason": "获取GPS位置信息记录运动轨迹"
      },
      {
        "name": "ohos.permission.LOCATION_IN_BACKGROUND",
        "reason": "后台持续记录运动轨迹"
      },
      {
        "name": "ohos.permission.DISTRIBUTED_DATASYNC",
        "reason": "同步轨迹数据到其他设备"
      },
      {
        "name": "ohos.permission.GET_BATTERY_INFO",
        "reason": "获取电量信息实现节电策略"
      }
    ],
    "abilities": [
      {
        "name": "MainAbility",
        "type": "page",
        "backgroundModes": ["location"],
        "visible": true
      }
    ]
  }
}

四、总结与扩展

本运动轨迹记录器实现了三大核心功能：

1. ​​智能采样控制​​：根据运动速度动态调整GPS采样率
2. ​​高效轨迹压缩​​：使用Douglas-Peucker算法减少存储空间
3. ​​电量感知降级​​：低电量时自动降低功能规格

​​扩展方向​​：

1. ​​多运动模式识别​​：自动检测步行、跑步、骑行等不同运动状态
2. ​​云端轨迹同步​​：将轨迹备份到云端并跨设备恢复
3. ​​社交分享功能​​：分享运动轨迹到社交平台
4. ​​健康数据分析​​：结合心率等传感器数据提供健康建议
5. ​​AR轨迹回放​​：使用AR技术重现运动过程
6. ​​离线地图支持​​：在没有网络时仍能显示轨迹地图

通过HarmonyOS的分布式能力，该系统可以实现多设备间的轨迹同步和协同记录，为用户提供更加完整和一致的运动体验。