HarmonyOS开发：行驶轨迹记录——让每一段行程都有迹可循

📌 核心要点：行驶轨迹记录的核心是GPS采集精度与存储策略的平衡，以及行程数据统计、轨迹回放、驾驶行为分析三大功能的完整实现。

背景与动机

你有没有过这种经历：开车去一个地方，觉得路线不错，想下次还走这条路。结果呢？过了两天就忘了当时走的哪条路了。

又或者，公司要报销油费，你得证明这趟出差确实跑了300公里。你拿什么证明？加油小票只能证明你加了油，不能证明你跑了多远。

行驶轨迹记录就是解决这些问题的。它不只是画一条线在地图上——它记录你什么时候出发、什么时候到达、走了多远、开了多久、均速多少、油耗多少。这些数据组合起来，就是一份完整的"行车日记"。

但GPS轨迹采集不是简单地每隔几秒记一个坐标。采样太密，存储爆炸；采样太疏，轨迹失真。高速上1秒就跑30米，你5秒采一个点，弯道上的轨迹就变成直线了。市区里堵车，1分钟才挪10米，你1秒采一个点，全是重复数据。

怎么在精度和存储之间找到平衡？怎么让轨迹回放流畅自然？怎么从轨迹数据中分析出驾驶习惯？这篇文章一个一个讲。

核心原理

GPS轨迹采集策略

GPS轨迹采集的核心问题是采样频率。频率太高浪费存储，频率太低丢失细节。答案是自适应采样——根据速度动态调整采样间隔。

graph TD
    A[开始行程] --> B[启动GPS采集]
    B --> C{当前车速?}
    
    C -->|> 80km/h 高速| D[高频采样 1秒/次]
    C -->|30-80km/h 城市道路| E[中频采样 3秒/次]
    C -->|< 30km/h 低速/拥堵| F[低频采样 10秒/次]
    C -->|0km/h 停车| G[暂停采样]
    
    D --> H{方向变化>15°?}
    E --> H
    F --> H
    
    H -->|是| I[立即采样 拐点补采]
    H -->|否| J[按间隔采样]
    
    I --> K[存储轨迹点]
    J --> K
    
    G --> L{静止超过5分钟?}
    L -->|是| M[标记停车点]
    L -->|否| B
    
    K --> B

    classDef start fill:#4CAF50,stroke:#2E7D32,color:#fff
    classDef decision fill:#FF9800,stroke:#E65100,color:#fff
    classDef action fill:#2196F3,stroke:#1565C0,color:#fff
    classDef special fill:#9C27B0,stroke:#6A1B9A,color:#fff

    class A,B start
    class C,H,L decision
    class D,E,F,G,I,J,K,M action
    class special fill:#E91E63,stroke:#880E4F,color:#fff

轨迹数据存储结构

一条完整的行程由多个轨迹点组成，每个轨迹点包含以下信息：

一个轨迹点大约100字节。如果1秒采一次，1小时就是360KB，一天开8小时就是2.88MB。看起来不多，但一年下来就是1GB。对于车机有限的存储空间，必须做压缩。

压缩策略：

• 停车期间不采样
• 直线段只保留起止点
• 精度低于20米的点丢弃
• 历史轨迹超过30天的自动归档到云端

驾驶行为分析维度

从轨迹数据中可以提取出以下驾驶行为指标：

1. 急加速：速度变化率超过阈值（如3m/s²）
2. 急减速：减速度超过阈值
3. 急转弯：方向变化率超过阈值
4. 超速：速度超过道路限速
5. 怠速时长：速度为0但发动机运转的时长

这些指标综合起来，可以给驾驶员一个"驾驶评分"——分数越高，驾驶越安全省油。

代码实战

基础用法：GPS轨迹采集与存储

先实现最基础的功能——采集GPS轨迹并存储到本地数据库。

// TripTracker.ets - GPS轨迹采集
import { geoLocationManager } from '@kit.LocationKit';
import { relationalStore } from '@kit.ArkData';

