HarmonyOS开发：路径规划算法与多策略选择

核心要点：本文深入解析HarmonyOS导航系统中的路径规划算法体系，涵盖Dijkstra、A*、CH（Contraction Hierarchies）等经典算法原理，多策略（最短时间/最短距离/避免收费/绿色出行）选择机制，以及在HarmonyOS上的ArkTS实现与性能优化。

| 开发语言 | ArkTS |
| 核心框架 | ArkUI (StateManagement V2) |
| 相关文档 | 地图服务开发指南 / 网络管理开发 |

一、背景与动机

路径规划是导航系统的"大脑"，决定了从A到B走哪条路。一个优秀的路径规划系统需要满足以下需求：

1. 多策略支持：用户可能追求最短时间、最短距离、避免高速、避免收费、绿色低碳等不同目标
2. 实时性要求：规划耗时需控制在秒级，否则用户等待体验差
3. 大规模路网：全国路网节点数以百万计，算法需高效处理
4. 多模式交通：驾车、步行、骑行、公交各有不同的路网和规则
5. HarmonyOS分布式优势：可利用设备端算力做本地规划，减少云端依赖

二、核心原理

2.1 路径规划算法体系

flowchart TB
    subgraph 算法选型
        A[路径规划请求] --> B{路网规模?}
        B -->|小规模<br/>节点<1万| C[Dijkstra算法]
        B -->|中规模<br/>节点1-100万| D[A*算法]
        B -->|大规模<br/>节点>100万| E[CH预处理加速]
    end

    subgraph 策略层
        C --> F[策略权重计算]
        D --> F
        E --> F
        F --> G{用户选择策略}
        G -->|最短时间| H[时间权重图]
        G -->|最短距离| I[距离权重图]
        G -->|避免收费| J[收费惩罚图]
        G -->|绿色出行| K[碳排放权重图]
    end

    subgraph 输出
        H --> L[多路线候选集]
        I --> L
        J --> L
        K --> L
        L --> M[路线排序与推荐]
        M --> N[最优路线 + 备选路线]
    end

    classDef processStyle fill:#16213e,stroke:#0f3460,color:#e0e0e0
    classDef decisionStyle fill:#0f3460,stroke:#e94560,color:#fff
    classDef outputStyle fill:#533483,stroke:#e94560,color:#fff
    classDef dataStyle fill:#1a1a2e,stroke:#e94560,color:#fff

    class A,C,D,E,F processStyle
    class B,G decisionStyle
    class H,I,J,K dataStyle
    class L,M,N outputStyle

2.2 Dijkstra算法

Dijkstra是最经典的单源最短路径算法，采用贪心策略逐步扩展最短路径树：

• 时间复杂度：O((V+E)logV)（使用优先队列）
• 优点：保证全局最优，实现简单
• 缺点：无方向性引导，在大规模路网上搜索空间大

2.3 A*算法

A*在Dijkstra基础上引入启发式函数，引导搜索朝目标方向进行：

• 核心公式：f(n) = g(n) + h(n)，其中g(n)为已走代价，h(n)为到终点的估计代价
• 启发函数：通常使用欧几里得距离或曼哈顿距离
• 关键性质：当h(n)满足可容许性（不高估实际代价）时，A*保证找到最优解
• 性能提升：相比Dijkstra，搜索节点数可减少50%-90%

2.4 CH（Contraction Hierarchies）

CH是业界大规模路网规划的标准方案，核心思想是预处理路网构建层次结构：

flowchart LR
    A[原始路网] --> B[节点重要性排序]
    B --> C[逐节点收缩<br/>添加Shortcut边]
    C --> D[层次化路网]
    D --> E[双向A*搜索<br/>仅向上扩展]
    E --> F[毫秒级规划结果]

    classDef inputStyle fill:#1a1a2e,stroke:#e94560,color:#fff
    classDef processStyle fill:#16213e,stroke:#0f3460,color:#e0e0e0
    classDef outputStyle fill:#533483,stroke:#e94560,color:#fff

    class A inputStyle
    class B,C,D,E processStyle
    class F outputStyle

2.5 多策略权重模型

不同导航策略的本质是边权重函数不同：

