一、引言

二、技术背景

1. 鸿蒙公共交通查询架构

• ​​实时位置与到站查询​​：通过公交/地铁车辆的GPS定位数据（或车站的物联网传感器），实时获取车辆当前位置（如“距离本站2站”），并结合线路站点信息计算到站时间；
• ​​到站时间预测​​：基于历史运行数据（如不同时间段的平均车速）、实时路况（如交通拥堵指数）和车辆当前位置，通过算法预测下一班车的到站时间（精确到分钟）；
• ​​多线路协同​​：支持同时查询多条公交/地铁线路（如“回家路线：地铁2号线→公交101路”），并显示各线路的实时状态与到站时间；
• ​​分布式数据同步​​：用户的常用路线、收藏站点等信息通过鸿蒙分布式数据库（如@ohos.data.preferences）同步至手机/车机，实现跨设备无缝查询；
• ​​低延迟更新​​：车辆位置与到站时间数据通过鸿蒙软总线（Distributed SoftBus）或云端API实时推送（更新频率≤30秒），确保信息时效性。

2. 核心技术点

• ​​GPS/物联网定位​​：公交/地铁车辆安装GPS模块（或车站部署物联网传感器），实时上报位置坐标（经纬度）至云端服务器；
• ​​路线与站点映射​​：通过鸿蒙本地数据库存储公交/地铁线路的站点顺序、站点经纬度等信息，用于计算车辆与当前站点的距离；
• ​​预测算法​​：结合历史平均车速（如工作日早高峰地铁平均时速30km/h）、实时路况（如通过交通API获取拥堵系数）和车辆当前位置，动态调整到站时间预测（如拥堵时延长预测时间）；
• ​​分布式用户偏好​​：用户的常用路线（如“公司→家”）、收藏站点（如“学校门口站”）通过鸿蒙分布式数据库同步，多设备登录时自动加载。

三、应用使用场景

1. 日常通勤查询

• ​​场景描述​​：上班族在地铁站等待地铁2号线时，通过手机APP查询“下一班地铁2号线到站时间”，系统显示“预计2分钟后到达（当前距离本站1站，车速正常）”；
• ​​需求​​：实时到站时间（精确到分钟）、车辆位置（距离本站几站）、预测依据（如“车速正常”）。

2. 换乘路线规划

• ​​场景描述​​：乘客从家到公司需换乘公交101路和地铁3号线，通过APP输入起点和终点，系统推荐“最优路线：公交101路（预计5分钟后到站）→地铁3号线（预计10分钟后到站）”，并实时更新各线路状态；
• ​​需求​​：多线路协同查询、换乘时间衔接（如公交与地铁的到站间隔）、动态调整（如某线路延误时推荐替代方案）。

3. 特殊场景应急

• ​​场景描述​​：雨天导致公交线路拥堵，乘客在车站等待时，系统通过实时路况数据预测“原预计3分钟的公交102路将延迟至5分钟到达”，并提示“建议改乘相邻的公交103路（预计2分钟后到站）”；
• ​​需求​​：实时路况融合预测、应急提醒（如延误通知）、替代方案推荐。

4. 公共交通管理

• ​​场景描述​​：公交公司通过后台系统监控车辆实时位置与到站时间，当某线路多辆车集中延误时，自动调整发车间隔（如增加后续车辆班次），并通过鸿蒙推送通知乘客；
• ​​需求​​：车辆状态集中管理、预测数据反向同步（车站大屏显示预测到站时间）、乘客通知（APP/短信）。

四、不同场景下详细代码实现

场景 1：手机APP查询公交实时到站时间（基础版）

1.1 项目结构

PublicTransportApp/
├── entry/src/main/ets/pages/
│   ├── Index.ets          // 主页面（查询输入与结果展示）
│   ├── TransportManager.ets // 公交/地铁数据查询逻辑（实时位置+预测）
│   └── LocationManager.ets  // 位置服务管理（获取当前站点）
├── entry/src/main/module.json5  // 模块配置（声明位置与网络权限）
└── build-profile.json5

1.2 权限配置（module.json5）

