HarmonyOS APP开发：网络定位与基站定位

核心要点：深入理解Wi-Fi指纹定位与基站三角定位原理，掌握HarmonyOS网络定位API，实现GPS不可用场景下的快速位置获取与多源融合定位策略。

项目	说明
核心模块	@ohos.geoLocationManager
定位方式	Wi-Fi指纹定位、基站三角定位

一、背景与动机

1.1 为什么需要网络定位

GPS定位虽然精度高，但存在明显局限：

网络定位的核心价值在于弥补GPS的覆盖盲区，在GPS信号弱或不可用的场景下提供快速、低功耗的位置服务。对于外卖配送、室内导航、商圈分析等应用场景，网络定位是不可或缺的补充能力。

1.2 网络定位技术全景

1.3 三种定位方式对比

二、核心原理

2.1 Wi-Fi指纹定位原理

Wi-Fi指纹定位的核心思想是位置指纹匹配：

1. 离线阶段（指纹采集）：在目标区域各参考点扫描Wi-Fi信号，记录每个AP的BSSID和信号强度，构建指纹数据库
2. 在线阶段（位置查询）：用户设备扫描周围Wi-Fi，将扫描结果与指纹数据库匹配，估算用户位置

指纹向量：F = {(BSSID₁, RSSI₁), (BSSID₂, RSSI₂), ..., (BSSIDₙ, RSSIₙ)}

匹配算法（KNN）：
1. 计算在线指纹与数据库中每个指纹的欧氏距离
2. 选取距离最近的K个参考点
3. 对K个参考点坐标取加权平均，得到估算位置

欧氏距离：d = √[Σ(RSSI_online_i - RSSI_db_i)²]

Wi-Fi定位精度影响因素：

2.2 基站三角定位原理

基站定位利用蜂窝网络的基站信息估算位置：

Cell-ID定位（最简单）：

• 获取当前服务基站的Cell-ID
• 返回基站覆盖区域的中心坐标
• 精度取决于基站覆盖半径（城市100~500m，农村1~5km）

三角测量定位（更精确）：

• 获取3个及以上基站的Cell-ID和信号强度
• 通过信号衰减模型估算到各基站的距离
• 利用三角测量法计算交点坐标

信号衰减模型（COST-231 Hata）：
L = 46.3 + 33.9·log(f) - 13.82·log(hb) - a(hr) + (44.9 - 6.55·log(hb))·log(d) + Cm

其中：
- L：路径损耗（dB）
- f：频率（MHz）
- hb：基站天线高度（m）
- hr：移动台天线高度（m）
- d：距离（km）
- a(hr)：天线高度修正因子
- Cm：地形修正因子

距离估算：d = 10^((RSSI - Pt + L) / (10·n))
- RSSI：接收信号强度
- Pt：发射功率
- n：路径损耗指数（2~4）

2.3 HarmonyOS融合定位策略

HarmonyOS的位置服务框架内置了融合定位引擎，根据定位请求的优先级自动选择最优定位源：

// 融合定位决策流程
enum LocationPriority {
  ACCURACY_PRIORITY = 0x0201,  // 精度优先 → GNSS + Wi-Fi辅助
  LOW_POWER_PRIORITY = 0x0202, // 低功耗优先 → 基站 + Wi-Fi
  FIRST_FIX_PRIORITY = 0x0203  // 快速定位优先 → 网络定位先行 + GNSS补充
}

flowchart LR
    A[定位请求] --> B{优先级判断}
    B -->|精度优先| C[GNSS主导]
    C --> D[Wi-Fi辅助]
    D --> E[高精度结果<br/>3~10m]
    
    B -->|低功耗优先| F[基站主导]
    F --> G[Wi-Fi辅助]
    G --> H[低功耗结果<br/>50~500m]
    
    B -->|快速定位| I[网络定位先行]
    I --> J[GNSS热启动补充]
    J --> K[渐进精化结果<br/>先粗后精]
    
    classDef requestStyle fill:#E17055,stroke:#D63031,color:#FFF,font-weight:bold
    classDef decisionStyle fill:#6C5CE7,stroke:#5B4CDB,color:#FFF,font-weight:bold
    classDef gnssStyle fill:#00B894,stroke:#00A383,color:#FFF,font-weight:bold
    classDef networkStyle fill:#0984E3,stroke:#0770C2,color:#FFF,font-weight:bold
    classDef resultStyle fill:#FDCB6E,stroke:#F0B429,color:#333,font-weight:bold
    
    class A requestStyle
    class B decisionStyle
    class C,D gnssStyle
    class F,G,I,J networkStyle
    class E,H,K resultStyle