// 轨迹点
export interface TrackPoint {
  latitude: number;
  longitude: number;
  altitude: number;
  speed: number;
  bearing: number;
  timestamp: number;
  accuracy: number;
}

// 行程记录
export interface TripRecord {
  id: string;
  startTime: number;
  endTime: number;
  distance: number;      // 总里程 米
  duration: number;      // 总时长 秒
  avgSpeed: number;      // 平均速度 km/h
  maxSpeed: number;      // 最高速度 km/h
  fuelConsumption: number; // 油耗 L
  pointCount: number;    // 轨迹点数量
}

export class TripTracker {
  private isTracking: boolean = false;
  private currentTripId: string = '';
  private trackPoints: TrackPoint[] = [];
  private lastSampleTime: number = 0;
  private lastBearing: number = 0;
  private totalDistance: number = 0;
  private maxSpeed: number = 0;
  private startTime: number = 0;
  private db: relationalStore.RdbStore | null = null;

  // 初始化数据库
  async initDatabase(context: Context): Promise<void> {
    const config: relationalStore.StoreConfig = {
      name: 'trip_tracker.db',
      securityLevel: relationalStore.SecurityLevel.S1,
    };
    this.db = await relationalStore.getRdbStore(context, config);
    
    // 创建轨迹点表
    const createTableSQL = `
      CREATE TABLE IF NOT EXISTS track_points (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        trip_id TEXT NOT NULL,
        latitude REAL NOT NULL,
        longitude REAL NOT NULL,
        altitude REAL,
        speed REAL,
        bearing REAL,
        timestamp INTEGER NOT NULL,
        accuracy REAL
      )
    `;
    await this.db.executeSql(createTableSQL);
    
    // 创建行程表
    const createTripSQL = `
      CREATE TABLE IF NOT EXISTS trips (
        id TEXT PRIMARY KEY,
        start_time INTEGER NOT NULL,
        end_time INTEGER,
        distance REAL,
        duration INTEGER,
        avg_speed REAL,
        max_speed REAL,
        fuel_consumption REAL,
        point_count INTEGER
      )
    `;
    await this.db.executeSql(createTripSQL);
    console.info('[Trip] 数据库初始化完成');
  }

  // 开始行程记录
  startTrip(): void {
    if (this.isTracking) {
      console.warn('[Trip] 已在记录中');
      return;
    }

    this.isTracking = true;
    this.currentTripId = `trip_${Date.now()}`;
    this.trackPoints = [];
    this.totalDistance = 0;
    this.maxSpeed = 0;
    this.startTime = Date.now();
    this.lastSampleTime = 0;

    // 启动GPS持续定位
    const requestInfo: geoLocationManager.LocationRequest = {
      priority: geoLocationManager.LocationRequestPriority.ACCURACY,
      timeInterval: 1,
      distanceInterval: 0,
      maxAccuracy: 20,
    };

    geoLocationManager.on('locationChange', requestInfo, (location: geoLocationManager.Location) => {
      this.onLocationUpdate(location);
    });

    console.info(`[Trip] 行程开始: ${this.currentTripId}`);
  }

  // GPS位置更新回调
  onLocationUpdate(location: geoLocationManager.Location): void {
    if (!this.isTracking) return;

    const now = Date.now();
    const point: TrackPoint = {
      latitude: location.latitude,
      longitude: location.longitude,
      altitude: location.altitude,
      speed: location.speed * 3.6, // m/s → km/h
      bearing: location.direction,
      timestamp: now,
      accuracy: location.accuracy,
    };

    // 精度检查：低于20米的点丢弃
    if (point.accuracy > 20) {
      return;
    }

    // 自适应采样：根据速度决定采样间隔
    const sampleInterval = this.getSampleInterval(point.speed);
    const timeSinceLastSample = now - this.lastSampleTime;

    // 方向变化检查：转弯时补采
    const bearingChange = Math.abs(point.bearing - this.lastBearing);
    const needCornerSample = bearingChange > 15; // 方向变化超过15°

    if (timeSinceLastSample >= sampleInterval || needCornerSample) {
      // 计算距离
      if (this.trackPoints.length > 0) {
        const lastPoint = this.trackPoints[this.trackPoints.length - 1];
        const dist = this.calculateDistance(
          lastPoint.latitude, lastPoint.longitude,
          point.latitude, point.longitude
        );
        this.totalDistance += dist;
      }

      // 更新最高速度
      if (point.speed > this.maxSpeed) {
        this.maxSpeed = point.speed;
      }

      this.trackPoints.push(point);
      this.lastSampleTime = now;
      this.lastBearing = point.bearing;

      // 异步存储到数据库
      this.saveTrackPoint(point);
    }
  }

