跨平台位置服务开发指南：从技术原理到商业落地

2026-03-17 04:00:28作者：史锋燃Gardner

问题导入：位置服务开发的三重挑战

在移动应用开发中，地理位置功能往往是产品差异化的关键，但开发者常面临三大核心难题：平台碎片化导致的重复开发、电量消耗与定位精度的平衡困境、复杂场景下的可靠性保障。某外卖平台技术团队曾透露，其早期版本因Android与iOS定位API差异导致配送地址偏差率高达15%，用户投诉率居高不下。

现代LBS应用开发需要解决的核心矛盾包括：

如何用一套代码实现跨平台位置服务
如何在保证定位精度的同时优化电量消耗
如何处理复杂环境（如室内、地下、高楼密集区）的定位偏差
如何合规处理用户位置数据并建立隐私保护机制

核心价值：Expo Location技术栈解析

Expo Location作为Expo生态的核心模块，通过抽象化平台差异，为开发者提供了统一的位置服务接口。其架构设计体现了三大技术优势：

技术原理透视 🔧

Expo Location的底层架构采用分层设计，主要包含四个核心组件：

graph TD
    A[应用层 API] --> B[权限管理层]
    B --> C[平台适配层]
    C --> D[原生定位引擎]
    D --> E[硬件抽象层]
    style A fill:#f9f,stroke:#333
    style B fill:#9f9,stroke:#333
    style C fill:#99f,stroke:#333
    style D fill:#ff9,stroke:#333
    style E fill:#f99,stroke:#333

权限管理层：自动处理Android的运行时权限和iOS的权限申请流程，将复杂的平台权限模型简化为统一的API调用。

平台适配层：封装了Android的FusedLocationProviderClient和iOS的CLLocationManager，提供一致的接口行为。

原生定位引擎：实现了位置数据的滤波、缓存和误差修正算法，确保不同设备上的定位结果一致性。

技术选型决策树

在决定是否采用Expo Location前，可通过以下决策路径评估：

是否需要跨平台支持？
├── 否 → 使用原生平台API
└── 是 → 是否需要深度定制定位引擎？
    ├── 是 → 考虑原生开发或混合方案
    └── 否 → 评估应用定位需求复杂度
        ├── 简单（仅需单次定位） → Expo Location基础功能
        ├── 中等（实时跟踪） → Expo Location + 自定义优化
        └── 复杂（地理围栏+后台跟踪） → Expo Location + TaskManager

💡 专家提示：对于需要亚米级精度的应用（如AR导航），建议结合平台原生API使用；而90%的LBS应用场景（如签到、附近服务、物流追踪）可完全依赖Expo Location实现。

场景化解决方案

场景一：共享出行应用的实时位置追踪

共享电动车平台需要在保证定位精度的同时最大化电池续航。以下是基于Expo Location的优化实现：

import React, { useState, useEffect } from 'react';
import { View, Text, StyleSheet } from 'react-native';
import * as Location from 'expo-location';
import * as TaskManager from 'expo-task-manager';

// 定义后台位置更新任务
// 任务名称必须在全局作用域定义，确保应用重启后仍可识别
TaskManager.defineTask('BIKE_TRACKING_TASK', async ({ data, error }) => {
  if (error) {
    console.error('位置跟踪错误:', error);
    return;
  }
  
  if (data) {
    const { locations } = data;
    // 仅在位置变化显著时上传（优化网络和电量消耗）
    if (isSignificantLocationChange(locations[0])) {
      await uploadLocationToServer(locations[0]);
    }
  }
});