{
  "module": {
    "name": "entry",
    "type": "entry",
    "description": "$string:module_desc",
    "mainElement": "EntryAbility",
    "deviceTypes": [
      "phone" // 手机端查询
    ],
    "deliveryWithInstall": true,
    "installationFree": false,
    "requestPermissions": [
      {
        "name": "ohos.permission.LOCATION", // 位置权限（获取当前站点）
        "reason": "$string:location_permission_reason"
      },
      {
        "name": "ohos.permission.NETWORK", // 网络权限（获取实时数据）
        "reason": "$string:network_permission_reason"
      }
    ],
    "abilities": [
      {
        "name": "EntryAbility",
        "srcEntry": "./ets/entryability/EntryAbility.ts",
        "description": "$string:EntryAbility_desc",
        "icon": "$media:icon",
        "label": "$string:EntryAbility_label",
        "startWindowIcon": "$media:icon",
        "startWindowBackground": "$color:start_window_background",
        "exported": true,
        "skills": [
          {
            "entities": [
              "entity.system.home"
            ],
            "actions": [
              "action.system.home"
            ]
          }
        ]
      }
    ]
  }
}

1.3 位置服务管理（LocationManager.ets）

// entry/src/main/ets/pages/LocationManager.ets
import location from '@ohos.location'; // 鸿蒙位置服务模块

export class LocationManager {
  // 获取用户当前位置（经纬度）
  async getCurrentLocation(): Promise<{ latitude: number; longitude: number }> {
    try {
      const request = new location.LocationRequest();
      request.priority = location.LocationRequestPriority.PRIORITY_HIGH_ACCURACY;
      request.interval = 1000;

      return new Promise((resolve, reject) => {
        location.getLocation(request, (error, position) => {
          if (error) {
            reject(error);
          } else {
            resolve({
              latitude: position.latitude,
              longitude: position.longitude
            });
          }
        });
      });
    } catch (error) {
      console.error('获取位置失败:', error);
      throw error;
    }
  }

  // 根据经纬度匹配最近的公交站点（简化：实际需调用本地站点数据库）
  async findNearestStop(latitude: number, longitude: number, lineId: string): Promise<string> {
    // 模拟：假设已知“中山公园站”的经纬度（实际应从本地数据库查询线路站点）
    const stops = {
      '公交101路': [
        { name: '中山公园站', latitude: 31.2304, longitude: 121.4737 },
        { name: '人民广场站', latitude: 31.2350, longitude: 121.4780 },
        { name: '火车站站', latitude: 31.2400, longitude: 121.4820 }
      ]
    };

    const lineStops = stops[lineId];
    if (!lineStops) return '未知站点';

    let nearestStop = lineStops[0];
    let minDistance = this.calculateDistance(latitude, longitude, nearestStop.latitude, nearestStop.longitude);

    for (const stop of lineStops) {
      const distance = this.calculateDistance(latitude, longitude, stop.latitude, stop.longitude);
      if (distance < minDistance) {
        minDistance = distance;
        nearestStop = stop;
      }
    }

    return nearestStop.name;
  }

  // 计算两点间距离（Haversine公式简化版，单位：米）
  private calculateDistance(lat1: number, lon1: number, lat2: number, lon2: number): number {
    const R = 6371e3; // 地球半径（米）
    const φ1 = lat1 * Math.PI / 180;
    const φ2 = lat2 * Math.PI / 180;
    const Δφ = (lat2 - lat1) * Math.PI / 180;
    const Δλ = (lon2 - lon1) * Math.PI / 180;

    const a = Math.sin(Δφ/2) * Math.sin(Δφ/2) +
              Math.cos(φ1) * Math.cos(φ2) *
              Math.sin(Δλ/2) * Math.sin(Δλ/2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));

    return R * c;
  }
}

1.4 公交数据查询逻辑（TransportManager.ets）

// entry/src/main/ets/pages/TransportManager.ets
import { LocationManager } from './LocationManager.ets';

// 公交到站状态枚举
export enum ArrivalStatus {
  ARRIVING = 'arriving', // 即将到站
  COMING_SOON = 'coming_soon', // 几分钟后到站
  DELAYED = 'delayed', // 延误
  UNKNOWN = 'unknown' // 未知
}

