HarmonyOS开发：位置权限申请与隐私合规

核心要点：全面掌握HarmonyOS位置权限体系，实现合规的用户授权流程，理解模糊定位与精确定位的双轨机制，构建符合隐私法规的LBS应用。

项目	说明
核心模块	@kit.AbilityKit（abilityAccessCtrl）
权限等级	normal / system_basic / system_core

一、背景与动机

1.1 位置权限为何如此敏感

位置信息是最高敏感度的个人数据之一。根据《个人信息保护法》《数据安全法》等法规，位置信息属于敏感个人信息，处理前必须取得用户的单独同意。近年来，因位置信息违规收集被下架的应用屡见不鲜：

1.2 HarmonyOS位置权限演进

timeline
    title HarmonyOS位置权限演进
    section HarmonyOS 3
        单一位置权限 : ohos.permission.LOCATION
        无前后台区分 : 前后台统一权限
    section HarmonyOS 4
        双轨权限 : APPROXIMATELY_LOCATION + LOCATION
        模糊定位 : 用户可选择模糊定位
    section HarmonyOS 5
        后台定位权限 : LOCATION_IN_BACKGROUND
        位置使用指示器 : 系统状态栏指示灯
    section HarmonyOS 6
        临时授权 : 单次授权自动回收
        位置数据审计 : 系统级位置访问日志

1.3 位置权限体系全景

HarmonyOS的位置权限采用三层分级设计：

权限依赖关系：

APPROXIMATELY_LOCATION（基础权限，必须先授予）
        ↓ 依赖
LOCATION（精确定位，需要先有模糊定位权限）
        ↓ 依赖
LOCATION_IN_BACKGROUND（后台定位，需要先有精确定位权限）

二、核心原理

2.1 权限授权流程

flowchart TB
    A[应用发起定位请求] --> B{检查APPROXIMATELY_LOCATION}
    B -->|未授予| C[请求模糊定位权限]
    C --> D{用户选择}
    D -->|拒绝| E[无法定位<br/>降级处理]
    D -->|模糊定位| F[获取大致位置<br/>精度: 城市级]
    D -->|精确定位| G{检查LOCATION}
    
    B -->|已授予| G
    G -->|未授予| H[请求精确定位权限]
    H --> I{用户选择}
    I -->|拒绝| F
    I -->|授予| J{是否需要后台定位}
    
    G -->|已授予| J
    J -->|否| K[前台精确定位]
    J -->|是| L{检查LOCATION_IN_BACKGROUND}
    L -->|未授予| M[请求后台定位权限]
    M --> N{用户选择}
    N -->|拒绝| K
    N -->|授予| O[后台精确定位]
    L -->|已授予| O
    
    classDef startStyle fill:#E17055,stroke:#D63031,color:#FFF,font-weight:bold
    classDef checkStyle fill:#6C5CE7,stroke:#5B4CDB,color:#FFF,font-weight:bold
    classDef requestStyle fill:#0984E3,stroke:#0770C2,color:#FFF,font-weight:bold
    classDef resultStyle fill:#00B894,stroke:#00A383,color:#FFF,font-weight:bold
    classDef denyStyle fill:#D63031,stroke:#C0392B,color:#FFF,font-weight:bold
    
    class A startStyle
    class B,G,L checkStyle
    class C,H,M requestStyle
    class F,K,O resultStyle
    class E denyStyle

2.2 模糊定位机制

HarmonyOS的模糊定位（Approximate Location）是一种隐私保护机制：

• 精度降级：将精确坐标偏移到城市/区域级别（约3~5公里范围）
• 用户可控：用户可以在系统设置中随时切换模糊/精确模式
• 应用适配：应用需要根据实际精度调整功能表现

// 模糊定位返回的坐标示例
// 真实位置: 39.904200, 116.407396 (天安门)
// 模糊位置: 39.912000, 116.398000 (约3公里偏移)