三、代码实战

3.1 路网图数据结构

// PathPlanningGraph.ets - 路网图数据结构

/** 路网节点 */
export interface GraphNode {
  id: number;
  latitude: number;
  longitude: number;
  importance: number;          // CH重要性等级（预处理用）
}

/** 路网边 */
export interface GraphEdge {
  fromId: number;
  toId: number;
  length: number;              // 长度（米）
  speed: number;               // 限速（km/h）
  isToll: boolean;             // 是否收费
  isHighway: boolean;          // 是否高速
  roadClass: RoadClass;        // 道路等级
  emissionFactor: number;      // 碳排放系数
  trafficDelay: number;        // 实时路况延迟（秒）
}

/** 道路等级 */
export enum RoadClass {
  MOTORWAY = 1,       // 高速公路
  TRUNK = 2,          // 国道
  PRIMARY = 3,        // 省道/主干道
  SECONDARY = 4,      // 次干道
  TERTIARY = 5,       // 支路
  RESIDENTIAL = 6     // 住宅区道路
}

/** 导航策略 */
export enum RouteStrategy {
  FASTEST = 'fastest',           // 最短时间
  SHORTEST = 'shortest',         // 最短距离
  NO_TOLL = 'no-toll',           // 避免收费
  NO_HIGHWAY = 'no-highway',     // 避免高速
  GREEN = 'green'                // 绿色出行
}

/** 路网图 */
export class PathPlanningGraph {
  private nodes: Map<number, GraphNode> = new Map();
  private adjacency: Map<number, GraphEdge[]> = new Map();  // 邻接表
  private chLevel: Map<number, number> = new Map();         // CH层次

  /** 添加节点 */
  addNode(node: GraphNode): void {
    this.nodes.set(node.id, node);
    if (!this.adjacency.has(node.id)) {
      this.adjacency.set(node.id, []);
    }
  }

  /** 添加边（双向） */
  addEdge(edge: GraphEdge): void {
    const fromEdges = this.adjacency.get(edge.fromId) ?? [];
    fromEdges.push(edge);
    this.adjacency.set(edge.fromId, fromEdges);

    // 反向边
    const reverseEdge: GraphEdge = {
      fromId: edge.toId,
      toId: edge.fromId,
      length: edge.length,
      speed: edge.speed,
      isToll: edge.isToll,
      isHighway: edge.isHighway,
      roadClass: edge.roadClass,
      emissionFactor: edge.emissionFactor,
      trafficDelay: edge.trafficDelay
    };
    const toEdges = this.adjacency.get(edge.toId) ?? [];
    toEdges.push(reverseEdge);
    this.adjacency.set(edge.toId, toEdges);
  }

  /** 获取节点 */
  getNode(id: number): GraphNode | undefined {
    return this.nodes.get(id);
  }

  /** 获取邻居边 */
  getEdges(nodeId: number): GraphEdge[] {
    return this.adjacency.get(nodeId) ?? [];
  }

  /** 节点数量 */
  get nodeCount(): number {
    return this.nodes.size;
  }

  /** 设置CH层次等级 */
  setCHLevel(nodeId: number, level: number): void {
    this.chLevel.set(nodeId, level);
  }

  /** 获取CH层次等级 */
  getCHLevel(nodeId: number): number {
    return this.chLevel.get(nodeId) ?? 0;
  }
}

3.2 A*路径规划引擎

// AStarPlanner.ets - A*路径规划引擎

import { PathPlanningGraph, GraphNode, GraphEdge, RouteStrategy } from './PathPlanningGraph';

/** 优先队列项 */
interface QueueItem {
  nodeId: number;
  gCost: number;     // 已走代价
  fCost: number;     // 总估计代价 f = g + h
  parent: number;    // 父节点ID
  edgeFrom: number;  // 经过的边来源节点
}

/** 规划结果 */
export interface PlanResult {
  path: number[];              // 节点ID序列
  totalCost: number;           // 总代价
  totalDistance: number;       // 总距离（米）
  totalDuration: number;       // 总时间（秒）
  edges: GraphEdge[];          // 经过的边序列
}