// 公交到站信息接口
export interface BusArrivalInfo {
  lineId: string; // 线路号（如“公交101路”）
  stopName: string; // 当前站点名称
  nextBusTime: number; // 下一班车到站时间（分钟）
  status: ArrivalStatus; // 到站状态
  distance: number; // 车辆距离本站的站点数
}

export class TransportManager {
  private locationManager: LocationManager = new LocationManager();
  private mockRealTimeData: Map<string, BusArrivalInfo[]> = new Map(); // 模拟实时数据（实际应调用云端API）

  constructor() {
    // 初始化模拟数据（实际需替换为真实API调用）
    this.mockRealTimeData.set('公交101路', [
      { lineId: '公交101路', stopName: '中山公园站', nextBusTime: 3, status: ArrivalStatus.ARRIVING, distance: 2 },
      { lineId: '公交101路', stopName: '人民广场站', nextBusTime: 8, status: ArrivalStatus.COMING_SOON, distance: 4 }
    ]);
  }

  // 查询指定线路和站点的到站信息
  async queryBusArrival(lineId: string, stopName: string): Promise<BusArrivalInfo | null> {
    try {
      // 1. 获取当前位置（可选，用于自动匹配站点）
      // const location = await this.locationManager.getCurrentLocation();
      // const nearestStop = await this.locationManager.findNearestStop(location.latitude, location.longitude, lineId);

      // 2. 从模拟数据中获取该线路和站点的到站信息（实际应调用云端API）
      const lineData = this.mockRealTimeData.get(lineId);
      if (!lineData) return null;

      const targetInfo = lineData.find(info => info.stopName === stopName);
      if (!targetInfo) return null;

      // 3. 模拟预测逻辑（实际结合历史数据与实时路况）
      const predictedTime = this.predictArrivalTime(targetInfo);
      return {
        ...targetInfo,
        nextBusTime: predictedTime,
        status: this.getStatus(predictedTime)
      };
    } catch (error) {
      console.error('查询公交到站信息失败:', error);
      return null;
    }
  }

  // 预测到站时间（简化：实际结合历史平均车速、实时路况）
  private predictArrivalTime(info: BusArrivalInfo): number {
    // 基础预测：根据距离（站点数）估算（假设每站间隔2分钟，拥堵时+1分钟）
    let baseTime = info.distance * 2;
    if (info.status === ArrivalStatus.DELAYED) {
      baseTime += 3; // 延误时额外+3分钟
    }
    return Math.max(1, baseTime); // 至少1分钟
  }

  // 获取到站状态
  private getStatus(predictedTime: number): ArrivalStatus {
    if (predictedTime <= 1) return ArrivalStatus.ARRIVING;
    if (predictedTime <= 5) return ArrivalStatus.COMING_SOON;
    return ArrivalStatus.COMING_SOON; // 实际可扩展更多状态
  }

  // 模拟实时数据更新（实际通过定时器调用云端API）
  async updateRealTimeData() {
    // 示例：每隔30秒更新一次数据（模拟路况变化）
    setInterval(() => {
      const lineData = this.mockRealTimeData.get('公交101路');
      if (lineData) {
        lineData.forEach(info => {
          // 随机调整到站时间（模拟实时变化）
          info.nextBusTime = Math.max(1, info.nextBusTime + Math.floor(Math.random() * 3) - 1);
        });
      }
    }, 30000);
  }
}

1.5 主页面（Index.ets）

// entry/src/main/ets/pages/Index.ets
import { TransportManager } from './TransportManager.ets';

@Entry
@Component
struct Index {
  @State private transportManager: TransportManager = new TransportManager();
  @State private busInfo: any = null; // 公交到站信息
  @State private inputLine: string = '公交101路';
  @State private inputStop: string = '中山公园站';

  aboutToAppear() {
    // 初始化实时数据更新
    this.transportManager.updateRealTimeData();
    // 自动查询默认线路
    this.queryBusArrival();
  }

  // 查询公交到站信息
  private async queryBusArrival() {
    const info = await this.transportManager.queryBusArrival(this.inputLine, this.inputStop);
    this.busInfo = info;
  }

  build() {
    Column() {
      Text('公共交通查询 - 公交到站时间预测')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ bottom: 30 });