  // 结束行程记录
  async stopTrip(): Promise<TripRecord | null> {
    if (!this.isTracking) {
      console.warn('[Trip] 没有正在进行的行程');
      return null;
    }

    this.isTracking = false;
    geoLocationManager.off('locationChange');

    const endTime = Date.now();
    const duration = Math.round((endTime - this.startTime) / 1000);
    const avgSpeed = duration > 0 ? (this.totalDistance / 1000) / (duration / 3600) : 0;

    const trip: TripRecord = {
      id: this.currentTripId,
      startTime: this.startTime,
      endTime: endTime,
      distance: Math.round(this.totalDistance),
      duration: duration,
      avgSpeed: Math.round(avgSpeed * 10) / 10,
      maxSpeed: Math.round(this.maxSpeed),
      fuelConsumption: this.estimateFuel(this.totalDistance, avgSpeed),
      pointCount: this.trackPoints.length,
    };

    // 保存行程记录
    await this.saveTripRecord(trip);
    console.info(`[Trip] 行程结束: ${trip.distance}m, ${Math.ceil(duration / 60)}分钟, 均速${trip.avgSpeed}km/h`);

    return trip;
  }

  // 根据速度获取采样间隔（毫秒）
  private getSampleInterval(speed: number): number {
    if (speed > 80) return 1000;     // 高速：1秒
    if (speed > 30) return 3000;     // 城市道路：3秒
    if (speed > 5) return 10000;     // 低速：10秒
    return 30000;                     // 停车：30秒
  }