export default function BikeTracker() {
  const [isTracking, setIsTracking] = useState(false);
  const [currentLocation, setCurrentLocation] = useState(null);
  const [batteryLevel, setBatteryLevel] = useState(100);

  // 初始化位置服务
  useEffect(() => {
    checkLocationServices();
    monitorBatteryLevel();
    return () => {
      if (isTracking) {
        stopTracking();
      }
    };
  }, []);

  // 检查位置服务状态
  const checkLocationServices = async () => {
    const enabled = await Location.hasServicesEnabledAsync();
    if (!enabled) {
      Alert.alert('位置服务已关闭', '请在系统设置中启用位置服务以使用追踪功能');
    }
  };

  // 监控电池电量，动态调整定位策略
  const monitorBatteryLevel = async () => {
    const subscription = BatteryState.addEventListener('batteryLevelDidChange', (level) => {
      setBatteryLevel(level * 100);
      adjustTrackingAccuracy(level * 100);
    });
    return () => subscription.remove();
  };

  // 根据电量动态调整定位精度
  const adjustTrackingAccuracy = (level) => {
    if (isTracking) {
      const options = level > 30 
        ? { accuracy: Location.Accuracy.Balanced, timeInterval: 3000 }
        : { accuracy: Location.Accuracy.Low, timeInterval: 10000 };
      
      updateTrackingOptions(options);
    }
  };

  // 开始追踪
  const startTracking = async () => {
    // 请求权限 - 采用渐进式权限申请策略
    const { status } = await Location.requestForegroundPermissionsAsync();
    if (status !== 'granted') {
      Alert.alert('权限不足', '需要位置权限才能提供追踪服务');
      return;
    }

    // 检查是否需要后台权限
    const backgroundStatus = await Location.getBackgroundPermissionsAsync();
    if (backgroundStatus.status !== 'granted') {
      const { status: newStatus } = await Location.requestBackgroundPermissionsAsync();
      if (newStatus !== 'granted') {
        Alert.alert('后台权限不足', '应用在后台时可能无法持续追踪位置');
      }
    }

    // 启动位置更新
    await Location.startLocationUpdatesAsync('BIKE_TRACKING_TASK', {
      accuracy: Location.Accuracy.Balanced,
      timeInterval: 3000, // 3秒更新一次
      distanceInterval: 5, // 移动5米更新一次
      showsBackgroundLocationIndicator: true, // 在状态栏显示定位图标
    });

    setIsTracking(true);
  };

  // 停止追踪
  const stopTracking = async () => {
    await Location.stopLocationUpdatesAsync('BIKE_TRACKING_TASK');
    setIsTracking(false);
  };

  // 判断位置变化是否显著
  const isSignificantLocationChange = (newLoc) => {
    if (!currentLocation) return true;
    const distance = calculateHaversineDistance(
      currentLocation.coords.latitude,
      currentLocation.coords.longitude,
      newLoc.coords.latitude,
      newLoc.coords.longitude
    );
    return distance > 5; // 超过5米则认为是显著变化
  };

  // 计算两点间距离（Haversine公式）
  const calculateHaversineDistance = (lat1, lon1, lat2, lon2) => {
    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; // 距离（米）
  };

  return (
    <View style={styles.container}>
      <Text style={styles.status}>{isTracking ? '正在追踪位置' : '追踪已停止'}</Text>
      <Text style={styles.battery}>电池电量: {batteryLevel.toFixed(0)}%</Text>
      {currentLocation && (
        <View style={styles.locationInfo}>
          <Text>纬度: {currentLocation.coords.latitude.toFixed(6)}</Text>
          <Text>经度: {currentLocation.coords.longitude.toFixed(6)}</Text>
          <Text>精度: {currentLocation.coords.accuracy.toFixed(1)}米</Text>
        </View>
      )}
      <View style={styles.buttons}>
        {isTracking ? (
          <Button title="停止追踪" onPress={stopTracking} color="#ff3b30" />
        ) : (
          <Button title="开始追踪" onPress={startTracking} color="#34c759" />
        )}
      </View>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 20,
    justifyContent: 'center',
    alignItems: 'center',
  },
  status: {
    fontSize: 18,
    marginBottom: 10,
    fontWeight: 'bold',
  },
  battery: {
    fontSize: 16,
    color: '#666',
    marginBottom: 20,
  },
  locationInfo: {
    backgroundColor: '#f5f5f5',
    padding: 15,
    borderRadius: 8,
    marginBottom: 20,
    width: '100%',
  },
  buttons: {
    width: '100%',
  }
});

该实现的核心优化点包括：

基于电池电量动态调整定位精度和频率
采用Haversine公式计算实际距离，避免因GPS漂移导致的无效更新
实现显著位置变化检测，减少网络传输和电量消耗
遵循渐进式权限申请策略，提升用户体验

场景二：零售商场的室内位置服务

大型购物中心需要为顾客提供室内导航和店铺定位功能。以下是结合Expo Location和iBeacon技术的实现方案：

import React, { useState, useEffect } from 'react';
import { View, Text, StyleSheet, FlatList, Image } from 'react-native';
import * as Location from 'expo-location';
import * as Permissions from 'expo-permissions';