三、代码实战

3.1 网络定位请求封装

// NetworkLocationManager.ets
// 功能：封装网络定位请求，支持Wi-Fi定位和基站定位

import { geoLocationManager } from '@kit.LocationKit';
import { wifiManager } from '@kit.WifiKit';
import { BusinessError } from '@kit.BasicServicesKit';

const TAG = '[NetworkLocationManager]';

// 定位模式枚举
export enum NetworkLocationMode {
  WIFI_ONLY = 'wifi_only',       // 仅Wi-Fi定位
  CELL_ONLY = 'cell_only',       // 仅基站定位
  HYBRID = 'hybrid',             // 融合定位
  AUTO_FALLBACK = 'auto_fallback' // 自动降级
}

// 网络定位结果
export interface NetworkLocationResult {
  latitude: number;
  longitude: number;
  accuracy: number;
  source: string;         // 定位源标识
  responseTime: number;   // 响应时间（毫秒）
  timestamp: number;
}

export class NetworkLocationManager {
  private lastResult: NetworkLocationResult | null = null;

  /**
   * 获取网络定位
   * @param mode 定位模式
   * @param timeoutMs 超时时间（毫秒）
   */
  async getNetworkLocation(
    mode: NetworkLocationMode = NetworkLocationMode.AUTO_FALLBACK,
    timeoutMs: number = 15000
  ): Promise<NetworkLocationResult | null> {
    const startTime = Date.now();

    try {
      // 根据模式选择定位优先级
      const priority = this.getPriorityByMode(mode);

      const requestInfo: geoLocationManager.SingleLocationRequest = {
        priority: priority,
        timeoutMs: timeoutMs
      };

      console.info(TAG, `发起网络定位: mode=${mode}, priority=${priority}`);
      const location = await geoLocationManager.getCurrentLocation(requestInfo);

      const result: NetworkLocationResult = {
        latitude: location.latitude,
        longitude: location.longitude,
        accuracy: location.accuracy,
        source: this.identifyLocationSource(location),
        responseTime: Date.now() - startTime,
        timestamp: location.timeStamp
      };

      this.lastResult = result;
      console.info(TAG, `网络定位成功: source=${result.source}, ` +
        `accuracy=${result.accuracy.toFixed(1)}m, time=${result.responseTime}ms`);
      return result;
    } catch (error) {
      const err = error as BusinessError;
      console.error(TAG, `网络定位失败: ${err.code} - ${err.message}`);

      // 自动降级模式：尝试备用定位源
      if (mode === NetworkLocationMode.AUTO_FALLBACK) {
        return await this.fallbackLocation(startTime, timeoutMs);
      }
      return null;
    }
  }

  /**
   * 根据定位模式获取优先级
   */
  private getPriorityByMode(mode: NetworkLocationMode): geoLocationManager.LocationRequestPriority {
    switch (mode) {
      case NetworkLocationMode.WIFI_ONLY:
      case NetworkLocationMode.CELL_ONLY:
        return geoLocationManager.LocationRequestPriority.LOW_POWER_PRIORITY;
      case NetworkLocationMode.HYBRID:
        return geoLocationManager.LocationRequestPriority.FIRST_FIX_PRIORITY;
      case NetworkLocationMode.AUTO_FALLBACK:
        return geoLocationManager.LocationRequestPriority.FIRST_FIX_PRIORITY;
      default:
        return geoLocationManager.LocationRequestPriority.LOW_POWER_PRIORITY;
    }
  }

  /**
   * 识别定位源
   */
  private identifyLocationSource(location: geoLocationManager.Location): string {
    // 根据精度推断定位源
    if (location.accuracy <= 15) return 'GNSS+WiFi';
    if (location.accuracy <= 50) return 'WiFi';
    if (location.accuracy <= 200) return 'WiFi+Cell';
    return 'Cell';
  }

