expo-gaode-map 2.2.6-next.1 → 2.2.6-next.2

package/android/src/main/java/expo/modules/gaodemap/MapPreloadManager.kt

@@ -34,13 +34,27 @@ data class PreloadedMapInstance(
  */
 object MapPreloadManager : ComponentCallbacks2 {
     private const val TAG = "MapPreloadManager"
-    private const val MAX_POOL_SIZE = 3
-    private const val INSTANCE_TTL = 5 * 60 * 1000L // 5分钟过期
+    
+    // 动态池大小配置（根据内存自适应）
+    private const val MAX_POOL_SIZE_HIGH_MEMORY = 3      // 高内存设备：>= 500MB
+    private const val MAX_POOL_SIZE_MEDIUM_MEMORY = 2    // 中等内存：300-500MB
+    private const val MAX_POOL_SIZE_LOW_MEMORY = 1       // 低内存设备：150-300MB
+    private const val MIN_MEMORY_THRESHOLD_MB = 150      // 最低内存要求
+    
+    // 动态 TTL 配置（根据内存压力自适应）
+    private const val TTL_NORMAL = 5 * 60 * 1000L        // 正常：5分钟
+    private const val TTL_MEMORY_PRESSURE = 2 * 60 * 1000L  // 内存压力：2分钟
+    private const val TTL_LOW_MEMORY = 1 * 60 * 1000L    // 低内存：1分钟
     
     private val preloadedMapViews = ConcurrentLinkedQueue<PreloadedMapInstance>()
     private val isPreloading = AtomicBoolean(false)
     private val preloadScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     
+    // 动态配置
+    @Volatile private var currentMaxPoolSize = MAX_POOL_SIZE_MEDIUM_MEMORY
+    @Volatile private var currentTTL = TTL_NORMAL
+    @Volatile private var memoryPressureLevel = 0  // 0=正常, 1=压力, 2=严重
+    
     // 性能统计
     private val totalPreloads = AtomicInteger(0)
     private val successfulPreloads = AtomicInteger(0)
@@ -83,7 +97,7 @@ object MapPreloadManager : ComponentCallbacks2 {
     }
     
     /**
-     * 清理过期的预加载实例
+     * 清理过期的预加载实例（使用动态 TTL）
      */
     private fun cleanupExpiredInstances() {
         val now = System.currentTimeMillis()
@@ -92,7 +106,8 @@ object MapPreloadManager : ComponentCallbacks2 {
         val iterator = preloadedMapViews.iterator()
         while (iterator.hasNext()) {
             val instance = iterator.next()
-            if (now - instance.timestamp > INSTANCE_TTL) {
+            // 使用动态 TTL
+            if (now - instance.timestamp > currentTTL) {
                 try {
                     instance.mapView.onDestroy()
                     iterator.remove()
@@ -105,7 +120,7 @@ object MapPreloadManager : ComponentCallbacks2 {
         
         if (expiredCount > 0) {
             instancesExpired.addAndGet(expiredCount)
-            Log.i(TAG, "🧹 清理了 $expiredCount 个过期实例（总计: ${instancesExpired.get()}）")
+            Log.i(TAG, "🧹 清理了 $expiredCount 个过期实例（总计: ${instancesExpired.get()}，当前TTL: ${currentTTL/1000}秒）")
         }
     }
     
@@ -144,9 +159,9 @@ object MapPreloadManager : ComponentCallbacks2 {
     }
     
     /**
-     * 开始预加载地图实例
+     * 开始预加载地图实例（自适应版本）
      * @param context Android 上下文
-     * @param poolSize 预加载的地图实例数量
+     * @param poolSize 预加载的地图实例数量（会根据内存自适应调整）
      */
     fun startPreload(context: Context, poolSize: Int) {
         if (isPreloading.get()) {
@@ -154,6 +169,13 @@ object MapPreloadManager : ComponentCallbacks2 {
             return
         }
         
+        // 动态计算最优池大小
+        val adaptiveMaxPoolSize = calculateAdaptivePoolSize(context)
+        currentMaxPoolSize = adaptiveMaxPoolSize
+        
+        // 动态调整 TTL
+        currentTTL = calculateAdaptiveTTL(context)
+        
         // 检查内存是否充足
         if (!hasEnoughMemory(context)) {
             Log.w(TAG, "⚠️ 内存不足，跳过预加载")
@@ -161,8 +183,8 @@ object MapPreloadManager : ComponentCallbacks2 {
         }
         
         isPreloading.set(true)
-        val targetSize = minOf(poolSize, MAX_POOL_SIZE)
-        Log.i(TAG, "🚀 开始预加载 $targetSize 个地图实例")
+        val targetSize = minOf(poolSize, adaptiveMaxPoolSize)
+        Log.i(TAG, "🚀 开始预加载 $targetSize 个地图实例 (自适应池大小: $adaptiveMaxPoolSize, TTL: ${currentTTL/1000}秒)")
         
         val startTime = System.currentTimeMillis()
         totalPreloads.incrementAndGet()
@@ -208,16 +230,86 @@ object MapPreloadManager : ComponentCallbacks2 {
     }
     
     /**
-     * 检查是否有足够的内存
+     * 计算自适应池大小
+     * 根据可用内存动态调整池大小
      */
-    private fun hasEnoughMemory(context: Context): Boolean {
+    private fun calculateAdaptivePoolSize(context: Context): Int {
+        val availableMB = getAvailableMemoryMB(context)
+        
+        return when {
+            availableMB >= 500 -> {
+                Log.i(TAG, "📊 高内存设备 (${availableMB}MB)，池大小: $MAX_POOL_SIZE_HIGH_MEMORY")
+                MAX_POOL_SIZE_HIGH_MEMORY
+            }
+            availableMB >= 300 -> {
+                Log.i(TAG, "📊 中等内存设备 (${availableMB}MB)，池大小: $MAX_POOL_SIZE_MEDIUM_MEMORY")
+                MAX_POOL_SIZE_MEDIUM_MEMORY
+            }
+            availableMB >= 150 -> {
+                Log.i(TAG, "📊 低内存设备 (${availableMB}MB)，池大小: $MAX_POOL_SIZE_LOW_MEMORY")
+                MAX_POOL_SIZE_LOW_MEMORY
+            }
+            else -> {
+                Log.w(TAG, "⚠️ 内存极低 (${availableMB}MB)，禁用预加载")
+                0
+            }
+        }
+    }
+    
+    /**
+     * 计算自适应 TTL
+     * 根据内存压力动态调整过期时间
+     */
+    private fun calculateAdaptiveTTL(context: Context): Long {
+        val availableMB = getAvailableMemoryMB(context)
+        val totalMB = getTotalMemoryMB(context)
+        val usagePercent = ((totalMB - availableMB).toFloat() / totalMB * 100).toInt()
+        
+        return when {
+            usagePercent < 60 -> {
+                memoryPressureLevel = 0
+                Log.i(TAG, "📊 内存充足 (使用率: $usagePercent%)，TTL: ${TTL_NORMAL/1000}秒")
+                TTL_NORMAL
+            }
+            usagePercent < 80 -> {
+                memoryPressureLevel = 1
+                Log.i(TAG, "📊 内存压力 (使用率: $usagePercent%)，TTL: ${TTL_MEMORY_PRESSURE/1000}秒")
+                TTL_MEMORY_PRESSURE
+            }
+            else -> {
+                memoryPressureLevel = 2
+                Log.w(TAG, "⚠️ 内存严重不足 (使用率: $usagePercent%)，TTL: ${TTL_LOW_MEMORY/1000}秒")
+                TTL_LOW_MEMORY
+            }
+        }
+    }
+    
+    /**
+     * 获取可用内存（MB）
+     */
+    private fun getAvailableMemoryMB(context: Context): Long {
         val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
         val memoryInfo = ActivityManager.MemoryInfo()
         activityManager?.getMemoryInfo(memoryInfo)
-        
-        // 如果可用内存低于 100MB，不进行预加载
-        val availableMB = memoryInfo.availMem / (1024 * 1024)
-        return availableMB > 100
+        return memoryInfo.availMem / (1024 * 1024)
+    }
+    
+    /**
+     * 获取总内存（MB）
+     */
+    private fun getTotalMemoryMB(context: Context): Long {
+        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+        val memoryInfo = ActivityManager.MemoryInfo()
+        activityManager?.getMemoryInfo(memoryInfo)
+        return memoryInfo.totalMem / (1024 * 1024)
+    }
+    
+    /**
+     * 检查是否有足够的内存
+     */
+    private fun hasEnoughMemory(context: Context): Boolean {
+        val availableMB = getAvailableMemoryMB(context)
+        return availableMB > MIN_MEMORY_THRESHOLD_MB
     }
     
     /**
@@ -257,22 +349,22 @@ object MapPreloadManager : ComponentCallbacks2 {
     }
     
     /**
-     * 获取一个预加载的地图实例
+     * 获取一个预加载的地图实例（使用动态 TTL）
      * @return 预加载的地图视图，如果池为空则返回 null
      */
     fun getPreloadedMapView(): MapView? {
         val now = System.currentTimeMillis()
         
-        // 检查并移除过期实例
+        // 检查并移除过期实例（使用动态 TTL）
         while (true) {
             val instance = preloadedMapViews.peek() ?: break
             
-            if (now - instance.timestamp > INSTANCE_TTL) {
+            if (now - instance.timestamp > currentTTL) {
                 preloadedMapViews.poll()
                 try {
                     instance.mapView.onDestroy()
                     instancesExpired.incrementAndGet()
-                    Log.i(TAG, "🗑️ 预加载实例已过期，已删除")
+                    Log.i(TAG, "🗑️ 预加载实例已过期（TTL: ${currentTTL/1000}秒），已删除")
                 } catch (e: Exception) {
                     Log.e(TAG, "清理过期实例失败: ${e.message}", e)
                 }
@@ -316,14 +408,17 @@ object MapPreloadManager : ComponentCallbacks2 {
     }
     
     /**
-     * 获取预加载状态
+     * 获取预加载状态（包含动态配置信息）
      * @return 预加载状态信息
      */
     fun getStatus(): Map<String, Any> {
         return mapOf(
             "poolSize" to preloadedMapViews.size,
             "isPreloading" to isPreloading.get(),
-            "maxPoolSize" to MAX_POOL_SIZE
+            "maxPoolSize" to currentMaxPoolSize,
+            "currentTTL" to currentTTL,
+            "memoryPressureLevel" to memoryPressureLevel,
+            "isAdaptive" to true
         )
     }
     
@@ -336,7 +431,7 @@ object MapPreloadManager : ComponentCallbacks2 {
     }
     
     /**
-     * 获取性能统计信息
+     * 获取性能统计信息（包含内存信息）
      */
     fun getPerformanceMetrics(): Map<String, Any> {
         val total = totalPreloads.get()
@@ -344,6 +439,10 @@ object MapPreloadManager : ComponentCallbacks2 {
         val avgDuration = if (successful > 0) totalDuration.get() / successful else 0
         val successRate = if (total > 0) (successful.toFloat() / total * 100) else 0f
         
+        val availableMB = appContext?.let { getAvailableMemoryMB(it) } ?: 0
+        val totalMB = appContext?.let { getTotalMemoryMB(it) } ?: 0
+        val usagePercent = if (totalMB > 0) ((totalMB - availableMB).toFloat() / totalMB * 100).toInt() else 0
+        
         return mapOf(
             "totalPreloads" to total,
             "successfulPreloads" to successful,
@@ -351,7 +450,13 @@ object MapPreloadManager : ComponentCallbacks2 {
             "averageDuration" to avgDuration,
             "instancesUsed" to instancesUsed.get(),
             "instancesExpired" to instancesExpired.get(),
-            "successRate" to successRate
+            "successRate" to successRate,
+            "currentMaxPoolSize" to currentMaxPoolSize,
+            "currentTTL" to currentTTL,
+            "memoryPressureLevel" to memoryPressureLevel,
+            "availableMemoryMB" to availableMB,
+            "totalMemoryMB" to totalMB,
+            "memoryUsagePercent" to usagePercent
         )
     }
     

package/android/src/main/java/expo/modules/gaodemap/managers/UIManager.kt

@@ -172,6 +172,30 @@ class UIManager(private val aMap: AMap, private val context: Context) : Location
     
     val style = currentLocationStyle!!
     
+    // 定位蓝点展现模式 (locationType) - Android 支持8种模式
+    val locationType = config["locationType"] as? String
+    if (locationType != null) {
+      val locationTypeValue = when (locationType) {
+        "SHOW" -> MyLocationStyle.LOCATION_TYPE_SHOW
+        "LOCATE" -> MyLocationStyle.LOCATION_TYPE_LOCATE
+        "FOLLOW" -> MyLocationStyle.LOCATION_TYPE_FOLLOW
+        "MAP_ROTATE" -> MyLocationStyle.LOCATION_TYPE_MAP_ROTATE
+        "LOCATION_ROTATE" -> MyLocationStyle.LOCATION_TYPE_LOCATION_ROTATE
+        "LOCATION_ROTATE_NO_CENTER" -> MyLocationStyle.LOCATION_TYPE_LOCATION_ROTATE_NO_CENTER
+        "FOLLOW_NO_CENTER" -> MyLocationStyle.LOCATION_TYPE_FOLLOW_NO_CENTER
+        "MAP_ROTATE_NO_CENTER" -> MyLocationStyle.LOCATION_TYPE_MAP_ROTATE_NO_CENTER
+        else -> MyLocationStyle.LOCATION_TYPE_LOCATION_ROTATE // 默认值
+      }
+      style.myLocationType(locationTypeValue)
+    }
+    
+    // 是否显示定位蓝点 (showMyLocation) - Android 5.1.0+ 支持
+    // 注意：这个属性在 iOS 中没有对应项，是 Android 特有的
+    val showMyLocation = config["showMyLocation"] as? Boolean
+    if (showMyLocation != null) {
+      style.showMyLocation(showMyLocation)
+    }
+    
     // 是否显示精度圈 (showsAccuracyRing) - 先处理这个，设置默认值
     val showsAccuracyRing = config["showsAccuracyRing"] as? Boolean ?: true
     if (!showsAccuracyRing) {
@@ -198,6 +222,13 @@ class UIManager(private val aMap: AMap, private val context: Context) : Location
       }
     }
     
+    // 定位图标锚点 (anchor) - Android 支持
+    val anchorU = config["anchorU"] as? Number
+    val anchorV = config["anchorV"] as? Number
+    if (anchorU != null && anchorV != null) {
+      style.anchor(anchorU.toFloat(), anchorV.toFloat())
+    }
+    
     // 自定义图标 (image)
     val imagePath = config["image"] as? String
     if (imagePath != null && imagePath.isNotEmpty()) {
@@ -316,4 +347,47 @@ class UIManager(private val aMap: AMap, private val context: Context) : Location
       else -> AMap.MAP_TYPE_NORMAL  // 标准地图
     }
   }
+  
+  // ==================== 自定义地图样式 ====================
+  
+  /**
+   * 设置自定义地图样式
+   * @param styleData 样式数据，支持以下格式：
+   *   - styleId: String - 在线样式ID（从高德开放平台获取）
+   *   - styleDataPath: String - 本地样式文件路径
+   *   - extraStyleDataPath: String - 额外样式文件路径（可选）
+   */
+  fun setCustomMapStyle(styleData: Map<String, Any>) {
+    // 在线样式 ID
+    val styleId = styleData["styleId"] as? String
+    if (!styleId.isNullOrEmpty()) {
+      val options = com.amap.api.maps.model.CustomMapStyleOptions()
+      options.isEnable = true
+      options.styleId = styleId
+      aMap.setCustomMapStyle(options)
+      return
+    }
+    
+    // 本地样式文件
+    val styleDataPath = styleData["styleDataPath"] as? String
+    if (!styleDataPath.isNullOrEmpty()) {
+      val options = com.amap.api.maps.model.CustomMapStyleOptions()
+      options.isEnable = true
+      options.styleDataPath = styleDataPath
+      
+      // 额外样式文件（可选）
+      val extraPath = styleData["extraStyleDataPath"] as? String
+      if (!extraPath.isNullOrEmpty()) {
+        options.styleExtraPath = extraPath
+      }
+      
+      aMap.setCustomMapStyle(options)
+      return
+    }
+    
+    // 如果没有提供任何样式，禁用自定义样式
+    val options = com.amap.api.maps.model.CustomMapStyleOptions()
+    options.isEnable = false
+    aMap.setCustomMapStyle(options)
+  }
 }

package/android/src/main/java/expo/modules/gaodemap/modules/SDKInitializer.kt

@@ -17,75 +17,27 @@ import com.amap.api.maps.MapsInitializer
 object SDKInitializer {
     
     /** 隐私协议是否已同意（进程内缓存） */
-    private var privacyAgreed = false
+    private var privacyAgreed = true
 
     private const val PREFS_NAME = "expo_gaode_map_prefs"
-    private const val KEY_PRIVACY_AGREED = "privacy_agreed"
 
     private fun prefs(context: Context): SharedPreferences =
         context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
     
-    /**
-     * 更新隐私合规状态
-     * 必须在用户同意隐私协议后调用
-     *
-     * @param context 应用上下文
-     * @param hasAgreed 用户是否已同意隐私协议
-     */
-    fun updatePrivacyCompliance(context: Context, hasAgreed: Boolean) {
-        privacyAgreed = hasAgreed
-        
-        // 先更新隐私信息显示状态
-        MapsInitializer.updatePrivacyShow(context, true, true)
-        AMapLocationClient.updatePrivacyShow(context, true, true)
-        
-        // 根据用户选择更新同意状态
-        if (hasAgreed) {
-            MapsInitializer.updatePrivacyAgree(context, true)
-            AMapLocationClient.updatePrivacyAgree(context, true)
-            android.util.Log.d("ExpoGaodeMap", "✅ 用户已同意隐私协议，可以使用 SDK")
-        } else {
-            MapsInitializer.updatePrivacyAgree(context, false)
-            AMapLocationClient.updatePrivacyAgree(context, false)
-            android.util.Log.w("ExpoGaodeMap", "⚠️ 用户未同意隐私协议，SDK 功能将受限")
-        }
 
-        // 持久化状态，供下次启动自动恢复
-        try {
-            prefs(context).edit().putBoolean(KEY_PRIVACY_AGREED, hasAgreed).apply()
-        } catch (e: Exception) {
-            android.util.Log.w("ExpoGaodeMap", "持久化隐私状态失败: ${e.message}")
-        }
-    }
     
-    /**
-     * 从本地存储恢复隐私合规状态（在应用启动或模块加载时调用）
-     * 若无记录则保持默认 false，不抛出异常。
-     */
     fun restorePrivacyState(context: Context) {
         try {
-            val saved = prefs(context).getBoolean(KEY_PRIVACY_AGREED, false)
-            privacyAgreed = saved
-
             // 同步到 SDK
             MapsInitializer.updatePrivacyShow(context, true, true)
             AMapLocationClient.updatePrivacyShow(context, true, true)
-            MapsInitializer.updatePrivacyAgree(context, saved)
-            AMapLocationClient.updatePrivacyAgree(context, saved)
-
-            android.util.Log.d("ExpoGaodeMap", "🔁 已从缓存恢复隐私状态: $saved")
+            MapsInitializer.updatePrivacyAgree(context, privacyAgreed)
+            AMapLocationClient.updatePrivacyAgree(context, privacyAgreed)
         } catch (e: Exception) {
             android.util.Log.w("ExpoGaodeMap", "恢复隐私状态失败: ${e.message}")
         }
     }
 
-    /**
-     * 检查隐私协议是否已同意
-     *
-     * @return 是否已同意隐私协议
-     */
-    fun isPrivacyAgreed(): Boolean = privacyAgreed
-
     /**
      * 初始化高德地图和定位 SDK
      *

package/android/src/main/java/expo/modules/gaodemap/utils/PermissionHelper.kt

@@ -0,0 +1,247 @@
+package expo.modules.gaodemap.utils
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+
+/**
+ * Android 14+ 权限适配助手
+ * 
+ * 主要变化：
+ * 1. Android 14 (API 34) 引入了更精细的位置权限
+ * 2. 需要同时请求前台和后台位置权限
+ * 3. 权限请求流程更加严格
+ */
+object PermissionHelper {
+    
+    /**
+     * 位置权限类型
+     */
+    enum class LocationPermissionType {
+        FOREGROUND,      // 仅前台位置
+        BACKGROUND,      // 后台位置
+        FOREGROUND_AND_BACKGROUND  // 前台+后台
+    }
+    
+    /**
+     * 权限状态
+     */
+    data class PermissionStatus(
+        val granted: Boolean,
+        val shouldShowRationale: Boolean,
+        val isPermanentlyDenied: Boolean,
+        val fineLocation: Boolean = false,
+        val coarseLocation: Boolean = false,
+        val backgroundLocation: Boolean = false
+    )
+    
+    /**
+     * 检查是否为 Android 14+
+     */
+    fun isAndroid14Plus(): Boolean {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE // API 34
+    }
+    
+    /**
+     * 检查是否为 Android 10+（引入后台位置权限）
+     */
+    fun isAndroid10Plus(): Boolean {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q // API 29
+    }
+    
+    /**
+     * 获取需要请求的前台位置权限列表
+     */
+    fun getForegroundLocationPermissions(): Array<String> {
+        return arrayOf(
+            Manifest.permission.ACCESS_FINE_LOCATION,
+            Manifest.permission.ACCESS_COARSE_LOCATION
+        )
+    }
+    
+    /**
+     * 获取后台位置权限
+     */
+    fun getBackgroundLocationPermission(): String? {
+        return if (isAndroid10Plus()) {
+            Manifest.permission.ACCESS_BACKGROUND_LOCATION
+        } else {
+            null
+        }
+    }
+    
+    /**
+     * 检查前台位置权限状态
+     */
+    fun checkForegroundLocationPermission(context: Context): PermissionStatus {
+        val fineGranted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+        
+        val coarseGranted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.ACCESS_COARSE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+        
+        val granted = fineGranted && coarseGranted
+        
+        val activity = context as? Activity
+        val shouldShowRationale = if (activity != null && !granted) {
+            ActivityCompat.shouldShowRequestPermissionRationale(
+                activity,
+                Manifest.permission.ACCESS_FINE_LOCATION
+            )
+        } else {
+            false
+        }
+        
+        return PermissionStatus(
+            granted = granted,
+            shouldShowRationale = shouldShowRationale,
+            isPermanentlyDenied = !granted && !shouldShowRationale && activity != null,
+            fineLocation = fineGranted,
+            coarseLocation = coarseGranted
+        )
+    }
+    
+    /**
+     * 检查后台位置权限状态
+     */
+    fun checkBackgroundLocationPermission(context: Context): PermissionStatus {
+        val permission = getBackgroundLocationPermission()
+        if (permission == null) {
+            // Android 10 以下不支持后台位置权限
+            return PermissionStatus(
+                granted = true,
+                shouldShowRationale = false,
+                isPermanentlyDenied = false,
+                backgroundLocation = true
+            )
+        }
+        
+        val granted = ContextCompat.checkSelfPermission(
+            context,
+            permission
+        ) == PackageManager.PERMISSION_GRANTED
+        
+        val activity = context as? Activity
+        val shouldShowRationale = if (activity != null && !granted) {
+            ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)
+        } else {
+            false
+        }
+        
+        return PermissionStatus(
+            granted = granted,
+            shouldShowRationale = shouldShowRationale,
+            isPermanentlyDenied = !granted && !shouldShowRationale && activity != null,
+            backgroundLocation = granted
+        )
+    }
+    
+    /**
+     * 检查完整位置权限状态（前台+后台）
+     */
+    fun checkFullLocationPermission(context: Context): PermissionStatus {
+        val foreground = checkForegroundLocationPermission(context)
+        val background = checkBackgroundLocationPermission(context)
+        
+        return PermissionStatus(
+            granted = foreground.granted && background.granted,
+            shouldShowRationale = foreground.shouldShowRationale || background.shouldShowRationale,
+            isPermanentlyDenied = foreground.isPermanentlyDenied || background.isPermanentlyDenied,
+            fineLocation = foreground.fineLocation,
+            coarseLocation = foreground.coarseLocation,
+            backgroundLocation = background.backgroundLocation
+        )
+    }
+    
+    /**
+     * 请求前台位置权限
+     * Android 14+ 推荐的请求流程
+     */
+    fun requestForegroundLocationPermission(activity: Activity, requestCode: Int) {
+        val permissions = getForegroundLocationPermissions()
+        ActivityCompat.requestPermissions(activity, permissions, requestCode)
+    }
+    
+    /**
+     * 请求后台位置权限
+     * 注意：必须在前台权限已授予后才能请求
+     */
+    fun requestBackgroundLocationPermission(activity: Activity, requestCode: Int): Boolean {
+        val permission = getBackgroundLocationPermission()
+        if (permission == null) {
+            return false
+        }
+        
+        // 检查前台权限是否已授予
+        val foregroundStatus = checkForegroundLocationPermission(activity)
+        if (!foregroundStatus.granted) {
+            return false
+        }
+        
+        ActivityCompat.requestPermissions(activity, arrayOf(permission), requestCode)
+        return true
+    }
+    
+    /**
+     * 打开应用设置页面
+     * 用于引导用户手动授予权限
+     */
+    fun openAppSettings(context: Context) {
+        val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+            data = Uri.fromParts("package", context.packageName, null)
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK
+        }
+        context.startActivity(intent)
+    }
+    
+    /**
+     * 获取权限请求的推荐提示文案（Android 14+ 优化）
+     */
+    fun getPermissionRationale(
+        type: LocationPermissionType,
+        isAndroid14: Boolean = isAndroid14Plus()
+    ): String {
+        return when (type) {
+            LocationPermissionType.FOREGROUND -> {
+                if (isAndroid14) {
+                    "为了在地图上显示您的位置，应用需要访问您的位置信息。\n\n" +
+                    "您可以选择：\n" +
+                    "• 仅在使用应用时允许\n" +
+                    "• 每次询问\n\n" +
+                    "我们不会在后台收集您的位置数据。"
+                } else {
+                    "为了在地图上显示您的位置，应用需要访问您的位置信息。"
+                }
+            }
+            LocationPermissionType.BACKGROUND -> {
+                if (isAndroid14) {
+                    "为了在后台更新您的位置（如导航、轨迹记录），应用需要始终访问位置权限。\n\n" +
+                    "您可以随时在设置中更改此权限。"
+                } else {
+                    "为了在后台更新您的位置，应用需要始终访问位置权限。"
+                }
+            }
+            LocationPermissionType.FOREGROUND_AND_BACKGROUND -> {
+                if (isAndroid14) {
+                    "应用需要位置权限来提供以下功能：\n" +
+                    "• 在地图上显示您的位置（前台）\n" +
+                    "• 后台导航和轨迹记录（后台）\n\n" +
+                    "我们会先请求前台权限，然后再请求后台权限。"
+                } else {
+                    "应用需要位置权限来显示地图位置和后台导航功能。"
+                }
+            }
+        }
+    }
+}