/** 简易优先队列（小顶堆） */
class MinHeap {
  private heap: QueueItem[] = [];

  push(item: QueueItem): void {
    this.heap.push(item);
    this.bubbleUp(this.heap.length - 1);
  }

  pop(): QueueItem | undefined {
    if (this.heap.length === 0) return undefined;
    const top = this.heap[0];
    const last = this.heap.pop()!;
    if (this.heap.length > 0) {
      this.heap[0] = last;
      this.bubbleDown(0);
    }
    return top;
  }

  get size(): number {
    return this.heap.length;
  }

  private bubbleUp(index: number): void {
    while (index > 0) {
      const parent = Math.floor((index - 1) / 2);
      if (this.heap[parent].fCost <= this.heap[index].fCost) break;
      [this.heap[parent], this.heap[index]] = [this.heap[index], this.heap[parent]];
      index = parent;
    }
  }

  private bubbleDown(index: number): void {
    const len = this.heap.length;
    while (true) {
      let smallest = index;
      const left = 2 * index + 1;
      const right = 2 * index + 2;
      if (left < len && this.heap[left].fCost < this.heap[smallest].fCost) smallest = left;
      if (right < len && this.heap[right].fCost < this.heap[smallest].fCost) smallest = right;
      if (smallest === index) break;
      [this.heap[smallest], this.heap[index]] = [this.heap[index], this.heap[smallest]];
      index = smallest;
    }
  }
}

export class AStarPlanner {
  private graph: PathPlanningGraph;
  private strategy: RouteStrategy;

  /** 策略惩罚参数 */
  private static readonly TOLL_PENALTY = 3600;     // 收费路段惩罚（秒等价）
  private static readonly HIGHWAY_PENALTY = 1800;  // 高速路段惩罚（秒等价）

  constructor(graph: PathPlanningGraph, strategy: RouteStrategy = RouteStrategy.FASTEST) {
    this.graph = graph;
    this.strategy = strategy;
  }

  /** 执行路径规划 */
  plan(originId: number, destinationId: number): PlanResult | null {
    const origin = this.graph.getNode(originId);
    const dest = this.graph.getNode(destinationId);
    if (!origin || !dest) return null;

    // 初始化
    const openSet = new MinHeap();
    const gScore = new Map<number, number>();       // 最优g值
    const cameFrom = new Map<number, { parent: number; edge: GraphEdge }>();  // 路径回溯

    gScore.set(originId, 0);
    openSet.push({
      nodeId: originId,
      gCost: 0,
      fCost: this.heuristic(origin, dest),
      parent: -1,
      edgeFrom: -1
    });

    const closedSet = new Set<number>();

    while (openSet.size > 0) {
      const current = openSet.pop()!;
      const currentId = current.nodeId;

      // 到达终点
      if (currentId === destinationId) {
        return this.reconstructPath(cameFrom, currentId);
      }

      // 已访问过
      if (closedSet.has(currentId)) continue;
      closedSet.add(currentId);

      // 扩展邻居
      const edges = this.graph.getEdges(currentId);
      for (const edge of edges) {
        const neighborId = edge.toId;
        if (closedSet.has(neighborId)) continue;

        // 计算边权重（根据策略）
        const edgeCost = this.computeEdgeCost(edge);
        const tentativeG = current.gCost + edgeCost;

        const prevG = gScore.get(neighborId) ?? Infinity;
        if (tentativeG < prevG) {
          gScore.set(neighborId, tentativeG);
          const neighborNode = this.graph.getNode(neighborId);
          const hCost = neighborNode ? this.heuristic(neighborNode, dest) : 0;

          cameFrom.set(neighborId, { parent: currentId, edge });
          openSet.push({
            nodeId: neighborId,
            gCost: tentativeG,
            fCost: tentativeG + hCost,
            parent: currentId,
            edgeFrom: currentId
          });
        }
      }
    }

    // 无可达路径
    return null;
  }