  /**
   * 降级定位策略
   */
  private async fallbackLocation(
    startTime: number,
    timeoutMs: number
  ): Promise<NetworkLocationResult | null> {
    console.info(TAG, '尝试降级定位...');

    // 降级1：尝试低功耗定位
    try {
      const fallbackRequest: geoLocationManager.SingleLocationRequest = {
        priority: geoLocationManager.LocationRequestPriority.LOW_POWER_PRIORITY,
        timeoutMs: Math.min(timeoutMs, 10000)
      };
      const location = await geoLocationManager.getCurrentLocation(fallbackRequest);
      return {
        latitude: location.latitude,
        longitude: location.longitude,
        accuracy: location.accuracy,
        source: 'Fallback-LowPower',
        responseTime: Date.now() - startTime,
        timestamp: location.timeStamp
      };
    } catch (error) {
      console.warn(TAG, '降级定位也失败');
    }

    // 降级2：使用上次缓存的位置
    if (this.lastResult) {
      console.info(TAG, '使用缓存位置');
      return { ...this.lastResult, source: 'Cache' };
    }

    return null;
  }

  /**
   * 获取上次定位结果
   */
  getLastResult(): NetworkLocationResult | null {
    return this.lastResult;
  }
}

3.2 Wi-Fi扫描辅助定位

// WifiScanAssistant.ets
// 功能：Wi-Fi扫描辅助定位，获取周围AP信息用于位置估算

import { wifiManager } from '@kit.WifiKit';
import { BusinessError } from '@kit.BasicServicesKit';

const TAG = '[WifiScanAssistant]';

// Wi-Fi扫描结果
export interface WifiScanResult {
  ssid: string;       // 网络名称
  bssid: string;      // AP MAC地址
  rssi: number;       // 信号强度（dBm）
  band: number;       // 频段
  frequency: number;  // 频率（MHz）
  channelWidth: number; // 信道宽度
}

export class WifiScanAssistant {
  private scanResults: WifiScanResult[] = [];

  /**
   * 执行Wi-Fi扫描
   */
  async scanWifiAccessPoints(): Promise<WifiScanResult[]> {
    try {
      // 检查Wi-Fi是否开启
      if (!wifiManager.isWifiActive()) {
        console.warn(TAG, 'Wi-Fi未开启，尝试开启...');
        wifiManager.enableWifi();
        // 等待Wi-Fi启动
        await this.delay(2000);
      }

      // 发起扫描
      const scanResult = await wifiManager.scan();
      console.info(TAG, `Wi-Fi扫描${scanResult ? '成功' : '失败'}`);

      // 获取扫描结果
      const results = wifiManager.getScanResultsSync();
      this.scanResults = results.map(info => ({
        ssid: info.ssid,
        bssid: info.bssid,
        rssi: info.rssi,
        band: info.band,
        frequency: info.frequency,
        channelWidth: info.channelWidth
      }));

      // 按信号强度排序
      this.scanResults.sort((a, b) => b.rssi - a.rssi);

      console.info(TAG, `扫描到 ${this.scanResults.length} 个Wi-Fi AP`);
      return this.scanResults;
    } catch (error) {
      const err = error as BusinessError;
      console.error(TAG, `Wi-Fi扫描失败: ${err.code} - ${err.message}`);
      return [];
    }
  }

  /**
   * 获取信号最强的N个AP
   */
  getTopAccessPoints(count: number = 5): WifiScanResult[] {
    return this.scanResults.slice(0, count);
  }

  /**
   * 评估Wi-Fi定位可用性
   * @returns 可用性评分 0~100
   */
  evaluateWifiPositioningAvailability(): number {
    if (this.scanResults.length === 0) return 0;

    let score = 0;
    // AP数量评分（0~40分）
    const apCount = this.scanResults.length;
    score += Math.min(apCount * 4, 40);

    // 信号质量评分（0~30分）
    const strongSignals = this.scanResults.filter(ap => ap.rssi > -60).length;
    score += Math.min(strongSignals * 10, 30);

    // AP多样性评分（0~30分）
    const uniqueBssids = new Set(this.scanResults.map(ap => ap.bssid)).size;
    score += Math.min(uniqueBssids * 5, 30);

    return Math.min(score, 100);
  }