  // 计算两点间距离（Haversine公式）
  private calculateDistance(lat1: number, lon1: number, lat2: number, lon2: number): number {
    const R = 6371000; // 地球半径 米
    const dLat = (lat2 - lat1) * Math.PI / 180;
    const dLon = (lon2 - lon1) * Math.PI / 180;
    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
      Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
      Math.sin(dLon / 2) * Math.sin(dLon / 2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    return R * c;
  }

  // 估算油耗（简化模型）
  private estimateFuel(distance: number, avgSpeed: number): number {
    // 百公里油耗估算：城市8L，高速6L，综合7L
    const fuelPer100km = avgSpeed > 60 ? 6 : avgSpeed > 30 ? 7 : 8;
    return Math.round(distance / 1000 * fuelPer100km / 100 * 10) / 10;
  }

  // 保存轨迹点到数据库
  private async saveTrackPoint(point: TrackPoint): Promise<void> {
    if (!this.db) return;
    const valueBucket: relationalStore.ValuesBucket = {
      trip_id: this.currentTripId,
      latitude: point.latitude,
      longitude: point.longitude,
      altitude: point.altitude,
      speed: point.speed,
      bearing: point.bearing,
      timestamp: point.timestamp,
      accuracy: point.accuracy,
    };
    await this.db.insert('track_points', valueBucket);
  }

  // 保存行程记录
  private async saveTripRecord(trip: TripRecord): Promise<void> {
    if (!this.db) return;
    const valueBucket: relationalStore.ValuesBucket = {
      id: trip.id,
      start_time: trip.startTime,
      end_time: trip.endTime,
      distance: trip.distance,
      duration: trip.duration,
      avg_speed: trip.avgSpeed,
      max_speed: trip.maxSpeed,
      fuel_consumption: trip.fuelConsumption,
      point_count: trip.pointCount,
    };
    await this.db.insert('trips', valueBucket);
  }
}

进阶用法：轨迹回放与驾驶行为分析

光记录轨迹不够，还得能回放、能分析。轨迹回放不是简单地按时间顺序画点——那样回放速度要么太快要么太慢，体验很差。驾驶行为分析也不是简单统计——得从轨迹数据中提取出有意义的模式。

// TripAnalyzer.ets - 轨迹回放与驾驶行为分析
import { map } from '@kit.MapKit';

// 驾驶事件
export interface DrivingEvent {
  type: 'hard_accel' | 'hard_brake' | 'sharp_turn' | 'speeding' | 'idling';
  timestamp: number;
  latitude: number;
  longitude: number;
  value: number;    // 事件强度（加速度、速度等）
  description: string;
}

// 驾驶评分
export interface DrivingScore {
  total: number;       // 总分 0-100
  acceleration: number; // 加速评分
  braking: number;      // 制动评分
  cornering: number;    // 转弯评分
  speeding: number;     // 超速评分
  idling: number;       // 怠速评分
}

export class TripAnalyzer {
  // 从轨迹点中检测驾驶事件
  analyzeDrivingBehavior(points: TrackPoint[]): DrivingEvent[] {
    const events: DrivingEvent[] = [];
    
    for (let i = 1; i < points.length; i++) {
      const prev = points[i - 1];
      const curr = points[i];
      const dt = (curr.timestamp - prev.timestamp) / 1000; // 秒
      
      if (dt <= 0) continue;

      // 计算加速度
      const dv = curr.speed - prev.speed; // km/h
      const acceleration = (dv / 3.6) / dt; // m/s²

      // 急加速检测
      if (acceleration > 3.0) {
        events.push({
          type: 'hard_accel',
          timestamp: curr.timestamp,
          latitude: curr.latitude,
          longitude: curr.longitude,
          value: acceleration,
          description: `急加速 ${acceleration.toFixed(1)}m/s²`,
        });
      }

      // 急减速检测
      if (acceleration < -3.5) {
        events.push({
          type: 'hard_brake',
          timestamp: curr.timestamp,
          latitude: curr.latitude,
          longitude: curr.longitude,
          value: Math.abs(acceleration),
          description: `急刹车 ${Math.abs(acceleration).toFixed(1)}m/s²`,
        });
      }

      // 急转弯检测
      const bearingChange = Math.abs(curr.bearing - prev.bearing);
      if (bearingChange > 30 && dt < 3 && curr.speed > 20) {
        events.push({
          type: 'sharp_turn',
          timestamp: curr.timestamp,
          latitude: curr.latitude,
          longitude: curr.longitude,
          value: bearingChange,
          description: `急转弯 ${bearingChange.toFixed(0)}°`,
        });
      }

      // 超速检测（简化：统一120km/h限速）
      if (curr.speed > 120) {
        events.push({
          type: 'speeding',
          timestamp: curr.timestamp,
          latitude: curr.latitude,
          longitude: curr.longitude,
          value: curr.speed,
          description: `超速 ${curr.speed.toFixed(0)}km/h`,
        });
      }

      // 怠速检测（速度<2km/h持续超过60秒）
      if (curr.speed < 2 && prev.speed < 2) {
        const idleDuration = this.checkIdleDuration(points, i);
        if (idleDuration > 60) {
          events.push({
            type: 'idling',
            timestamp: curr.timestamp,
            latitude: curr.latitude,
            longitude: curr.longitude,
            value: idleDuration,
            description: `怠速 ${idleDuration}秒`,
          });
        }
      }
    }

    return events;
  }