      // 输入框（简化：实际可优化为下拉选择）
      TextInput({ placeholder: '输入公交线路号（如公交101路）' })
        .value(this.inputLine)
        .onChange((value: string) => {
          this.inputLine = value;
        })
        .margin({ bottom: 10 });

      TextInput({ placeholder: '输入当前站点名称（如中山公园站）' })
        .value(this.inputStop)
        .onChange((value: string) => {
          this.inputStop = value;
        })
        .margin({ bottom: 20 });

      // 查询按钮
      Button('查询到站时间')
        .onClick(() => this.queryBusArrival())
        .margin({ bottom: 20 });

      // 结果展示
      if (!this.busInfo) {
        Text('🔍 未查询到结果，请检查线路和站点名称')
          .fontSize(16)
          .fontColor('#666');
      } else {
        Column() {
          Text(`🚌 线路：${this.busInfo.lineId}`)
            .fontSize(18)
            .fontWeight(FontWeight.Medium);
          Text(`📍 当前站点：${this.busInfo.stopName}`)
            .fontSize(16)
            .margin({ bottom: 10 });
          Text(`⏱️ 预计到站时间：${this.busInfo.nextBusTime}分钟后`)
            .fontSize(16)
            .fontColor(this.busInfo.nextBusTime <= 1 ? '#f44336' : this.busInfo.nextBusTime <= 5 ? '#ff9800' : '#4caf50');
          Text(`📊 状态：${this.getStatusText(this.busInfo.status)}`)
            .fontSize(14)
            .fontColor('#666');
          Text(`🚏 车辆距离：${this.busInfo.distance}站`)
            .fontSize(14)
            .fontColor('#666');
        }
        .width('100%')
        .padding(15)
        .border({ width: 1, color: '#eee', radius: 8 });
      }
    }
    .width('100%')
    .height('100%')
    .padding(20)
    .justifyContent(FlexAlign.Start);
  }

  // 获取状态文本
  private getStatusText(status: string): string {
    switch (status) {
      case 'arriving': return '即将到站';
      case 'coming_soon': return '几分钟内到站';
      case 'delayed': return '可能延误';
      default: return '未知';
    }
  }
}

• 用户输入公交线路号（如“公交101路”）和当前站点（如“中山公园站”），点击“查询到站时间”；
• 系统显示“预计3分钟后到达”“车辆距离本站2站”“状态：即将到站”（根据模拟数据动态更新）；
• 若模拟数据中车辆延误（如nextBusTime调整为5分钟），页面实时刷新显示“预计5分钟后到达”“状态：几分钟内到站”。

场景 2：多线路协同查询（进阶版）

2.1 多线路查询逻辑（扩展 TransportManager.ets）

// 在 TransportManager.ets 中添加多线路查询方法
export class TransportManager {
  // ... 原有代码 ...

  // 查询换乘路线的多线路到站信息
  async queryTransferRoutes(routes: { lineId: string; stopName: string }[]): Promise<any[]> {
    const results = [];
    for (const route of routes) {
      const info = await this.queryBusArrival(route.lineId, route.stopName);
      if (info) {
        results.push({
          ...route,
          arrivalInfo: info
        });
      }
    }
    return results;
  }
}

2.2 主页面扩展（Index.ets）

// 在 Index.ets 中添加换乘查询按钮和逻辑
@State private transferRoutes: any[] = [];

// 查询换乘路线（示例：公交101路→地铁2号线）
private async queryTransfer() {
  const routes = [
    { lineId: '公交101路', stopName: '中山公园站' },
    { lineId: '地铁2号线', stopName: '人民广场站' }
  ];
  this.transferRoutes = await this.transportManager.queryTransferRoutes(routes);
}

build() {
  Column() {
    // ... 原有内容 ...

    // 换乘查询按钮
    Button('查询换乘路线（公交101路→地铁2号线）')
      .onClick(() => this.queryTransfer())
      .margin({ top: 20 });

    // 换乘结果展示
    if (this.transferRoutes.length > 0) {
      List() {
        ForEach(this.transferRoutes, (route: any) => {
          ListItem() {
            Column() {
              Text(`🚍 ${route.lineId} → ${route.stopName}`)
                .fontSize(16)
                .fontWeight(FontWeight.Medium);
              Text(`⏱️ 预计：${route.arrivalInfo.nextBusTime}分钟后`)
                .fontSize(14)
                .fontColor(route.arrivalInfo.nextBusTime <= 3 ? '#f44336' : '#4caf50');
            }
            .width('100%')
            .padding(10)
            .border({ width: 1, color: '#eee', radius: 5 });
          }
        })
      }
      .width('100%')
      .layoutWeight(1);
    }
  }
}