export default function MallNavigator() {
  const [currentStore, setCurrentStore] = useState(null);
  const [nearbyStores, setNearbyStores] = useState([]);
  const [isScanning, setIsScanning] = useState(false);
  
  // 商场Beacon布局数据
  const beaconLayout = {
    'store-electronics': { uuid: 'B9407F30-F5F8-466E-AFF9-25556B57FE6D', major: 1001, minor: 1, name: '电子数码店', distance: 0 },
    'store-fashion': { uuid: 'B9407F30-F5F8-466E-AFF9-25556B57FE6D', major: 1001, minor: 2, name: '时尚服饰店', distance: 0 },
    'store-food': { uuid: 'B9407F30-F5F8-466E-AFF9-25556B57FE6D', major: 1001, minor: 3, name: '美食广场', distance: 0 },
    'store-book': { uuid: 'B9407F30-F5F8-466E-AFF9-25556B57FE6D', major: 1001, minor: 4, name: '书店', distance: 0 },
  };

  useEffect(() => {
    requestPermissions();
    return () => {
      if (isScanning) {
        stopScanning();
      }
    };
  }, []);

  // 请求权限
  const requestPermissions = async () => {
    const { status } = await Location.requestForegroundPermissionsAsync();
    if (status === 'granted') {
      startScanning();
    }
  };

  // 开始扫描Beacon信号
  const startScanning = async () => {
    setIsScanning(true);
    
    // 配置Beacon区域监测
    const regions = Object.values(beaconLayout).map(beacon => ({
      identifier: beacon.name,
      uuid: beacon.uuid,
      major: beacon.major,
      minor: beacon.minor,
    }));

    // 开始监测Beacon区域
    await Location.startMonitoringBeaconsAsync('MALL_BEACON_REGION', regions);
    
    // 监听Beacon范围变化事件
    Location.addListener('beaconDidEnterRegion', handleBeaconEnter);
    Location.addListener('beaconDidExitRegion', handleBeaconExit);
    Location.addListener('beaconDidRange', handleBeaconRange);
  };

  // 停止扫描
  const stopScanning = async () => {
    await Location.stopMonitoringBeaconsAsync('MALL_BEACON_REGION');
    Location.removeAllListeners('beaconDidEnterRegion');
    Location.removeAllListeners('beaconDidExitRegion');
    Location.removeAllListeners('beaconDidRange');
    setIsScanning(false);
  };

  // 进入Beacon区域处理
  const handleBeaconEnter = (region) => {
    const store = Object.values(beaconLayout).find(
      b => b.name === region.identifier
    );
    if (store) {
      setCurrentStore(store);
      // 显示店铺优惠推送
      showStorePromotion(store);
    }
  };

  // 离开Beacon区域处理
  const handleBeaconExit = (region) => {
    if (currentStore && currentStore.name === region.identifier) {
      setCurrentStore(null);
    }
  };

  // 处理Beacon信号强度变化
  const handleBeaconRange = (data) => {
    // 更新附近店铺距离
    const updatedStores = [...nearbyStores];
    data.beacons.forEach(beacon => {
      const storeId = Object.keys(beaconLayout).find(
        id => beaconLayout[id].major === beacon.major && 
              beaconLayout[id].minor === beacon.minor
      );
      
      if (storeId) {
        const distance = calculateBeaconDistance(beacon.rssi, beacon.txPower);
        const store = { ...beaconLayout[storeId], distance };
        
        // 更新或添加到附近店铺列表
        const index = updatedStores.findIndex(s => s.name === store.name);
        if (index >= 0) {
          updatedStores[index] = store;
        } else {
          updatedStores.push(store);
        }
      }
    });
    
    // 按距离排序
    updatedStores.sort((a, b) => a.distance - b.distance);
    setNearbyStores(updatedStores);
  };

  // 根据信号强度计算距离
  const calculateBeaconDistance = (rssi, txPower) => {
    if (rssi === 0) return -1; // 无法获取信号强度
    
    const ratio = rssi * 1.0 / txPower;
    let distance;
    
    if (ratio < 1.0) {
      distance = Math.pow(ratio, 10);
    } else {
      distance = (0.89976) * Math.pow(ratio, 7.7095) + 0.111;
    }
    
    return distance.toFixed(2); // 保留两位小数
  };

  // 显示店铺优惠推送
  const showStorePromotion = (store) => {
    // 这里可以实现本地通知或弹窗显示店铺优惠信息
    Alert.alert(
      `欢迎来到${store.name}`,
      '出示本通知可享受9折优惠！',
      [{ text: '知道了' }]
    );
  };

  return (
    <View style={styles.container}>
      <Text style={styles.title}>商场导航</Text>
      
      {currentStore && (
        <View style={styles.currentStore}>
          <Image 
            source={require('apps/native-component-list/assets/images/example2.jpg')} 
            style={styles.storeImage}
            alt="当前店铺外观"
          />
          <Text style={styles.currentStoreText}>当前位置: {currentStore.name}</Text>
        </View>
      )}
      
      <Text style={styles.nearbyTitle}>附近店铺:</Text>
      <FlatList
        data={nearbyStores}
        keyExtractor={(item) => item.name}
        renderItem={({ item }) => (
          <View style={styles.storeItem}>
            <Text>{item.name}</Text>
            <Text style={styles.distance}>{item.distance}米</Text>
          </View>
        )}
      />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 20,
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
    marginBottom: 20,
  },
  currentStore: {
    marginBottom: 20,
    padding: 15,
    backgroundColor: '#f0f8ff',
    borderRadius: 8,
    alignItems: 'center',
  },
  storeImage: {
    width: '100%',
    height: 150,
    borderRadius: 4,
    marginBottom: 10,
  },
  currentStoreText: {
    fontSize: 18,
    fontWeight: 'bold',
  },
  nearbyTitle: {
    fontSize: 18,
    marginBottom: 10,
    fontWeight: '500',
  },
  storeItem: {
    flexDirection: 'row',
    justifyContent: 'space-between',
    padding: 12,
    borderBottomWidth: 1,
    borderBottomColor: '#eee',
  },
  distance: {
    color: '#666',
    fontWeight: '500',
  }
});