  // 计算驾驶评分
  calculateDrivingScore(events: DrivingEvent[], totalDistance: number, duration: number): DrivingScore {
    const hardAccelCount = events.filter(e => e.type === 'hard_accel').length;
    const hardBrakeCount = events.filter(e => e.type === 'hard_brake').length;
    const sharpTurnCount = events.filter(e => e.type === 'sharp_turn').length;
    const speedingCount = events.filter(e => e.type === 'speeding').length;
    const idlingCount = events.filter(e => e.type === 'idling').length;

    // 每百公里事件数
    const per100km = totalDistance > 0 ? 100000 / totalDistance : 1;

    const acceleration = Math.max(0, 100 - hardAccelCount * per100km * 5);
    const braking = Math.max(0, 100 - hardBrakeCount * per100km * 4);
    const cornering = Math.max(0, 100 - sharpTurnCount * per100km * 6);
    const speeding = Math.max(0, 100 - speedingCount * per100km * 8);
    const idling = Math.max(0, 100 - idlingCount * per100km * 2);

    const total = Math.round(
      acceleration * 0.2 + braking * 0.25 + cornering * 0.2 + speeding * 0.25 + idling * 0.1
    );

    return { total, acceleration, braking, cornering, speeding, idling };
  }

  // 检查怠速持续时长
  private checkIdleDuration(points: TrackPoint[], currentIndex: number): number {
    let duration = 0;
    for (let i = currentIndex; i > 0; i--) {
      if (points[i].speed >= 2) break;
      duration += (points[i].timestamp - points[i - 1].timestamp) / 1000;
    }
    return Math.round(duration);
  }
}

完整示例：行程记录页面

把轨迹采集、行程统计、驾驶评分整合到一个完整的页面里。

// TripRecordPage.ets - 行程记录完整页面
@Entry
@Component
struct TripRecordPage {
  @State isTracking: boolean = false;
  @State currentSpeed: number = 0;
  @State currentDistance: number = 0;
  @State currentDuration: string = '00:00';
  @State drivingScore: number = 95;
  @State recentTrips: TripRecord[] = [];
  @State selectedTrip: TripRecord | null = null;

  private durationTimer: number = -1;
  private elapsedSeconds: number = 0;