// 通过accuracy字段判断是否为模糊定位
if (location.accuracy > 3000) {
  // 大概率是模糊定位
  console.info('当前为模糊定位模式');
}

2.3 后台定位限制

HarmonyOS对后台定位施加了严格限制：

三、代码实战

3.1 完整权限管理器

// LocationPermissionManager.ets
// 功能：位置权限完整管理，支持模糊/精确定位、后台定位

import { abilityAccessCtrl, bundleManager, Permissions, common } from '@kit.AbilityKit';
import { BusinessError } from '@kit.BasicServicesKit';

const TAG = '[LocationPermissionManager]';

// 权限状态枚举
export enum PermissionStatus {
  GRANTED = 'granted',           // 已授予
  DENIED = 'denied',             // 已拒绝
  DENIED_DO_NOT_ASK_AGAIN = 'denied_permanently', // 永久拒绝
  NOT_REQUESTED = 'not_requested'  // 未请求
}

// 权限申请结果
export interface PermissionResult {
  approximateStatus: PermissionStatus;  // 模糊定位状态
  preciseStatus: PermissionStatus;      // 精确定位状态
  backgroundStatus: PermissionStatus;   // 后台定位状态
  canLocate: boolean;                   // 是否可以定位
  isPrecise: boolean;                   // 是否精确定位
  canBackgroundLocate: boolean;         // 是否可后台定位
}

export class LocationPermissionManager {
  private atManager: abilityAccessCtrl.AtManager;
  private context: common.UIAbilityContext;

  constructor(context: common.UIAbilityContext) {
    this.atManager = abilityAccessCtrl.createAtManager();
    this.context = context;
  }

  /**
   * 检查单个权限状态
   */
  async checkPermission(permission: Permissions): Promise<PermissionStatus> {
    try {
      const bundleInfo = bundleManager.getBundleInfoForSelfSync(
        bundleManager.BundleFlag.GET_BUNDLE_INFO_DEFAULT
      );
      const tokenId = bundleInfo.appId;
      const grantStatus = await this.atManager.checkAccessToken(tokenId, permission);

      return grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED
        ? PermissionStatus.GRANTED
        : PermissionStatus.DENIED;
    } catch (error) {
      console.error(TAG, `检查权限失败: ${permission}`, JSON.stringify(error));
      return PermissionStatus.NOT_REQUESTED;
    }
  }

  /**
   * 获取完整权限状态
   */
  async getPermissionStatus(): Promise<PermissionResult> {
    const approximateStatus = await this.checkPermission('ohos.permission.APPROXIMATELY_LOCATION');
    const preciseStatus = await this.checkPermission('ohos.permission.LOCATION');
    const backgroundStatus = await this.checkPermission('ohos.permission.LOCATION_IN_BACKGROUND');

    return {
      approximateStatus,
      preciseStatus,
      backgroundStatus,
      canLocate: approximateStatus === PermissionStatus.GRANTED ||
                 preciseStatus === PermissionStatus.GRANTED,
      isPrecise: preciseStatus === PermissionStatus.GRANTED,
      canBackgroundLocate: preciseStatus === PermissionStatus.GRANTED &&
                           backgroundStatus === PermissionStatus.GRANTED
    };
  }