• 用户点击“查询换乘路线”后，系统同时查询公交101路（中山公园站）和地铁2号线（人民广场站）的到站时间；
• 页面显示“公交101路（预计3分钟后到站）→地铁2号线（预计8分钟后到站）”，帮助用户规划最佳换乘时机。

五、原理解释

1. 鸿蒙公共交通查询的核心流程

1. ​​数据获取​​：
   • 公交/地铁车辆的实时位置通过GPS模块上传至云端服务器（或车站物联网传感器），存储为“线路-站点-车辆位置”数据；
   • 用户通过手机APP输入线路号和当前站点（或自动通过位置服务匹配最近站点）。
2. ​​实时到站计算​​：
   • 系统根据车辆的当前位置（如“距离本站2站”）和线路站点顺序，计算下一班车到达当前站点所需的站点数；
   • 结合历史平均车速（如每站间隔2分钟）和实时路况（如拥堵时延长1-2分钟），预测到站时间（精确到分钟）。
3. ​​状态同步与提醒​​：
   • 到站时间和车辆位置通过鸿蒙软总线或云端API实时推送至用户APP（更新频率≤30秒）；
   • 当车辆即将到站（如1分钟内）时，APP通过弹窗或震动提醒用户准备上车。
4. ​​多线路协同​​：
   • 用户输入换乘路线（如“公交→地铁”），系统并行查询各线路的到站时间，综合计算最佳换乘时机（如公交到站后等待地铁的时间≤5分钟）。

2. 关键技术点

• ​​实时定位与映射​​：公交/地铁车辆的GPS数据通过分布式数据库同步至查询系统，结合线路站点经纬度信息，精准计算车辆与站点的距离；
• ​​智能预测算法​​：融合历史数据（如工作日早高峰平均车速）、实时路况（如交通API的拥堵指数）和车辆当前位置，动态调整预测时间；
• ​​低延迟更新​​：通过鸿蒙软总线或云端推送机制，确保到站时间信息的实时性（误差<1分钟）；
• ​​用户友好展示​​：通过颜色区分到站状态（如红色表示即将到站，绿色表示较宽松），提升信息可读性。

六、核心特性

七、原理流程图及原理解释

原理流程图（鸿蒙公共交通查询）

+-----------------------+       +-----------------------+       +-----------------------+
|     用户手机（查询端） |       |     公交/地铁系统    |       |     云端服务器       |
|  (Phone - APP)      |       |  (车辆GPS/物联网)   |       |  (数据存储与预测)   |
+-----------------------+       +-----------------------+       +-----------------------+
          |                             |                             |
          |  1. 输入线路/站点     |                             |  
          |-------------------------->|                             |
          |  (如公交101路，中山公园站) |                             |
          |  2. 请求实时到站信息  |                             |  
          |<--------------------------|                             |
          |  (通过云端API查询)    |                             |  
          |  3. 获取车辆位置      |                             |  4. 实时上报GPS数据 |
          |<--------------------------|  (车辆GPS模块上传)  |  
          |  (距离本站2站)        |                             |  
          |  5. 预测到站时间      |                             |  6. 结合历史与路况  |
          |<--------------------------|  (云端预测算法)     |  
          |  (预计3分钟后到达)    |                             |  
          |  7. 显示结果          |                             |  
          |  (弹窗/列表展示)      |                             |

原理解释

1. ​​数据采集​​：公交/地铁车辆通过内置GPS模块实时上报位置坐标（经纬度）至云端服务器，车站物联网传感器（可选）辅助监测车辆进站状态；
2. ​​用户查询​​：用户通过手机APP输入公交线路号和当前站点（或自动通过位置服务匹配最近站点），向云端服务器发送实时到