  build() {
    Column({ space: 16 }) {
      // 标题
      Row() {
        Text('行程记录')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor(Color.White)
      }
      .width('100%')
      .padding({ left: 30, top: 20 })

      if (this.isTracking) {
        // 记录中：显示实时数据
        this.RecordingView()
      } else {
        // 未记录：显示历史行程
        this.HistoryView()
      }
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0D1117')
  }

  // 记录中视图
  @Builder
  RecordingView() {
    Column({ space: 20 }) {
      // 实时数据卡片
      Row({ space: 20 }) {
        this.DataCard('当前速度', `${this.currentSpeed}`, 'km/h', '#4FC3F7')
        this.DataCard('行驶距离', `${(this.currentDistance / 1000).toFixed(1)}`, 'km', '#4CAF50')
        this.DataCard('用时', this.currentDuration, '', '#FF9800')
      }
      .padding({ left: 30, right: 30 })

      // 驾驶评分
      Column({ space: 8 }) {
        Text('驾驶评分')
          .fontSize(14)
          .fontColor('#888888')
        Text(`${this.drivingScore}`)
          .fontSize(56)
          .fontWeight(FontWeight.Bold)
          .fontColor(this.drivingScore >= 80 ? '#4CAF50' : this.drivingScore >= 60 ? '#FF9800' : '#F44336')
        Text(this.drivingScore >= 80 ? '优秀' : this.drivingScore >= 60 ? '良好' : '需改善')
          .fontSize(16)
          .fontColor('#AAAAAA')
      }
      .padding(20)

      // 停止按钮
      Button('结束行程')
        .fontSize(20)
        .fontColor(Color.White)
        .backgroundColor('#F44336')
        .borderRadius(28)
        .width(200)
        .height(56)
        .onClick(() => this.stopRecording())
    }
    .layoutWeight(1)
    .justifyContent(FlexAlign.Center)
  }

  // 历史行程视图
  @Builder
  HistoryView() {
    Column({ space: 16 }) {
      // 开始按钮
      Button('开始记录')
        .fontSize(20)
        .fontColor(Color.White)
        .backgroundColor('#4CAF50')
        .borderRadius(28)
        .width(200)
        .height(56)
        .onClick(() => this.startRecording())

      // 历史行程列表
      Text('历史行程')
        .fontSize(18)
        .fontWeight(FontWeight.Medium)
        .fontColor(Color.White)
        .padding({ left: 30 })
        .alignSelf(ItemAlign.Start)

      if (this.recentTrips.length === 0) {
        Text('暂无行程记录')
          .fontSize(16)
          .fontColor('#888888')
          .padding({ top: 40 })
      } else {
        List({ space: 12 }) {
          ForEach(this.recentTrips, (trip: TripRecord) => {
            ListItem() {
              this.TripCard(trip)
            }
          })
        }
        .padding({ left: 30, right: 30 })
        .layoutWeight(1)
      }
    }
    .layoutWeight(1)
  }

  @Builder
  DataCard(title: string, value: string, unit: string, color: string) {
    Column({ space: 4 }) {
      Text(title)
        .fontSize(12)
        .fontColor('#888888')
      Row({ space: 4 }) {
        Text(value)
          .fontSize(28)
          .fontWeight(FontWeight.Bold)
          .fontColor(color)
        if (unit) {
          Text(unit)
            .fontSize(12)
            .fontColor('#888888')
            .alignSelf(ItemAlign.End)
            .margin({ bottom: 4 })
        }
      }
    }
    .layoutWeight(1)
    .padding(16)
    .backgroundColor('#161B22')
    .borderRadius(12)
    .alignItems(HorizontalAlign.Center)
  }

  @Builder
  TripCard(trip: TripRecord) {
    Row({ space: 16 }) {
      Column({ space: 4 }) {
        Text(this.formatDate(trip.startTime))
          .fontSize(16)
          .fontColor(Color.White)
        Text(`${(trip.distance / 1000).toFixed(1)}km · ${Math.ceil(trip.duration / 60)}分钟`)
          .fontSize(13)
          .fontColor('#888888')
      }
      .layoutWeight(1)
      .alignItems(HorizontalAlign.Start)

      Column({ space: 4 }) {
        Text(`均速 ${trip.avgSpeed}km/h`)
          .fontSize(13)
          .fontColor('#4FC3F7')
        Text(`油耗 ${trip.fuelConsumption}L`)
          .fontSize(13)
          .fontColor('#FF9800')
      }
      .alignItems(HorizontalAlign.End)
    }
    .width('100%')
    .padding(16)
    .backgroundColor('#161B22')
    .borderRadius(12)
  }

  // 开始记录
  private startRecording(): void {
    this.isTracking = true;
    this.elapsedSeconds = 0;
    this.currentDistance = 0;
    this.currentSpeed = 0;
    this.drivingScore = 95;

    // 启动计时器
    this.durationTimer = setInterval(() => {
      this.elapsedSeconds++;
      const hours = Math.floor(this.elapsedSeconds / 3600);
      const mins = Math.floor((this.elapsedSeconds % 3600) / 60);
      const secs = this.elapsedSeconds % 60;
      this.currentDuration = hours > 0
        ? `${hours}:${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
        : `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
    }, 1000) as unknown as number;
  }

  // 停止记录
  private stopRecording(): void {
    this.isTracking = false;
    if (this.durationTimer !== -1) {
      clearInterval(this.durationTimer);
      this.durationTimer = -1;
    }
  }

  // 格式化日期
  private formatDate(timestamp: number): string {
    const date = new Date(timestamp);
    return `${date.getMonth() + 1}/${date.getDate()} ${date.getHours()}:${date.getMinutes().toString().padStart(2, '0')}`;
  }
}

踩坑与注意事项

坑1：GPS漂移导致轨迹"飞点"

GPS信号不好的时候（高楼密集区、隧道出入口），定位会突然跳到很远的地方，轨迹上出现一条"飞线"。这种"飞点"会让里程计算严重失真——一个飞点可能凭空增加几公里。

解决方案：

• 检查相邻两点的距离，如果超过物理可能（比如1秒移动了500米），判定为飞点，丢弃
• 检查GPS精度值，精度低于20米的点直接丢弃
• 对轨迹做平滑处理，使用Kalman滤波或移动平均

坑2：后台定位被系统杀死

HarmonyOS对后台定位有严格限制。应用切到后台后，如果不在前台持续显示通知，定位服务可能被系统回收。

解决方案：

• 使用continuousTask（长时任务）保持后台定位
• 在通知栏显示"正在记录行程"的持续通知
• 申请ohos.permission.LOCATION_ALWAYS权限（始终定位）

坑3：轨迹回放的性能问题

一条3小时的行程，按1秒采样，有10800个轨迹点。如果回放时逐点渲染，地图组件会卡死。

解决方案：

• 回放时按时间窗口聚合点，每100毫秒渲染一批
• 只渲染当前可视区域内的点，屏幕外的点不渲染
• 使用地图SDK的polyline接口一次性画线，不要逐点addMarker

坑4：油耗估算不准

油耗受太多因素影响——驾驶习惯、路况、空调、载重、天气。你用简单的公式估算，误差可能超过30%。

更靠谱的方案：

• 如果车辆支持，直接从CAN总线读取瞬时油耗（VehiclePropertyId.FUEL_CONSUMPTION）
• 不支持的话，结合速度、加速度、怠速时长做加权估算
• 允许用户手动输入加油量来校准

坑5：轨迹分享的隐私问题

用户分享轨迹时，可能无意中暴露了家庭住址、公司地址。轨迹起止点通常就是家和公司。

解决方案：

• 分享时自动模糊起止点（前后各500米不显示）
• 提供裁剪功能，让用户选择分享哪段轨迹
• 分享链接设置有效期，过期自动失效

HarmonyOS 6适配说明

HarmonyOS 6在行程记录方面做了几项更新：

1. 后台定位保活增强：新增CarBackgroundTask类型，专门用于车载应用的后台长时任务。相比普通的长时任务，CarBackgroundTask在系统资源紧张时优先级更高，不容易被杀死。

2. 轨迹压缩算法内置：新增TripCompressor工具类，内置Douglas-Peucker算法，可以将轨迹点数量压缩60-80%而保持形状精度。之前需要自己实现。

3. 驾驶行为模型升级：新增基于机器学习的驾驶行为评估模型，比规则匹配更准确。系统会根据大量驾驶数据训练模型，你的应用可以直接调用DrivingBehaviorAnalyzer获取评分。

4. 轨迹数据跨设备同步：基于分布式数据管理，行程数据可以在手机和车机之间自动同步。车机记录的轨迹，手机上也能查看和分享。

适配代码：

// HarmonyOS 6 轨迹压缩
import { car } from '@kit.CarKit';

async function compressTrack(points: TrackPoint[]): Promise<TrackPoint[]> {
  const compressor = car.createTripCompressor();
  
  // Douglas-Peucker算法压缩，保留5米精度
  const compressed = await compressor.compress(points, {
    algorithm: car.CompressAlgorithm.DOUGLAS_PEUCKER,
    epsilon: 5, // 5米精度
    preserveCorners: true, // 保留拐点
  });

  console.info(`[Trip] 压缩: ${points.length} → ${compressed.length} 点, ` +
    `压缩率 ${((1 - compressed.length / points.length) * 100).toFixed(1)}%`);
  
  return compressed;
}

总结

行驶轨迹记录看起来就是"采GPS点、画线、统计"，但每个环节都有坑——GPS漂移、后台保活、存储压缩、回放性能、油耗估算、隐私保护。这些细节处理不好，轨迹记录就是一堆没用的数据。处理好了，它就是用户最有价值的行车助手。

一句话：轨迹记录的价值不在于画线，而在于从数据中提取出有用的信息——里程统计、油耗分析、驾驶评分，这些才是用户真正需要的。