  /**
   * 请求位置权限（分步策略）
   * 先请求模糊定位，再请求精确定位
   */
  async requestLocationPermissions(): Promise<PermissionResult> {
    // 第1步：请求模糊定位权限
    console.info(TAG, '第1步: 请求模糊定位权限');
    const approximateResult = await this.requestPermissions(
      ['ohos.permission.APPROXIMATELY_LOCATION']
    );

    if (approximateResult[0] !== 0) {
      // 用户拒绝了模糊定位
      console.warn(TAG, '用户拒绝了模糊定位权限');
      return {
        approximateStatus: PermissionStatus.DENIED,
        preciseStatus: PermissionStatus.NOT_REQUESTED,
        backgroundStatus: PermissionStatus.NOT_REQUESTED,
        canLocate: false,
        isPrecise: false,
        canBackgroundLocate: false
      };
    }

    // 第2步：请求精确定位权限
    console.info(TAG, '第2步: 请求精确定位权限');
    const preciseResult = await this.requestPermissions(
      ['ohos.permission.LOCATION']
    );

    const isPrecise = preciseResult[0] === 0;

    return {
      approximateStatus: PermissionStatus.GRANTED,
      preciseStatus: isPrecise ? PermissionStatus.GRANTED : PermissionStatus.DENIED,
      backgroundStatus: PermissionStatus.NOT_REQUESTED,
      canLocate: true,
      isPrecise: isPrecise,
      canBackgroundLocate: false
    };
  }

  /**
   * 请求后台定位权限
   */
  async requestBackgroundPermission(): Promise<PermissionResult> {
    // 先确保有精确定位权限
    const currentStatus = await this.getPermissionStatus();
    if (!currentStatus.isPrecise) {
      console.warn(TAG, '需要先授予精确定位权限');
      const result = await this.requestLocationPermissions();
      if (!result.isPrecise) {
        return result;
      }
    }

    // 请求后台定位权限
    console.info(TAG, '请求后台定位权限');
    const bgResult = await this.requestPermissions(
      ['ohos.permission.LOCATION_IN_BACKGROUND']
    );

    const bgGranted = bgResult[0] === 0;

    return {
      approximateStatus: PermissionStatus.GRANTED,
      preciseStatus: PermissionStatus.GRANTED,
      backgroundStatus: bgGranted ? PermissionStatus.GRANTED : PermissionStatus.DENIED,
      canLocate: true,
      isPrecise: true,
      canBackgroundLocate: bgGranted
    };
  }

  /**
   * 批量请求权限
   */
  private async requestPermissions(permissions: Array<Permissions>): Promise<number[]> {
    try {
      const result = await this.atManager.requestPermissionsFromUser(
        this.context, permissions
      );
      console.info(TAG, `权限请求结果: ${JSON.stringify(result.authResults)}`);
      return result.authResults;
    } catch (error) {
      const err = error as BusinessError;
      console.error(TAG, `权限请求异常: ${err.code} - ${err.message}`);
      return permissions.map(() => -1);
    }
  }

  /**
   * 引导用户到系统设置页面
   */
  openSystemSettings(): void {
    try {
      const context = this.context as common.UIAbilityContext;
      // 打开应用设置页面
      context.startAbility({
        bundleName: 'com.huawei.hmos.settings',
        abilityName: 'PrivacyEntryAbility',
        parameters: {
          pageType: 'location'
        }
      });
    } catch (error) {
      console.error(TAG, '无法打开系统设置', JSON.stringify(error));
    }
  }
}

3.2 权限说明弹窗组件

// PermissionRationaleDialog.ets
// 功能：权限申请前的说明弹窗，解释为何需要位置权限

@CustomDialog
export struct PermissionRationaleDialog {
  controller: CustomDialogController;
  onConfirm: () => void;
  onCancel: () => void;
  @State permissionType: string = 'location'; // location / background