场景三：物流配送的地理围栏应用

物流配送应用需要在包裹到达特定区域时通知配送员。以下是地理围栏实现方案：

import React, { useState, useEffect } from 'react';
import { View, Text, StyleSheet, Switch, Alert } from 'react-native';
import * as Location from 'expo-location';
import * as TaskManager from 'expo-task-manager';

// 定义地理围栏任务
TaskManager.defineTask('DELIVERY_GEOFENCE_TASK', ({ data, error }) => {
  if (error) {
    console.error('地理围栏错误:', error);
    return;
  }
  
  if (data) {
    const { eventType, region } = data;
    // 发送本地通知
    sendNotification(
      eventType === Location.GeofencingEventType.Enter 
        ? `进入配送区域: ${region.identifier}`
        : `离开配送区域: ${region.identifier}`
    );
  }
});

export default function DeliveryGeofence() {
  const [isMonitoring, setIsMonitoring] = useState(false);
  const [deliveryPoints, setDeliveryPoints] = useState([
    {
      id: 'point1',
      name: '时代广场配送点',
      latitude: 40.7580,
      longitude: -73.9855,
      radius: 100, // 100米半径
      enabled: true
    },
    {
      id: 'point2',
      name: '中央车站配送点',
      latitude: 40.7505,
      longitude: -73.9772,
      radius: 150, // 150米半径
      enabled: true
    }
  ]);

  useEffect(() => {
    checkPermissions();
    return () => {
      if (isMonitoring) {
        stopMonitoring();
      }
    };
  }, []);

  // 检查权限
  const checkPermissions = async () => {
    const { status } = await Location.requestBackgroundPermissionsAsync();
    if (status === 'granted') {
      startMonitoring();
    } else {
      Alert.alert('权限不足', '需要后台位置权限才能使用地理围栏功能');
    }
  };

  // 开始地理围栏监控
  const startMonitoring = async () => {
    // 过滤启用的配送点
    const regions = deliveryPoints
      .filter(point => point.enabled)
      .map(point => ({
        identifier: point.name,
        latitude: point.latitude,
        longitude: point.longitude,
        radius: point.radius,
      }));

    if (regions.length === 0) {
      Alert.alert('无可用区域', '请至少启用一个配送点');
      return;
    }

    // 启动地理围栏监控
    await Location.startGeofencingAsync(
      'DELIVERY_GEOFENCE_TASK',
      regions,
      {
        notifyOnEnter: true,
        notifyOnExit: true,
        notifyOnDwell: false,
      }
    );

    setIsMonitoring(true);
  };

  // 停止地理围栏监控
  const stopMonitoring = async () => {
    await Location.stopGeofencingAsync('DELIVERY_GEOFENCE_TASK');
    setIsMonitoring(false);
  };

  // 切换配送点启用状态
  const toggleDeliveryPoint = (id) => {
    setDeliveryPoints(
      deliveryPoints.map(point => 
        point.id === id ? { ...point, enabled: !point.enabled } : point
      )
    );
    
    // 如果正在监控，需要重启监控以应用更改
    if (isMonitoring) {
      stopMonitoring().then(startMonitoring);
    }
  };

  // 发送本地通知
  const sendNotification = (message) => {
    // 这里可以集成expo-notifications实现本地通知
    console.log('配送通知:', message);
    // 实际应用中应使用Expo Notifications模块
    // Notifications.scheduleNotificationAsync({...});
  };

  return (
    <View style={styles.container}>
      <Text style={styles.title}>配送区域监控</Text>
      
      <View style={styles.monitoringStatus}>
        <Text>监控状态: {isMonitoring ? '已启用' : '已禁用'}</Text>
        <Switch
          value={isMonitoring}
          onValueChange={isMonitoring ? stopMonitoring : startMonitoring}
        />
      </View>
      
      <Text style={styles.pointsTitle}>配送点列表:</Text>
      
      <View style={styles.pointsList}>
        {deliveryPoints.map(point => (
          <View key={point.id} style={styles.pointItem}>
            <View style={styles.pointInfo}>
              <Text style={styles.pointName}>{point.name}</Text>
              <Text style={styles.pointDetails}>
                半径: {point.radius}米 | 坐标: {point.latitude.toFixed(4)}, {point.longitude.toFixed(4)}
              </Text>
            </View>
            <Switch
              value={point.enabled}
              onValueChange={() => toggleDeliveryPoint(point.id)}
            />
          </View>
        ))}
      </View>
      
      <Image 
        source={require('apps/native-component-list/assets/images/example3.jpg')} 
        style={styles.mapImage}
        alt="配送区域地图示意图"
      />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 20,
  },
  title: {
    fontSize: 24,
    fontWeight: 'bold',
    marginBottom: 20,
  },
  monitoringStatus: {
    flexDirection: 'row',
    justifyContent: 'space-between',
    alignItems: 'center',
    marginBottom: 20,
    padding: 10,
    backgroundColor: '#f5f5f5',
    borderRadius: 8,
  },
  pointsTitle: {
    fontSize: 18,
    marginBottom: 10,
    fontWeight: '500',
  },
  pointsList: {
    marginBottom: 20,
  },
  pointItem: {
    flexDirection: 'row',
    justifyContent: 'space-between',
    alignItems: 'center',
    padding: 15,
    borderBottomWidth: 1,
    borderBottomColor: '#eee',
  },
  pointInfo: {
    flex: 1,
  },
  pointName: {
    fontSize: 16,
    fontWeight: '500',
    marginBottom: 4,
  },
  pointDetails: {
    fontSize: 12,
    color: '#666',
  },
  mapImage: {
    width: '100%',
    height: 200,
    borderRadius: 8,
  }
});