  /** 计算边代价（根据策略） */
  private computeEdgeCost(edge: GraphEdge): number {
    const travelTime = (edge.length / (edge.speed * 1000 / 3600)) + edge.trafficDelay; // 秒

    switch (this.strategy) {
      case RouteStrategy.FASTEST:
        return travelTime;

      case RouteStrategy.SHORTEST:
        return edge.length;

      case RouteStrategy.NO_TOLL:
        return travelTime + (edge.isToll ? AStarPlanner.TOLL_PENALTY : 0);

      case RouteStrategy.NO_HIGHWAY:
        return travelTime + (edge.isHighway ? AStarPlanner.HIGHWAY_PENALTY : 0);

      case RouteStrategy.GREEN:
        return travelTime * edge.emissionFactor;

      default:
        return travelTime;
    }
  }

  /** 启发式函数（欧几里得距离 → 时间估计） */
  private heuristic(from: GraphNode, to: GraphNode): number {
    const dx = (to.longitude - from.longitude) * 111000; // 粗略转米
    const dy = (to.latitude - from.latitude) * 111000;
    const dist = Math.sqrt(dx * dx + dy * dy);

    // 根据策略选择启发函数
    switch (this.strategy) {
      case RouteStrategy.SHORTEST:
        return dist; // 距离启发
      case RouteStrategy.GREEN:
        return dist * 0.2 / 30; // 假设30km/h, 排放系数0.2
      default:
        return dist / (80 * 1000 / 3600); // 假设80km/h, 时间启发
    }
  }

  /** 路径回溯 */
  private reconstructPath(
    cameFrom: Map<number, { parent: number; edge: GraphEdge }>,
    endId: number
  ): PlanResult {
    const path: number[] = [endId];
    const edges: GraphEdge[] = [];
    let current = endId;

    while (cameFrom.has(current)) {
      const { parent, edge } = cameFrom.get(current)!;
      path.unshift(parent);
      edges.unshift(edge);
      current = parent;
    }

    // 统计总距离和总时间
    let totalDistance = 0;
    let totalDuration = 0;
    for (const edge of edges) {
      totalDistance += edge.length;
      totalDuration += (edge.length / (edge.speed * 1000 / 3600)) + edge.trafficDelay;
    }

    return {
      path,
      totalCost: totalDuration,
      totalDistance,
      totalDuration,
      edges
    };
  }
}

3.3 多策略规划服务

// MultiStrategyPlanner.ets - 多策略规划服务

import { PathPlanningGraph, RouteStrategy } from './PathPlanningGraph';
import { AStarPlanner, PlanResult } from './AStarPlanner';

/** 路线候选 */
export interface RouteCandidate {
  strategy: RouteStrategy;
  result: PlanResult;
  label: string;                // 显示标签
  isSelected: boolean;          // 是否为推荐路线
  tagColor: string;             // 标签颜色
}

/** 多策略规划配置 */
interface MultiStrategyConfig {
  strategies: RouteStrategy[];  // 需要计算的策略列表
  maxCandidates: number;        // 最大候选路线数
  similarityThreshold: number;  // 路线相似度阈值（0-1），超过则视为重复
}

@ObservedV2
export class MultiStrategyPlanner {
  private graph: PathPlanningGraph;
  private config: MultiStrategyConfig;

  @Trace candidates: RouteCandidate[] = [];
  @Trace isPlanning: boolean = false;
  @Trace selectedStrategy: RouteStrategy = RouteStrategy.FASTEST;

  // 策略标签配置
  private static readonly STRATEGY_LABELS: Record<RouteStrategy, string> = {
    [RouteStrategy.FASTEST]: '最快到达',
    [RouteStrategy.SHORTEST]: '距离最短',
    [RouteStrategy.NO_TOLL]: '避免收费',
    [RouteStrategy.NO_HIGHWAY]: '避免高速',
    [RouteStrategy.GREEN]: '绿色出行'
  };

  private static readonly STRATEGY_COLORS: Record<RouteStrategy, string> = {
    [RouteStrategy.FASTEST]: '#0f3460',
    [RouteStrategy.SHORTEST]: '#533483',
    [RouteStrategy.NO_TOLL]: '#e94560',
    [RouteStrategy.NO_HIGHWAY]: '#16213e',
    [RouteStrategy.GREEN]: '#2d6a4f'
  };