  build() {
    Column() {
      // 图标
      Image($r('app.media.ic_location_permission'))
        .width(56)
        .height(56)
        .margin({ top: 24, bottom: 16 })

      // 标题
      Text(this.permissionType === 'background' ? '需要后台定位权限' : '需要位置权限')
        .fontSize(20)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .margin({ bottom: 12 })

      // 说明文字
      Text(this.getRationaleText())
        .fontSize(14)
        .fontColor('#CCCCCC')
        .lineHeight(22)
        .textAlign(TextAlign.Center)
        .padding({ left: 24, right: 24 })
        .margin({ bottom: 24 })

      // 权限详情
      Column() {
        this.PermissionItem('📍', '实时导航', '为您提供精准的路线规划和导航服务')
        this.PermissionItem('🏃', '运动追踪', '记录您的运动轨迹和距离数据')
        this.PermissionItem('🌤️', '天气服务', '提供您所在位置的实时天气信息')
      }
      .width('100%')
      .padding({ left: 16, right: 16 })
      .margin({ bottom: 24 })

      // 操作按钮
      Row() {
        Button('暂不授权')
          .fontSize(14)
          .fontColor('#AAAAAA')
          .backgroundColor('rgba(255,255,255,0.08)')
          .borderRadius(22)
          .width('45%')
          .height(44)
          .onClick(() => {
            this.controller.close();
            this.onCancel();
          })

        Button('去授权')
          .fontSize(14)
          .fontColor('#FFFFFF')
          .backgroundColor('#4ECDC4')
          .borderRadius(22)
          .width('45%')
          .height(44)
          .onClick(() => {
            this.controller.close();
            this.onConfirm();
          })
      }
      .width('100%')
      .justifyContent(FlexAlign.SpaceBetween)
      .padding({ left: 24, right: 24, bottom: 24 })
    }
    .width('85%')
    .borderRadius(20)
    .backgroundColor('rgba(30,30,50,0.95)')
    .backdropBlur(30)
  }

  @Builder
  PermissionItem(icon: string, title: string, desc: string) {
    Row() {
      Text(icon)
        .fontSize(20)
        .margin({ right: 12 })

      Column() {
        Text(title)
          .fontSize(14)
          .fontColor('#FFFFFF')
          .fontWeight(FontWeight.Medium)
        Text(desc)
          .fontSize(12)
          .fontColor('#999999')
          .margin({ top: 2 })
      }
      .alignItems(HorizontalAlign.Start)
    }
    .width('100%')
    .padding({ top: 8, bottom: 8 })
  }

  private getRationaleText(): string {
    if (this.permissionType === 'background') {
      return '当您在使用导航或运动追踪功能时，即使应用在后台运行，也需要持续获取您的位置信息，以确保服务的连续性和准确性。';
    }
    return '我们需要获取您的位置信息，以提供导航、运动追踪、天气等基于位置的服务。您可以选择精确或模糊定位。';
  }
}

3.3 隐私合规位置服务封装

// PrivacyCompliantLocationService.ets
// 功能：隐私合规的位置服务封装，确保权限检查、用户告知、数据最小化

import { geoLocationManager } from '@kit.LocationKit';
import { common } from '@kit.AbilityKit';
import {
  LocationPermissionManager,
  PermissionResult,
  PermissionStatus
} from './LocationPermissionManager';
import { BusinessError } from '@kit.BasicServicesKit';

const TAG = '[PrivacyCompliantLocationService]';

// 位置数据使用声明
export interface LocationUsageDeclaration {
  purpose: string;           // 使用目的
  dataRetention: string;     // 数据保留期限
  thirdPartySharing: boolean; // 是否共享给第三方
  anonymization: boolean;     // 是否匿名化处理
}

// 合规定位结果
export interface CompliantLocationResult {
  location: geoLocationManager.Location | null;
  isPrecise: boolean;
  isBackground: boolean;
  usageDeclaration: LocationUsageDeclaration;
  timestamp: number;
}

export class PrivacyCompliantLocationService {
  private permissionManager: LocationPermissionManager;
  private usageDeclaration: LocationUsageDeclaration;
  private accessLog: Array<{ time: number; purpose: string; precise: boolean }> = [];

  constructor(context: common.UIAbilityContext) {
    this.permissionManager = new LocationPermissionManager(context);
    this.usageDeclaration = {
      purpose: '导航与位置服务',
      dataRetention: '30天',
      thirdPartySharing: false,
      anonymization: true
    };
  }