性能调优矩阵

定位精度与资源消耗平衡

不同定位场景需要不同的精度设置，以下是常见场景的优化配置：

应用场景	推荐精度	时间间隔	距离间隔	电量消耗	适用场景
导航应用	High (10米)	1-3秒	1-5米	高	驾车导航、步行导航
物流追踪	Balanced (100米)	5-10秒	10-20米	中	外卖配送、快递追踪
签到应用	Low (300米)	按需获取	-	低	商场签到、活动打卡
后台监控	Lowest (1000米)	60-300秒	100-500米	极低	资产管理、人员安全监控

电量优化策略

1. 动态调整定位参数

根据应用状态和用户行为动态调整定位策略：

// 根据应用状态调整定位参数
const adjustLocationStrategy = (appState) => {
  if (appState === 'active') {
    // 应用在前台，使用较高精度
    return {
      accuracy: Location.Accuracy.Balanced,
      timeInterval: 5000,
      distanceInterval: 10
    };
  } else if (appState === 'background') {
    // 应用在后台，降低精度和频率
    return {
      accuracy: Location.Accuracy.Low,
      timeInterval: 60000,
      distanceInterval: 100,
      deferredUpdatesInterval: 300000 // 5分钟强制更新一次
    };
  }
};

2. 批量处理位置数据

减少网络请求次数，批量上传位置数据：

// 批量处理位置数据
class LocationBatchProcessor {
  constructor(batchSize = 10, maxAge = 30000) {
    this.batch = [];
    this.batchSize = batchSize;
    this.maxAge = maxAge; // 30秒
    this.timer = null;
  }
  
