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

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 模块
@@ -24,7 +25,37 @@ class ExpoGaodeMapModule : Module() {
 
     // 在模块加载时尝试从本地缓存恢复隐私同意状态，避免每次启动都必须 JS 调用
     try {
-      SDKInitializer.restorePrivacyState(appContext.reactContext!!)
+      val context = appContext.reactContext!!
+      SDKInitializer.restorePrivacyState(context)
+      
+      // 初始化预加载管理器（注册内存监听）
+      MapPreloadManager.initialize(context)
+      
+      // 🚀 如果用户已同意隐私协议，自动启动预加载（延迟2秒）
+      if (SDKInitializer.isPrivacyAgreed()) {
+        // 尝试从 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()) {
+          try {
+            com.amap.api.maps.MapsInitializer.setApiKey(apiKey)
+            com.amap.api.location.AMapLocationClient.setApiKey(apiKey)
+            android.util.Log.d("ExpoGaodeMap", "✅ 从 AndroidManifest.xml 读取并设置 API Key 成功")
+            
+            // 只有在 API Key 已设置的情况下才启动预加载
+            android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+              android.util.Log.i("ExpoGaodeMap", "🚀 自动启动地图预加载")
+              MapPreloadManager.startPreload(context, poolSize = 1)
+            }, 2000)
+          } catch (e: Exception) {
+            android.util.Log.w("ExpoGaodeMap", "设置 API Key 失败: ${e.message}")
+          }
+        } else {
+          android.util.Log.w("ExpoGaodeMap", "⚠️ AndroidManifest.xml 未找到 API Key，跳过自动预加载")
+        }
+      }
     } catch (e: Exception) {
       android.util.Log.w("ExpoGaodeMap", "恢复隐私状态时出现问题: ${e.message}")
     }
@@ -37,7 +68,37 @@ class ExpoGaodeMapModule : Module() {
      * @param hasAgreed 用户是否已同意隐私协议
      */
     Function("updatePrivacyCompliance") { hasAgreed: Boolean ->
-      SDKInitializer.updatePrivacyCompliance(appContext.reactContext!!, hasAgreed)
+      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)
+      }
     }
     
     // ==================== SDK 初始化 ====================
@@ -271,31 +332,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 权限请求结果
      */
@@ -306,18 +386,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() {
@@ -327,20 +403,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++
@@ -351,6 +492,14 @@ class ExpoGaodeMapModule : Module() {
       
       handler.postDelayed(checkPermission, 100)
     }
+    
+    /**
+     * 打开应用设置页面（引导用户手动授予权限）
+     */
+    Function("openAppSettings") {
+      val context = appContext.reactContext!!
+      PermissionHelper.openAppSettings(context)
+    }
 
     // ==================== 地图预加载 ====================
     
@@ -385,6 +534,14 @@ class ExpoGaodeMapModule : Module() {
     Function("hasPreloadedMapView") {
       MapPreloadManager.hasPreloadedMapView()
     }
+    
+    /**
+     * 获取预加载性能统计
+     * @return 性能统计信息
+     */
+    Function("getMapPreloadPerformanceMetrics") {
+      MapPreloadManager.getPerformanceMetrics()
+    }
 
     Events("onLocationUpdate")