  /**
   * 设置位置使用声明
   */
  setUsageDeclaration(declaration: LocationUsageDeclaration): void {
    this.usageDeclaration = declaration;
    console.info(TAG, `位置使用声明已更新: purpose=${declaration.purpose}`);
  }

  /**
   * 合规定位：完整的权限检查→用户告知→定位流程
   */
  async locateCompliantly(
    requirePrecise: boolean = true,
    requireBackground: boolean = false
  ): Promise<CompliantLocationResult> {
    // 第1步：检查权限状态
    const permStatus = await this.permissionManager.getPermissionStatus();

    // 第2步：权限不足时请求权限
    if (!permStatus.canLocate) {
      console.info(TAG, '位置权限未授予，请求权限');
      const newStatus = await this.permissionManager.requestLocationPermissions();
      if (!newStatus.canLocate) {
        return this.createResult(null, false, false);
      }
    }

    // 第3步：精确定位权限检查
    if (requirePrecise && !permStatus.isPrecise) {
      console.info(TAG, '请求精确定位权限');
      const newStatus = await this.permissionManager.requestLocationPermissions();
      if (!newStatus.isPrecise) {
        console.warn(TAG, '用户仅授予模糊定位，降级处理');
        // 使用模糊定位继续
      }
    }

    // 第4步：后台定位权限检查
    if (requireBackground && !permStatus.canBackgroundLocate) {
      console.info(TAG, '请求后台定位权限');
      await this.permissionManager.requestBackgroundPermission();
    }

    // 第5步：执行定位
    const currentPerm = await this.permissionManager.getPermissionStatus();
    const priority = currentPerm.isPrecise
      ? geoLocationManager.LocationRequestPriority.ACCURACY_PRIORITY
      : geoLocationManager.LocationRequestPriority.LOW_POWER_PRIORITY;

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

      const location = await geoLocationManager.getCurrentLocation(requestInfo);

      // 第6步：记录访问日志
      this.logAccess(this.usageDeclaration.purpose, currentPerm.isPrecise);

      return this.createResult(location, currentPerm.isPrecise, currentPerm.canBackgroundLocate);
    } catch (error) {
      const err = error as BusinessError;
      console.error(TAG, `定位失败: ${err.code} - ${err.message}`);
      return this.createResult(null, currentPerm.isPrecise, currentPerm.canBackgroundLocate);
    }
  }

  /**
   * 获取访问日志
   */
  getAccessLog(): Array<{ time: number; purpose: string; precise: boolean }> {
    return [...this.accessLog];
  }

  /**
   * 数据匿名化处理
   * 对位置数据进行差分隐私处理
   */
  anonymizeLocation(location: geoLocationManager.Location): geoLocationManager.Location {
    if (!this.usageDeclaration.anonymization) {
      return location;
    }

    // 添加随机偏移（约500米范围）
    const offsetLat = (Math.random() - 0.5) * 0.01;
    const offsetLng = (Math.random() - 0.5) * 0.01;

    return {
      ...location,
      latitude: location.latitude + offsetLat,
      longitude: location.longitude + offsetLng,
      accuracy: Math.max(location.accuracy, 500) // 精度设为至少500米
    };
  }

  /**
   * 记录访问日志
   */
  private logAccess(purpose: string, precise: boolean): void {
    this.accessLog.push({
      time: Date.now(),
      purpose: purpose,
      precise: precise
    });

    // 限制日志大小
    if (this.accessLog.length > 100) {
      this.accessLog.shift();
    }

    console.info(TAG, `位置访问已记录: purpose=${purpose}, precise=${precise}`);
  }

  /**
   * 创建结果
   */
  private createResult(
    location: geoLocationManager.Location | null,
    isPrecise: boolean,
    isBackground: boolean
  ): CompliantLocationResult {
    return {
      location,
      isPrecise,
      isBackground,
      usageDeclaration: { ...this.usageDeclaration },
      timestamp: Date.now()
    };
  }
}