  /**
   * 生成位置辅助数据
   * 用于发送到定位服务器进行Wi-Fi指纹匹配
   */
  generatePositioningPayload(): Record<string, string>[] {
    return this.scanResults.slice(0, 10).map(ap => ({
      'bssid': ap.bssid,
      'rssi': ap.rssi.toString(),
      'ssid': ap.ssid,
      'frequency': ap.frequency.toString()
    }));
  }

  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

3.3 基站信息获取

// CellInfoCollector.ets
// 功能：获取基站信息用于基站定位

import { radio } from '@kit.TelephonyKit';
import { BusinessError } from '@kit.BasicServicesKit';

const TAG = '[CellInfoCollector]';

// 基站信息
export interface CellInfo {
  mcc: string;       // 移动国家代码
  mnc: string;       // 移动网络代码
  lac: number;       // 位置区域码
  cellId: number;    // 小区标识
  rssi: number;      // 信号强度
  tac: number;       // 跟踪区域码
  earfcn: number;    // E-UTRA绝对频率号
  pci: number;       // 物理小区标识
  signalLevel: number; // 信号等级
}

export class CellInfoCollector {
  /**
   * 获取当前基站信息
   */
  getCurrentCellInfo(): CellInfo | null {
    try {
      // 获取SIM卡状态
      const simState = radio.getSimStateSync(0);
      if (simState !== radio.SimState.SIM_STATE_READY) {
        console.warn(TAG, 'SIM卡未就绪');
        return null;
      }

      // 获取网络状态
      const networkState = radio.getNetworkStateSync(0);
      if (!networkState) {
        console.warn(TAG, '无法获取网络状态');
        return null;
      }

      // 构建基站信息
      const cellInfo: CellInfo = {
        mcc: networkState.plmn?.substring(0, 3) || '460',
        mnc: networkState.plmn?.substring(3) || '00',
        lac: 0,
        cellId: 0,
        rssi: 0,
        tac: 0,
        earfcn: 0,
        pci: 0,
        signalLevel: radio.getSignalLevelSync(0)
      };

      console.info(TAG, `基站信息: MCC=${cellInfo.mcc}, MNC=${cellInfo.mnc}, ` +
        `信号等级=${cellInfo.signalLevel}`);
      return cellInfo;
    } catch (error) {
      const err = error as BusinessError;
      console.error(TAG, `获取基站信息失败: ${err.code} - ${err.message}`);
      return null;
    }
  }

  /**
   * 评估基站定位可用性
   */
  evaluateCellPositioningAvailability(): { available: boolean; reason: string } {
    try {
      // 检查蜂窝网络连接
      const networkState = radio.getNetworkStateSync(0);
      if (!networkState || !networkState.isNetworkConnected) {
        return { available: false, reason: '蜂窝网络未连接' };
      }

      // 检查信号强度
      const signalLevel = radio.getSignalLevelSync(0);
      if (signalLevel <= 1) {
        return { available: false, reason: '信号太弱，定位精度极低' };
      }

      return { available: true, reason: '基站定位可用' };
    } catch (error) {
      return { available: false, reason: '无法获取网络状态' };
    }
  }
}

3.4 智能定位策略管理器

// SmartLocationStrategy.ets
// 功能：智能定位策略管理，根据环境自动选择最优定位方式

import { geoLocationManager } from '@kit.LocationKit';
import { NetworkLocationManager, NetworkLocationMode, NetworkLocationResult } from './NetworkLocationManager';
import { WifiScanAssistant } from './WifiScanAssistant';
import { CellInfoCollector } from './CellInfoCollector';
import { BusinessError } from '@kit.BasicServicesKit';

const TAG = '[SmartLocationStrategy]';

// 定位环境评估
export interface LocationEnvironment {
  gpsAvailable: boolean;
  wifiAvailable: boolean;
  wifiScore: number;
  cellAvailable: boolean;
  cellSignalLevel: number;
  recommendedMode: NetworkLocationMode;
  recommendedPriority: geoLocationManager.LocationRequestPriority;
}

export class SmartLocationStrategy {
  private networkLocator = new NetworkLocationManager();
  private wifiScanner = new WifiScanAssistant();
  private cellCollector = new CellInfoCollector();