  constructor(graph: PathPlanningGraph) {
    this.graph = graph;
    this.config = {
      strategies: [
        RouteStrategy.FASTEST,
        RouteStrategy.SHORTEST,
        RouteStrategy.NO_TOLL,
        RouteStrategy.GREEN
      ],
      maxCandidates: 3,
      similarityThreshold: 0.7
    };
  }

  /** 执行多策略规划 */
  async planAllStrategies(
    originId: number,
    destinationId: number
  ): Promise<RouteCandidate[]> {
    this.isPlanning = true;
    this.candidates = [];

    const results: RouteCandidate[] = [];

    // 并行计算各策略路线
    const planPromises = this.config.strategies.map(async (strategy) => {
      const planner = new AStarPlanner(this.graph, strategy);
      const result = planner.plan(originId, destinationId);
      if (result) {
        return {
          strategy,
          result,
          label: MultiStrategyPlanner.STRATEGY_LABELS[strategy],
          isSelected: strategy === RouteStrategy.FASTEST,
          tagColor: MultiStrategyPlanner.STRATEGY_COLORS[strategy]
        } as RouteCandidate;
      }
      return null;
    });

    const planResults = await Promise.all(planPromises);

    // 过滤空结果
    const validResults = planResults.filter((r): r is RouteCandidate => r !== null);

    // 去重：相似度过高的路线只保留最优的
    const uniqueResults = this.deduplicateRoutes(validResults);

    // 排序：按总代价升序
    uniqueResults.sort((a, b) => a.result.totalCost - b.result.totalCost);

    // 标记推荐路线（第一条为推荐）
    if (uniqueResults.length > 0) {
      uniqueResults[0].isSelected = true;
      this.selectedStrategy = uniqueResults[0].strategy;
    }

    // 截取最大候选数
    this.candidates = uniqueResults.slice(0, this.config.maxCandidates);
    this.isPlanning = false;

    return this.candidates;
  }

  /** 路线去重（基于Jaccard相似度） */
  private deduplicateRoutes(routes: RouteCandidate[]): RouteCandidate[] {
    const unique: RouteCandidate[] = [];

    for (const route of routes) {
      const isDuplicate = unique.some((existing) => {
        const similarity = this.computeJaccardSimilarity(
          route.result.path,
          existing.result.path
        );
        return similarity > this.config.similarityThreshold;
      });

      if (!isDuplicate) {
        unique.push(route);
      }
    }

    return unique;
  }

  /** 计算Jaccard相似度 */
  private computeJaccardSimilarity(path1: number[], path2: number[]): number {
    const set1 = new Set(path1);
    const set2 = new Set(path2);
    const intersection = new Set([...set1].filter(x => set2.has(x)));
    const union = new Set([...set1, ...set2]);
    return union.size > 0 ? intersection.size / union.size : 0;
  }

  /** 选择策略 */
  selectStrategy(strategy: RouteStrategy): void {
    this.selectedStrategy = strategy;
    this.candidates.forEach(c => {
      c.isSelected = c.strategy === strategy;
    });
  }

  /** 获取当前选中路线 */
  get selectedRoute(): RouteCandidate | undefined {
    return this.candidates.find(c => c.isSelected);
  }
}

3.4 规划结果展示组件

// RouteSelectionView.ets - 路线选择UI组件

import { MultiStrategyPlanner, RouteCandidate } from './MultiStrategyPlanner';
import { RouteStrategy } from './PathPlanningGraph';