3.4 权限设置引导页面

// PermissionGuidePage.ets
// 功能：权限设置引导页面，帮助用户理解并授予位置权限

import { LocationPermissionManager, PermissionResult, PermissionStatus } from './LocationPermissionManager';
import { common } from '@kit.AbilityKit';

@Entry
@Component
struct PermissionGuidePage {
  private permManager: LocationPermissionManager =
    new LocationPermissionManager(getContext(this) as common.UIAbilityContext);

  @State permResult: PermissionResult = {
    approximateStatus: PermissionStatus.NOT_REQUESTED,
    preciseStatus: PermissionStatus.NOT_REQUESTED,
    backgroundStatus: PermissionStatus.NOT_REQUESTED,
    canLocate: false,
    isPrecise: false,
    canBackgroundLocate: false
  };
  @State isRequesting: boolean = false;

  async aboutToAppear(): Promise<void> {
    this.permResult = await this.permManager.getPermissionStatus();
  }

  /**
   * 请求位置权限
   */
  async requestLocationPerm(): Promise<void> {
    this.isRequesting = true;
    this.permResult = await this.permManager.requestLocationPermissions();
    this.isRequesting = false;
  }

  /**
   * 请求后台权限
   */
  async requestBackgroundPerm(): Promise<void> {
    this.isRequesting = true;
    this.permResult = await this.permManager.requestBackgroundPermission();
    this.isRequesting = false;
  }