  /**
   * 评估当前定位环境
   */
  async evaluateEnvironment(): Promise<LocationEnvironment> {
    // 检查GPS可用性
    let gpsAvailable = false;
    try {
      gpsAvailable = geoLocationManager.isLocationEnabled();
    } catch (e) {
      gpsAvailable = false;
    }

    // 评估Wi-Fi定位可用性
    let wifiAvailable = false;
    let wifiScore = 0;
    try {
      await this.wifiScanner.scanWifiAccessPoints();
      wifiScore = this.wifiScanner.evaluateWifiPositioningAvailability();
      wifiAvailable = wifiScore > 30;
    } catch (e) {
      wifiAvailable = false;
    }

    // 评估基站定位可用性
    let cellAvailable = false;
    let cellSignalLevel = 0;
    try {
      const cellEval = this.cellCollector.evaluateCellPositioningAvailability();
      cellAvailable = cellEval.available;
      const cellInfo = this.cellCollector.getCurrentCellInfo();
      cellSignalLevel = cellInfo?.signalLevel ?? 0;
    } catch (e) {
      cellAvailable = false;
    }

    // 决策推荐模式
    let recommendedMode: NetworkLocationMode;
    let recommendedPriority: geoLocationManager.LocationRequestPriority;

    if (gpsAvailable && wifiAvailable) {
      recommendedMode = NetworkLocationMode.HYBRID;
      recommendedPriority = geoLocationManager.LocationRequestPriority.ACCURACY_PRIORITY;
    } else if (wifiAvailable) {
      recommendedMode = NetworkLocationMode.WIFI_ONLY;
      recommendedPriority = geoLocationManager.LocationRequestPriority.LOW_POWER_PRIORITY;
    } else if (cellAvailable) {
      recommendedMode = NetworkLocationMode.CELL_ONLY;
      recommendedPriority = geoLocationManager.LocationRequestPriority.LOW_POWER_PRIORITY;
    } else {
      recommendedMode = NetworkLocationMode.AUTO_FALLBACK;
      recommendedPriority = geoLocationManager.LocationRequestPriority.FIRST_FIX_PRIORITY;
    }

    const env: LocationEnvironment = {
      gpsAvailable,
      wifiAvailable,
      wifiScore,
      cellAvailable,
      cellSignalLevel,
      recommendedMode,
      recommendedPriority
    };

    console.info(TAG, `环境评估: GPS=${gpsAvailable}, WiFi=${wifiAvailable}(${wifiScore}分), ` +
      `Cell=${cellAvailable}(${cellSignalLevel}级), 推荐=${recommendedMode}`);
    return env;
  }

  /**
   * 智能定位：根据环境自动选择最优方式
   */
  async smartLocate(): Promise<NetworkLocationResult | null> {
    // 第1步：评估环境
    const env = await this.evaluateEnvironment();

    // 第2步：使用推荐模式定位
    const result = await this.networkLocator.getNetworkLocation(env.recommendedMode);

    if (result) {
      console.info(TAG, `智能定位成功: source=${result.source}, accuracy=${result.accuracy.toFixed(1)}m`);
    } else {
      console.warn(TAG, '智能定位失败，所有定位源均不可用');
    }

    return result;
  }