@Builder
function RouteCard(candidate: RouteCandidate, onSelect: () => void) {
  Row() {
    // 左侧标签
    Column() {
      Text(candidate.label)
        .fontSize(12)
        .fontColor('#ffffff')
        .padding({ left: 8, right: 8, top: 4, bottom: 4 })
        .borderRadius(8)
        .backgroundColor(candidate.tagColor)
    }
    .margin({ right: 12 })

    // 中间信息
    Column() {
      Row() {
        Text(`${(candidate.result.totalDuration / 60).toFixed(0)}分钟`)
          .fontSize(20)
          .fontWeight(FontWeight.Bold)
          .fontColor(candidate.isSelected ? '#e94560' : '#ffffff')
        Text(`${(candidate.result.totalDistance / 1000).toFixed(1)}公里`)
          .fontSize(14)
          .fontColor('rgba(255,255,255,0.6)')
          .margin({ left: 8 })
      }

      // 路线简述
      Text(`${candidate.result.edges.length}个路段`)
        .fontSize(12)
        .fontColor('rgba(255,255,255,0.4)')
        .margin({ top: 4 })
    }
    .layoutWeight(1)
    .alignItems(HorizontalAlign.Start)

    // 右侧选中指示
    if (candidate.isSelected) {
      Text('推荐')
        .fontSize(12)
        .fontColor('#e94560')
        .fontWeight(FontWeight.Bold)
    }
  }
  .width('100%')
  .padding(16)
  .borderRadius(12)
  .backgroundColor(candidate.isSelected ? 'rgba(233,69,96,0.1)' : 'rgba(26,26,46,0.8)')
  .border({
    width: candidate.isSelected ? 2 : 1,
    color: candidate.isSelected ? '#e94560' : 'rgba(255,255,255,0.1)',
    style: BorderStyle.Solid,
    radius: 12
  })
  .onClick(() => onSelect())
}

@Entry
@Component
struct RouteSelectionPage {
  @Local planner: MultiStrategyPlanner = new MultiStrategyPlanner(new PathPlanningGraph());
  @Local showPlanning: boolean = false;

  build() {
    Column() {
      // 标题栏
      Row() {
        Text('路线选择')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor('#ffffff')
      }
      .width('100%')
      .padding({ left: 20, right: 20, top: 16, bottom: 16 })

      // 路线列表
      if (this.planner.isPlanning) {
        Column() {
          LoadingProgress()
            .width(48)
            .height(48)
            .color('#e94560')
          Text('正在规划路线...')
            .fontSize(14)
            .fontColor('rgba(255,255,255,0.6)')
            .margin({ top: 12 })
        }
        .width('100%')
        .height(200)
        .justifyContent(FlexAlign.Center)
      } else {
        List() {
          ForEach(this.planner.candidates, (candidate: RouteCandidate) => {
            ListItem() {
              RouteCard(candidate, () => {
                this.planner.selectStrategy(candidate.strategy);
              })
            }
            .margin({ bottom: 8 })
          })
        }
        .width('100%')
        .padding({ left: 16, right: 16 })
        .layoutWeight(1)
      }

      // 底部按钮
      Button('开始导航')
        .width('90%')
        .height(48)
        .backgroundColor('#e94560')
        .fontColor('#ffffff')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .borderRadius(24)
        .margin({ bottom: 32 })
        .enabled(this.planner.candidates.length > 0)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0a0a1a')
  }
}

四、踩坑与注意事项

4.1 A*启发函数的陷阱

4.2 大规模路网性能优化

在设备端处理百万级节点路网时，需注意：

1. 内存管理：路网数据可能超过100MB，使用ArrayList替代Map减少内存开销
2. 增量加载：按区域分片加载路网，只加载起点终点周边的详细路网
3. WebWorker：规划计算放在Worker线程，避免阻塞UI
4. 缓存策略：相同起终点的规划结果缓存，避免重复计算

// 使用Worker进行后台规划
// PathPlanningWorker.ets
import { AStarPlanner } from './AStarPlanner';
import { PathPlanningGraph, RouteStrategy } from './PathPlanningGraph';

const worker = new worker.ThreadWorker('PathPlanningWorker.ets');

worker.onmessage = (event) => {
  const { originId, destId, strategy, graphData } = event.data;
  const graph = deserializeGraph(graphData);
  const planner = new AStarPlanner(graph, strategy as RouteStrategy);
  const result = planner.plan(originId, destId);
  worker.postMessage({ result });
};

4.3 路线相似度去重

多策略规划可能产生高度相似的路线（如"最快"和"最短"在畅通路段几乎重合），需要去重：

• Jaccard相似度：基于节点集合的交集/并集比，简单但忽略路径顺序
• EDR（Edit Distance on Real Sequence）：考虑路径顺序的编辑距离，更精确但计算量大
• 实践建议：先用Jaccard快速过滤，相似度在0.5-0.7之间的再用EDR精确判定

4.4 收费/高速路段的惩罚值调优

惩罚值设置直接影响路线质量：

• 惩罚太小：避免收费策略仍可能走收费路段（因为绕路代价更大）
• 惩罚太大：导致极端绕路，用户体验差
• 推荐值：收费惩罚 ≈ 1小时等价时间，高速惩罚 ≈ 30分钟等价时间
• 动态调整：根据绕行距离动态缩放惩罚值，绕行越远惩罚越小

五、HarmonyOS 6适配

5.1 端云协同规划

HarmonyOS 6强化了端云协同能力，路径规划可采用"端侧快速规划 + 云端精细规划"的混合模式：

// HybridPlanner.ets - 端云协同规划
import { http } from '@kit.NetworkKit';
import { AStarPlanner } from './AStarPlanner';

export class HybridPlanner {
  private localGraph: PathPlanningGraph;
  private cloudEndpoint: string = 'https://nav-api.example.com/route';