  build() {
    Scroll() {
      Column() {
        // 标题
        Text('位置权限设置')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFFFFF')
          .margin({ top: 30, bottom: 24 })

        // 权限状态卡片
        Column() {
          this.PermissionStatusItem(
            '模糊定位',
            'ohos.permission.APPROXIMATELY_LOCATION',
            this.permResult.approximateStatus
          )
          Divider().color('rgba(255,255,255,0.06)')
          this.PermissionStatusItem(
            '精确定位',
            'ohos.permission.LOCATION',
            this.permResult.preciseStatus
          )
          Divider().color('rgba(255,255,255,0.06)')
          this.PermissionStatusItem(
            '后台定位',
            'ohos.permission.LOCATION_IN_BACKGROUND',
            this.permResult.backgroundStatus
          )
        }
        .width('90%')
        .padding(16)
        .borderRadius(12)
        .backgroundColor('rgba(255,255,255,0.08)')
        .backdropBlur(20)

        // 操作区域
        Column() {
          if (!this.permResult.canLocate) {
            Button('授予位置权限')
              .width('90%')
              .height(48)
              .fontSize(16)
              .fontWeight(FontWeight.Medium)
              .backgroundColor('#4ECDC4')
              .borderRadius(24)
              .enabled(!this.isRequesting)
              .onClick(() => this.requestLocationPerm())
          }

          if (this.permResult.canLocate && !this.permResult.isPrecise) {
            Button('升级为精确定位')
              .width('90%')
              .height(48)
              .fontSize(16)
              .fontWeight(FontWeight.Medium)
              .backgroundColor('#FF6B6B')
              .borderRadius(24)
              .margin({ top: 12 })
              .enabled(!this.isRequesting)
              .onClick(() => this.requestLocationPerm())
          }

          if (this.permResult.isPrecise && !this.permResult.canBackgroundLocate) {
            Button('开启后台定位')
              .width('90%')
              .height(48)
              .fontSize(16)
              .fontWeight(FontWeight.Medium)
              .backgroundColor('#6C5CE7')
              .borderRadius(24)
              .margin({ top: 12 })
              .enabled(!this.isRequesting)
              .onClick(() => this.requestBackgroundPerm())
          }

          if (this.permResult.canBackgroundLocate) {
            Row() {
              Text('✅ 所有位置权限已授予')
                .fontSize(16)
                .fontColor('#00B894')
                .fontWeight(FontWeight.Medium)
            }
            .margin({ top: 16 })
          }
        }
        .width('100%')
        .alignItems(HorizontalAlign.Center)
        .margin({ top: 24 })

        // 隐私说明
        Column() {
          Text('隐私说明')
            .fontSize(16)
            .fontColor('#FFFFFF')
            .fontWeight(FontWeight.Medium)
            .margin({ bottom: 8 })

          Text('1. 您的位置信息仅用于提供导航和位置服务')
            .fontSize(12)
            .fontColor('#999999')
            .width('100%')
            .margin({ bottom: 4 })

          Text('2. 位置数据将在30天后自动删除')
            .fontSize(12)
            .fontColor('#999999')
            .width('100%')
            .margin({ bottom: 4 })

          Text('3. 我们不会将您的位置数据共享给第三方')
            .fontSize(12)
            .fontColor('#999999')
            .width('100%')
            .margin({ bottom: 4 })

          Text('4. 您可以随时在系统设置中撤销位置权限')
            .fontSize(12)
            .fontColor('#999999')
            .width('100%')
        }
        .width('90%')
        .padding(16)
        .borderRadius(12)
        .backgroundColor('rgba(255,255,255,0.04)')
        .margin({ top: 24, bottom: 30 })

        // 前往系统设置
        Button('前往系统设置')
          .fontSize(14)
          .fontColor('#AAAAAA')
          .backgroundColor('transparent')
          .onClick(() => this.permManager.openSystemSettings())
      }
      .width('100%')
      .alignItems(HorizontalAlign.Center)
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#1A1A2E')
  }

  @Builder
  PermissionStatusItem(name: string, permission: string, status: PermissionStatus) {
    Row() {
      Column() {
        Text(name)
          .fontSize(14)
          .fontColor('#FFFFFF')
          .fontWeight(FontWeight.Medium)
        Text(permission)
          .fontSize(10)
          .fontColor('#666666')
          .margin({ top: 2 })
      }
      .alignItems(HorizontalAlign.Start)
      .layoutWeight(1)

      Text(this.getStatusText(status))
        .fontSize(12)
        .fontColor(this.getStatusColor(status))
        .fontWeight(FontWeight.Medium)
    }
    .width('100%')
    .padding({ top: 12, bottom: 12 })
  }

  private getStatusText(status: PermissionStatus): string {
    switch (status) {
      case PermissionStatus.GRANTED: return '已授予';
      case PermissionStatus.DENIED: return '已拒绝';
      case PermissionStatus.DENIED_DO_NOT_ASK_AGAIN: return '永久拒绝';
      case PermissionStatus.NOT_REQUESTED: return '未请求';
      default: return '未知';
    }
  }

  private getStatusColor(status: PermissionStatus): string {
    switch (status) {
      case PermissionStatus.GRANTED: return '#00B894';
      case PermissionStatus.DENIED: return '#FF6B6B';
      case PermissionStatus.DENIED_DO_NOT_ASK_AGAIN: return '#D63031';
      default: return '#AAAAAA';
    }
  }
}

四、踩坑与注意事项

4.1 权限请求时机

// ❌ 错误：应用启动就弹权限请求
@Entry
@Component
struct IndexPage {
  async aboutToAppear() {
    // 用户还没看到应用内容，就弹出权限请求，体验极差
    await this.requestLocationPermission();
  }
}

// ✅ 正确：用户触发需要位置的功能时再请求
@Entry
@Component
struct IndexPage {
  async onNavigateButtonClick() {
    const permStatus = await this.permissionManager.getPermissionStatus();
    if (!permStatus.canLocate) {
      // 先显示说明弹窗
      this.showRationaleDialog();
    }
  }
}

4.2 模糊定位适配

// 根据定位精度调整功能表现
function adaptToLocationAccuracy(location: geoLocationManager.Location): void {
  if (location.accuracy <= 50) {
    // 精确定位：可以使用导航、轨迹记录等高精度功能
    enableNavigationFeatures();
  } else if (location.accuracy <= 500) {
    // 中等精度：可以使用天气、附近搜索等功能
    enableBasicLocationFeatures();
  } else {
    // 模糊定位：仅显示城市级信息
    enableCityLevelFeaturesOnly();
    showAccuracyWarning('当前定位精度较低，部分功能不可用');
  }
}

4.3 权限被永久拒绝的处理

// 检测权限是否被永久拒绝（用户勾选了"不再询问"）
async function handlePermanentDenial(): Promise<void> {
  // 1. 检查是否可以再次弹窗
  const permStatus = await this.permissionManager.getPermissionStatus();
  
  if (permStatus.preciseStatus === PermissionStatus.DENIED) {
    // 2. 尝试再次请求，如果系统不再弹窗，说明被永久拒绝
    const result = await this.permissionManager.requestLocationPermissions();
    
    if (!result.isPrecise) {
      // 3. 引导用户到系统设置手动开启
      showGoToSettingsDialog(
        '您已拒绝位置权限，如需使用位置功能，请前往系统设置手动开启。'
      );
    }
  }
}

4.4 module.json5权限声明

// module.json5 必须正确声明权限
{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.APPROXIMATELY_LOCATION",
        "reason": "$string:location_reason",
        "usedScene": {
          "abilities": ["EntryAbility"],
          "when": "inuse"
        }
      },
      {
        "name": "ohos.permission.LOCATION",
        "reason": "$string:precise_location_reason",
        "usedScene": {
          "abilities": ["EntryAbility"],
          "when": "inuse"
        }
      },
      {
        "name": "ohos.permission.LOCATION_IN_BACKGROUND",
        "reason": "$string:background_location_reason",
        "usedScene": {
          "abilities": ["EntryAbility"],
          "when": "always"
        }
      }
    ]
  }
}