  addLocation(location) {
    this.batch.push(location);
    
    // 达到批量大小则立即上传
    if (this.batch.length >= this.batchSize) {
      this.uploadBatch();
    } 
    // 启动定时器，超时后无论批量大小都上传
    else if (!this.timer) {
      this.timer = setTimeout(() => this.uploadBatch(), this.maxAge);
    }
  }
  
  async uploadBatch() {
    if (this.batch.length === 0) return;
    
    try {
      // 取消定时器
      if (this.timer) {
        clearTimeout(this.timer);
        this.timer = null;
      }
      
      // 上传批量数据
      await api.post('/locations/batch', { locations: this.batch });
      
      // 清空批次
      this.batch = [];
    } catch (error) {
      console.error('批量上传位置失败:', error);
      // 失败处理：可以将数据保存到本地，稍后重试
    }
  }
}

// 使用示例
const locationProcessor = new LocationBatchProcessor(10, 30000);
subscription = Location.watchPositionAsync(options, (location) => {
  locationProcessor.addLocation(location);
});

3. 利用地理围栏减少持续定位

对于需要在特定区域触发操作的应用，使用地理围栏替代持续定位：

// 使用地理围栏替代持续定位
const setupGeofenceInsteadOfTracking = async () => {
  // 定义目标区域
  const region = {
    latitude: 39.9042,
    longitude: 116.4074,
    radius: 500, // 500米半径
    identifier: 'target-area'
  };
  
  // 启动地理围栏监控
  await Location.startGeofencingAsync('AREA_MONITOR_TASK', [region], {
    notifyOnEnter: true,
    notifyOnExit: false,
    notifyOnDwell: false,
  });
  
  // 任务中处理进入事件
  TaskManager.defineTask('AREA_MONITOR_TASK', ({ data }) => {
    if (data.eventType === Location.GeofencingEventType.Enter) {
      // 进入目标区域后才开始详细定位
      startPreciseTracking();
      // 停止地理围栏监控
      Location.stopGeofencingAsync('AREA_MONITOR_TASK');
    }
  });
};

常见误区解析

误区一：过度追求高精度定位

许多开发者在所有场景都使用最高精度设置，导致不必要的电量消耗。实际上，大多数应用场景不需要米级精度。

解决方案：根据实际需求选择合适的精度级别，非导航类应用建议使用Balanced或Low精度。

误区二：忽略权限申请时机

在应用启动时就请求所有位置权限，导致用户反感和权限被拒。

解决方案：采用渐进式权限申请策略，在用户需要特定功能时才请求相应权限。

// 错误方式：应用启动时请求所有权限
useEffect(() => {
  // 不推荐：过早请求权限
  Location.requestBackgroundPermissionsAsync();
}, []);

// 正确方式：在用户需要时才请求
const handleStartTracking = async () => {
  const { status } = await Location.requestForegroundPermissionsAsync();
  if (status === 'granted') {
    // 用户同意后才开始功能
    startTracking();
  }
};

误区三：未处理位置服务禁用情况

未检测用户是否禁用了位置服务，导致应用崩溃或功能异常。

解决方案：在使用位置服务前检查位置服务状态：

const checkLocationServices = async () => {
  const enabled = await Location.hasServicesEnabledAsync();
  if (!enabled) {
    Alert.alert(
      '位置服务已关闭',
      '请在系统设置中启用位置服务以使用此功能',
      [
        { text: '取消' },
        { text: '设置', onPress: () => Linking.openSettings() }
      ]
    );
    return false;
  }
  return true;
};

误区四：未处理权限状态变化

用户可能在应用运行时更改权限设置，但应用未检测这些变化。

解决方案：定期检查权限状态或监听权限变化事件：

// 监听权限变化
const subscription = Location.addListener('permissionsDidChange', (event) => {
  if (event.status !== 'granted') {
    setTrackingEnabled(false);
    Alert.alert('权限已被禁用', '请在设置中重新启用位置权限');
  }
});

误区五：忽视平台特性差异

假设Android和iOS的定位行为完全一致，导致跨平台兼容性问题。

解决方案：针对平台特性做特殊处理：

// 平台特定处理
const handlePlatformSpecifics = async () => {
  if (Platform.OS === 'ios') {
    // iOS特有：请求临时高精度定位
    const { status } = await Location.requestTemporaryFullAccuracyAsync(
      '需要高精度定位以提供导航服务'
    );
    if (status !== 'granted') {
      console.warn('iOS高精度定位权限未获得');
    }
  } else if (Platform.OS === 'android') {
    // Android特有：启用网络定位提供器
    await Location.enableNetworkProviderAsync();
  }
};