  /**
   * 渐进式定位：先快速粗定位，再逐步精化
   */
  async progressiveLocate(
    onProgress: (result: NetworkLocationResult, phase: string) => void
  ): Promise<NetworkLocationResult | null> {
    // 阶段1：快速网络定位（1~3秒）
    console.info(TAG, '阶段1: 快速网络定位');
    const quickResult = await this.networkLocator.getNetworkLocation(
      NetworkLocationMode.AUTO_FALLBACK, 5000
    );
    if (quickResult) {
      onProgress(quickResult, '快速定位');
    }

    // 阶段2：Wi-Fi精化定位
    if (quickResult && quickResult.accuracy > 30) {
      console.info(TAG, '阶段2: Wi-Fi精化定位');
      const wifiResult = await this.networkLocator.getNetworkLocation(
        NetworkLocationMode.WIFI_ONLY, 10000
      );
      if (wifiResult && wifiResult.accuracy < quickResult.accuracy) {
        onProgress(wifiResult, 'Wi-Fi精化');
        return wifiResult;
      }
    }

    // 阶段3：GNSS高精度定位（如果可用）
    if (quickResult) {
      console.info(TAG, '阶段3: 尝试GNSS高精度定位');
      try {
        const gnssRequest: geoLocationManager.SingleLocationRequest = {
          priority: geoLocationManager.LocationRequestPriority.ACCURACY_PRIORITY,
          timeoutMs: 20000
        };
        const gnssLocation = await geoLocationManager.getCurrentLocation(gnssRequest);
        const gnssResult: NetworkLocationResult = {
          latitude: gnssLocation.latitude,
          longitude: gnssLocation.longitude,
          accuracy: gnssLocation.accuracy,
          source: 'GNSS',
          responseTime: 0,
          timestamp: gnssLocation.timeStamp
        };
        if (gnssResult.accuracy < quickResult.accuracy) {
          onProgress(gnssResult, 'GNSS高精度');
          return gnssResult;
        }
      } catch (e) {
        console.info(TAG, 'GNSS定位不可用，使用网络定位结果');
      }
    }

    return quickResult;
  }
}

四、踩坑与注意事项

4.1 Wi-Fi扫描权限问题

Wi-Fi扫描在HarmonyOS中受到严格权限管控：

// ❌ 错误：未申请Wi-Fi权限直接扫描
async function scanWithoutPermission(): Promise<void> {
  const results = wifiManager.getScanResultsSync(); // 可能抛出权限异常
}

// ✅ 正确：先检查再扫描
async function scanWithPermissionCheck(): Promise<void> {
  // 1. 需要位置权限
  // 2. Wi-Fi开关需要开启
  // 3. 部分设备需要连接过Wi-Fi网络
  if (!wifiManager.isWifiActive()) {
    console.warn('Wi-Fi未开启');
    return;
  }
  try {
    await wifiManager.scan();
    const results = wifiManager.getScanResultsSync();
    console.info(`扫描到 ${results.length} 个AP`);
  } catch (error) {
    console.error('扫描失败，请检查权限', JSON.stringify(error));
  }
}

4.2 基站定位精度波动

基站定位精度受以下因素影响极大：

建议：基站定位仅作为最后降级手段，不应作为主要定位方式。

4.3 网络定位缓存陷阱

// ⚠️ 注意：连续调用getCurrentLocation可能返回缓存结果
// 如果需要实时位置，应使用持续定位模式

// ❌ 错误：频繁单次定位获取实时位置
setInterval(async () => {
  const loc = await geoLocationManager.getCurrentLocation(request);
  // 可能返回相同的位置缓存
}, 1000);

// ✅ 正确：使用持续定位获取实时位置
const callbackId = geoLocationManager.on('locationChange', continuousRequest, (loc) => {
  // 每次都是新的位置更新
});

4.4 Android/iOS迁移差异

五、HarmonyOS 6适配

5.1 Wi-Fi 7定位增强

HarmonyOS 6支持Wi-Fi 7的新特性用于定位增强：

• 多链路操作（MLO）：同时使用2.4GHz和5GHz/6GHz频段，提高指纹匹配精度
• 精细时间测量（FTM）：通过RTT（Round Trip Time）直接测距，精度可达1~2米
• 感知技术：利用Wi-Fi信号变化检测人员移动

5.2 5G基站定位

5G网络的密集基站部署为基站定位带来质的提升：

• 5G毫米波：基站覆盖半径小（100~200m），Cell-ID精度大幅提升
• PRS定位参考信号：5G NR原生支持定位参考信号，精度可达3~10米
• 多TRP协同：多个传输接收点协同定位，提高三角测量精度

5.3 隐私计算定位

HarmonyOS 6引入了差分隐私定位：

// 差分隐私定位：在位置数据中添加噪声保护隐私
// 应用只能获取模糊化后的位置，无法精确定位用户
const privacyRequest: geoLocationManager.SingleLocationRequest = {
  priority: geoLocationManager.LocationRequestPriority.LOW_POWER_PRIORITY,
  timeoutMs: 10000
};
// 系统自动在结果中添加差分隐私噪声

六、总结

本文深入探讨了HarmonyOS网络定位与基站定位的技术原理与开发实践：

核心建议：

1. 生产环境务必实现环境评估→策略选择→降级兜底的完整链路
2. 网络定位适合作为快速首定位和GPS降级方案，不建议作为唯一定位源
3. Wi-Fi扫描注意控制频率，避免频繁扫描导致功耗飙升
4. 基站定位精度波动大，务必向用户展示精度信息，避免误导

下一篇我们将深入位置权限申请与隐私合规，探讨HarmonyOS位置权限体系、用户授权流程与隐私合规最佳实践。