expo-gaode-map 2.2.8-next.0 → 2.2.8

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

@@ -4,6 +4,7 @@ import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.gaodemap.modules.SDKInitializer
 import expo.modules.gaodemap.modules.LocationManager
+import expo.modules.gaodemap.utils.PermissionHelper
 
 /**
  * 高德地图 Expo 模块
@@ -30,14 +31,12 @@ class ExpoGaodeMapModule : Module() {
       // 初始化预加载管理器（注册内存监听）
       MapPreloadManager.initialize(context)
       
-      // 🚀 如果用户已同意隐私协议，自动启动预加载（延迟2秒）
-      if (SDKInitializer.isPrivacyAgreed()) {
-        // 尝试从 AndroidManifest.xml 读取并设置 API Key
-        val apiKey = context.packageManager
+      // 尝试从 AndroidManifest.xml 读取并设置 API Key
+      val apiKey = context.packageManager
           .getApplicationInfo(context.packageName, android.content.pm.PackageManager.GET_META_DATA)
           .metaData?.getString("com.amap.api.v2.apikey")
         
-        if (!apiKey.isNullOrEmpty()) {
+      if (!apiKey.isNullOrEmpty()) {
           try {
             com.amap.api.maps.MapsInitializer.setApiKey(apiKey)
             com.amap.api.location.AMapLocationClient.setApiKey(apiKey)
@@ -54,57 +53,28 @@ class ExpoGaodeMapModule : Module() {
         } else {
           android.util.Log.w("ExpoGaodeMap", "⚠️ AndroidManifest.xml 未找到 API Key，跳过自动预加载")
         }
-      }
+
     } catch (e: Exception) {
       android.util.Log.w("ExpoGaodeMap", "恢复隐私状态时出现问题: ${e.message}")
     }
  
-    // ==================== 隐私合规管理 ====================
+    // ==================== 隐私协议 ====================
     
     /**
      * 更新隐私合规状态
-     * 必须在用户同意隐私协议后调用
-     * @param hasAgreed 用户是否已同意隐私协议
+     * 不用主动调用，下个版本删除
+     * 
      */
     Function("updatePrivacyCompliance") { hasAgreed: Boolean ->
-      val context = appContext.reactContext!!
-      SDKInitializer.updatePrivacyCompliance(context, hasAgreed)
-      
-      // 🚀 用户首次同意隐私协议后，自动启动预加载
-      if (hasAgreed) {
-        // 在用户同意后，如果尚未设置 API Key，则尝试从 AndroidManifest.xml 读取并设置
-        try {
-          val apiKey = context.packageManager
-            .getApplicationInfo(context.packageName, android.content.pm.PackageManager.GET_META_DATA)
-            .metaData?.getString("com.amap.api.v2.apikey")
-          
-          if (!apiKey.isNullOrEmpty()) {
-            com.amap.api.maps.MapsInitializer.setApiKey(apiKey)
-            com.amap.api.location.AMapLocationClient.setApiKey(apiKey)
-            android.util.Log.d("ExpoGaodeMap", "✅ 从 AndroidManifest.xml 读取并设置 API Key 成功")
-          } else {
-            android.util.Log.w("ExpoGaodeMap", "⚠️ AndroidManifest.xml 未找到 API Key，后续需通过 initSDK 提供 androidKey")
-          }
-        } catch (e: Exception) {
-          android.util.Log.w("ExpoGaodeMap", "读取 API Key 失败: ${e.message}")
-        }
-        
-        // 延迟启动预加载
-        android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
-          if (!MapPreloadManager.hasPreloadedMapView() &&
-              !(MapPreloadManager.getStatus()["isPreloading"] as Boolean)) {
-            android.util.Log.i("ExpoGaodeMap", "🚀 用户同意隐私协议，自动启动预加载")
-            MapPreloadManager.startPreload(context, poolSize = 1)
-          }
-        }, 1000)
-      }
+       val context = appContext.reactContext!!
+       SDKInitializer.restorePrivacyState(context)
     }
     
     // ==================== SDK 初始化 ====================
     
     /**
      * 初始化 SDK（地图 + 定位）
-     * @param config 配置对象,包含 androidKey
+     * @config 配置对象,包含 androidKey
      */
     Function("initSDK") { config: Map<String, String> ->
       val androidKey = config["androidKey"]
@@ -136,12 +106,7 @@ class ExpoGaodeMapModule : Module() {
      * 开始连续定位
      */
     Function("start") {
-      // 检查隐私协议状态
-      if (!SDKInitializer.isPrivacyAgreed()) {
-        android.util.Log.w("ExpoGaodeMap", "用户未同意隐私协议，无法开始定位")
-        throw expo.modules.kotlin.exception.CodedException("用户未同意隐私协议，无法开始定位")
-      }
-      
+
       getLocationManager().start()
     }
     
@@ -165,12 +130,6 @@ class ExpoGaodeMapModule : Module() {
      * @return 位置信息对象
      */
     AsyncFunction("getCurrentLocation") { promise: expo.modules.kotlin.Promise ->
-      // 检查隐私协议状态
-      if (!SDKInitializer.isPrivacyAgreed()) {
-        promise.reject("PRIVACY_NOT_AGREED", "用户未同意隐私协议，无法获取位置", null)
-        return@AsyncFunction
-      }
-      
       getLocationManager().getCurrentLocation(promise)
     }
 
@@ -331,31 +290,50 @@ class ExpoGaodeMapModule : Module() {
       // 未实现
     }
 
+    /**
+     * 开始更新设备方向 (iOS 专用,Android 空实现)
+     * Android 不支持此功能
+     */
+    Function("startUpdatingHeading") {
+      // Android 不支持罗盘方向更新
+      android.util.Log.d("ExpoGaodeMap", "startUpdatingHeading: iOS 专用功能，Android 不支持")
+    }
+
+    /**
+     * 停止更新设备方向 (iOS 专用,Android 空实现)
+     * Android 不支持此功能
+     */
+    Function("stopUpdatingHeading") {
+      // Android 不支持罗盘方向更新
+      android.util.Log.d("ExpoGaodeMap", "stopUpdatingHeading: iOS 专用功能，Android 不支持")
+    }
+
     // ==================== 权限管理 ====================
     
     /**
-     * 检查位置权限状态
-     * @return 权限状态对象
+     * 检查位置权限状态（增强版，支持 Android 14+ 适配）
+     * @return 权限状态对象，包含详细的权限信息
      */
     AsyncFunction("checkLocationPermission") { promise: expo.modules.kotlin.Promise ->
       val context = appContext.reactContext!!
-      val fineLocation = android.Manifest.permission.ACCESS_FINE_LOCATION
-      val coarseLocation = android.Manifest.permission.ACCESS_COARSE_LOCATION
       
-      val hasFine = androidx.core.content.ContextCompat.checkSelfPermission(context, fineLocation) ==
-        android.content.pm.PackageManager.PERMISSION_GRANTED
-      val hasCoarse = androidx.core.content.ContextCompat.checkSelfPermission(context, coarseLocation) ==
-        android.content.pm.PackageManager.PERMISSION_GRANTED
+      // 使用增强的权限检查
+      val foregroundStatus = PermissionHelper.checkForegroundLocationPermission(context)
+      val backgroundStatus = PermissionHelper.checkBackgroundLocationPermission(context)
       
       promise.resolve(mapOf(
-        "granted" to (hasFine && hasCoarse),
-        "fineLocation" to hasFine,
-        "coarseLocation" to hasCoarse
+        "granted" to foregroundStatus.granted,
+        "fineLocation" to foregroundStatus.fineLocation,
+        "coarseLocation" to foregroundStatus.coarseLocation,
+        "backgroundLocation" to backgroundStatus.backgroundLocation,
+        "shouldShowRationale" to foregroundStatus.shouldShowRationale,
+        "isPermanentlyDenied" to foregroundStatus.isPermanentlyDenied,
+        "isAndroid14Plus" to PermissionHelper.isAndroid14Plus()
       ))
     }
     
     /**
-     * 请求位置权限
+     * 请求前台位置权限（增强版，支持 Android 14+ 适配）
      * 注意: Android 权限请求是异步的,使用轮询方式检查权限状态
      * @return 权限请求结果
      */
@@ -366,18 +344,14 @@ class ExpoGaodeMapModule : Module() {
         return@AsyncFunction
       }
       
-      val permissions = arrayOf(
-        android.Manifest.permission.ACCESS_FINE_LOCATION,
-        android.Manifest.permission.ACCESS_COARSE_LOCATION
-      )
-      
-      androidx.core.app.ActivityCompat.requestPermissions(activity, permissions, 1001)
+      // 使用增强的权限请求方法
+      PermissionHelper.requestForegroundLocationPermission(activity, 1001)
       
       // 使用 WeakReference 避免内存泄露
       val contextRef = java.lang.ref.WeakReference(appContext.reactContext)
       val handler = android.os.Handler(android.os.Looper.getMainLooper())
       var attempts = 0
-      val maxAttempts = 30 // 3 秒 / 100ms
+      val maxAttempts = 50 // 增加到 5 秒 / 100ms，给用户足够时间操作
       
       val checkPermission = object : Runnable {
         override fun run() {
@@ -387,20 +361,85 @@ class ExpoGaodeMapModule : Module() {
             return
           }
           
-          val hasFine = androidx.core.content.ContextCompat.checkSelfPermission(
-            context, android.Manifest.permission.ACCESS_FINE_LOCATION
-          ) == android.content.pm.PackageManager.PERMISSION_GRANTED
-          val hasCoarse = androidx.core.content.ContextCompat.checkSelfPermission(
-            context, android.Manifest.permission.ACCESS_COARSE_LOCATION
-          ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+          val status = PermissionHelper.checkForegroundLocationPermission(context)
           
           // 如果权限已授予或达到最大尝试次数,返回结果并清理 Handler
-          if ((hasFine && hasCoarse) || attempts >= maxAttempts) {
+          if (status.granted || attempts >= maxAttempts) {
+            handler.removeCallbacks(this)
+            promise.resolve(mapOf(
+              "granted" to status.granted,
+              "fineLocation" to status.fineLocation,
+              "coarseLocation" to status.coarseLocation,
+              "shouldShowRationale" to status.shouldShowRationale,
+              "isPermanentlyDenied" to status.isPermanentlyDenied
+            ))
+          } else {
+            attempts++
+            handler.postDelayed(this, 100)
+          }
+        }
+      }
+      
+      // 延迟更长时间开始轮询，给权限对话框弹出的时间
+      handler.postDelayed(checkPermission, 500)
+    }
+    
+    /**
+     * 请求后台位置权限（Android 10+ 支持）
+     * 注意: 必须在前台权限已授予后才能请求
+     * @return 权限请求结果
+     */
+    AsyncFunction("requestBackgroundLocationPermission") { promise: expo.modules.kotlin.Promise ->
+      val activity = appContext.currentActivity
+      if (activity == null) {
+        promise.reject("NO_ACTIVITY", "Activity not available", null)
+        return@AsyncFunction
+      }
+      
+      // 检查是否支持后台位置权限
+      if (!PermissionHelper.isAndroid10Plus()) {
+        promise.resolve(mapOf(
+          "granted" to true,
+          "backgroundLocation" to true,
+          "message" to "Android 10 以下不需要单独请求后台位置权限"
+        ))
+        return@AsyncFunction
+      }
+      
+      // 尝试请求后台位置权限
+      val canRequest = PermissionHelper.requestBackgroundLocationPermission(activity, 1002)
+      if (!canRequest) {
+        promise.reject(
+          "FOREGROUND_PERMISSION_REQUIRED",
+          "必须先授予前台位置权限才能请求后台位置权限",
+          null
+        )
+        return@AsyncFunction
+      }
+      
+      // 轮询检查权限状态
+      val contextRef = java.lang.ref.WeakReference(appContext.reactContext)
+      val handler = android.os.Handler(android.os.Looper.getMainLooper())
+      var attempts = 0
+      val maxAttempts = 30
+      
+      val checkPermission = object : Runnable {
+        override fun run() {
+          val context = contextRef.get()
+          if (context == null) {
+            promise.reject("CONTEXT_LOST", "Context was garbage collected", null)
+            return
+          }
+          
+          val status = PermissionHelper.checkBackgroundLocationPermission(context)
+          
+          if (status.granted || attempts >= maxAttempts) {
             handler.removeCallbacks(this)
             promise.resolve(mapOf(
-              "granted" to (hasFine && hasCoarse),
-              "fineLocation" to hasFine,
-              "coarseLocation" to hasCoarse
+              "granted" to status.granted,
+              "backgroundLocation" to status.backgroundLocation,
+              "shouldShowRationale" to status.shouldShowRationale,
+              "isPermanentlyDenied" to status.isPermanentlyDenied
             ))
           } else {
             attempts++
@@ -411,6 +450,14 @@ class ExpoGaodeMapModule : Module() {
       
       handler.postDelayed(checkPermission, 100)
     }
+    
+    /**
+     * 打开应用设置页面（引导用户手动授予权限）
+     */
+    Function("openAppSettings") {
+      val context = appContext.reactContext!!
+      PermissionHelper.openAppSettings(context)
+    }
 
     // ==================== 地图预加载 ====================