关键要点：

• reason字段必须填写，否则应用市场审核不通过
• usedScene.when区分inuse（前台使用）和always（前后台）
• 后台定位权限的when必须设为always

五、HarmonyOS 6适配

5.1 单次授权机制

HarmonyOS 6新增单次授权（One-time Permission）：

• 用户选择"仅本次允许"后，应用退出或切到后台，权限自动回收
• 下次使用需重新授权
• 应用需处理权限突然被回收的情况

// HarmonyOS 6 单次授权处理
async function handleOneTimePermission(): Promise<void> {
  // 监听权限变化
  const atManager = abilityAccessCtrl.createAtManager();
  atManager.on('permissionChange', (tokenId: number, permissionName: string) => {
    if (permissionName === 'ohos.permission.LOCATION') {
      // 权限被回收，停止定位
      stopLocationTracking();
      showPermissionRevokedNotice();
    }
  });
}

5.2 位置数据审计

HarmonyOS 6提供系统级位置访问审计：

• 系统记录所有应用的位置访问行为
• 用户可在设置中查看每个应用的位置访问历史
• 应用应主动提供位置使用说明

5.3 敏感权限分组

HarmonyOS 6将位置权限纳入敏感权限组管理：

• 同一权限组的权限一起授予/撤销
• 位置权限与附近设备权限（蓝牙）归为同一组
• 授予位置权限时，系统可能同时提示蓝牙权限

六、总结

本文全面解析了HarmonyOS位置权限体系与隐私合规实践：

核心建议：

1. 永远不要在应用启动时立即请求位置权限，应在用户触发相关功能时再请求
2. 权限请求前先展示说明弹窗，解释为何需要该权限
3. 实现模糊定位降级，即使只有模糊定位也应提供基本服务
4. 记录位置访问日志，便于合规审计和用户查询
5. 数据匿名化处理，上传服务器前对位置数据进行脱敏

下一篇我们将深入地理围栏与区域触发，探讨如何基于位置信息实现智能区域监控与事件触发。