  constructor(localGraph: PathPlanningGraph) {
    this.localGraph = localGraph;
  }

  async plan(origin: number, destination: number, strategy: RouteStrategy): Promise<PlanResult> {
    // 1. 端侧快速规划（粗略路网）
    const localPlanner = new AStarPlanner(this.localGraph, strategy);
    const localResult = localPlanner.plan(origin, destination);

    // 2. 云端精细规划（完整路网+实时路况）
    try {
      const cloudResult = await this.requestCloudPlanning(origin, destination, strategy);
      if (cloudResult && cloudResult.totalCost < (localResult?.totalCost ?? Infinity)) {
        return cloudResult;
      }
    } catch (error) {
      console.warn('[HybridPlanner] 云端规划失败，使用端侧结果');
    }

    return localResult!;
  }

  private async requestCloudPlanning(
    origin: number, dest: number, strategy: RouteStrategy
  ): Promise<PlanResult | null> {
    const httpRequest = http.createHttp();
    try {
      const response = await httpRequest.request(this.cloudEndpoint, {
        method: http.RequestMethod.POST,
        header: { 'Content-Type': 'application/json' },
        extraData: JSON.stringify({ origin, destination: dest, strategy })
      });

      if (response.responseCode === 200) {
        return JSON.parse(response.result as string) as PlanResult;
      }
    } finally {
      httpRequest.destroy();
    }
    return null;
  }
}

5.2 原子化服务卡片

HarmonyOS 6支持将路径规划结果以原子化服务卡片形式展示：

// NavWidget.ets - 导航服务卡片
@Entry
@Component
struct NavWidget {
  @Local eta: string = '约25分钟';
  @Local distance: string = '12.3公里';
  @Local nextInstruction: string = '前方500米右转';

  build() {
    Column() {
      Row() {
        Text('🚗 导航中')
          .fontSize(14)
          .fontColor('#e94560')
          .fontWeight(FontWeight.Bold)
        Text(this.eta)
          .fontSize(12)
          .fontColor('rgba(255,255,255,0.6)')
          .margin({ left: 8 })
      }
      .width('100%')
      .justifyContent(FlexAlign.SpaceBetween)

      Text(this.nextInstruction)
        .fontSize(16)
        .fontColor('#ffffff')
        .margin({ top: 8 })

      Progress({ value: 65, total: 100 })
        .color('#e94560')
        .backgroundColor('rgba(255,255,255,0.1)')
        .margin({ top: 8 })
    }
    .padding(16)
    .borderRadius(16)
    .backgroundColor('rgba(26,26,46,0.95)')
  }
}

六、总结

本文系统讲解了HarmonyOS导航系统中路径规划算法与多策略选择的完整方案：

路径规划是导航体验的基石。在实际开发中，算法选型需根据路网规模和设备算力灵活调整——小规模路网直接A*，大规模路网引入CH预处理。多策略规划的核心在于权重函数的设计与惩罚值的调优，需要在"策略偏好"和"路线合理性"之间取得平衡。HarmonyOS 6的端云协同和原子化服务能力，为路径规划提供了更丰富的分发渠道和更灵活的计算模式。