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

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

@@ -22,6 +22,43 @@ class ExpoGaodeMapModule : Module() {
   override fun definition() = ModuleDefinition {
     Name("ExpoGaodeMap")
 
+    // 在模块加载时尝试从本地缓存恢复隐私同意状态，避免每次启动都必须 JS 调用
+    try {
+      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}")
+    }
+ 
     // ==================== 隐私合规管理 ====================
     
     /**
@@ -30,7 +67,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 初始化 ====================
@@ -264,6 +331,24 @@ 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 不支持")
+    }
+
     // ==================== 权限管理 ====================
     
     /**
@@ -345,11 +430,54 @@ class ExpoGaodeMapModule : Module() {
       handler.postDelayed(checkPermission, 100)
     }
 
+    // ==================== 地图预加载 ====================
+    
+    /**
+     * 开始预加载地图实例
+     * @param config 预加载配置对象,包含 poolSize
+     */
+    Function("startMapPreload") { config: Map<String, Any> ->
+      val poolSize = (config["poolSize"] as? Number)?.toInt() ?: 2
+      MapPreloadManager.startPreload(appContext.reactContext!!, poolSize)
+    }
+    
+    /**
+     * 获取预加载状态
+     * @return 预加载状态信息
+     */
+    Function("getMapPreloadStatus") {
+      MapPreloadManager.getStatus()
+    }
+    
+    /**
+     * 清空预加载池
+     */
+    Function("clearMapPreloadPool") {
+      MapPreloadManager.clearPool()
+    }
+    
+    /**
+     * 检查是否有可用的预加载实例
+     * @return 是否有可用实例
+     */
+    Function("hasPreloadedMapView") {
+      MapPreloadManager.hasPreloadedMapView()
+    }
+    
+    /**
+     * 获取预加载性能统计
+     * @return 性能统计信息
+     */
+    Function("getMapPreloadPerformanceMetrics") {
+      MapPreloadManager.getPerformanceMetrics()
+    }
+
     Events("onLocationUpdate")
 
     OnDestroy {
       locationManager?.destroy()
       locationManager = null
+      MapPreloadManager.cleanup()
     }
   }
 

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

@@ -45,6 +45,8 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
     internal var initialCameraPosition: Map<String, Any?>? = null
     /** 是否跟随用户位置 */
     internal var followUserLocation: Boolean = false
+    /** 自定义地图样式配置（缓存） */
+    private var customMapStyleData: Map<String, Any>? = null
 
     /** 主线程 Handler */
     private val mainHandler = android.os.Handler(android.os.Looper.getMainLooper())
@@ -115,6 +117,11 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
                     pendingCameraPosition = null
                 }
 
+                // 应用缓存的自定义地图样式
+                customMapStyleData?.let { styleData ->
+                    uiManager.setCustomMapStyle(styleData)
+                }
+
                 onLoad(mapOf("loaded" to true))
             }
         } catch (_: Exception) {
@@ -331,6 +338,18 @@ class ExpoGaodeMapView(context: Context, appContext: AppContext) : ExpoView(cont
     fun setShowsBuildings(show: Boolean) = uiManager.setShowsBuildings(show)
     /** 设置是否显示室内地图 */
     fun setShowsIndoorMap(show: Boolean) = uiManager.setShowsIndoorMap(show)
+    
+    /**
+     * 设置自定义地图样式
+     * @param styleData 样式配置
+     */
+    fun setCustomMapStyle(styleData: Map<String, Any>) {
+        customMapStyleData = styleData
+        // 如果地图已加载，立即应用样式
+        if (isMapLoaded) {
+            uiManager.setCustomMapStyle(styleData)
+        }
+    }
 
     // ==================== 相机控制方法 ====================
 

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

@@ -51,6 +51,10 @@ class ExpoGaodeMapViewModule : Module() {
       Prop<Boolean>("trafficEnabled") { view, show -> view.setShowsTraffic(show) }
       Prop<Boolean>("buildingsEnabled") { view, show -> view.setShowsBuildings(show) }
       Prop<Boolean>("indoorViewEnabled") { view, show -> view.setShowsIndoorMap(show) }
+      
+      Prop<Map<String, Any>?>("customMapStyle") { view, styleData ->
+        styleData?.let { view.setCustomMapStyle(it) }
+      }
 
       OnViewDidUpdateProps { view: ExpoGaodeMapView ->
         if (view.mapType != 0) {

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

@@ -0,0 +1,368 @@
+/**
+ * 地图预加载管理器 (Android)
+ * 在后台预先初始化地图实例，提升首次显示速度
+ */
+
+package expo.modules.gaodemap
+
+import android.app.ActivityManager
+import android.content.ComponentCallbacks2
+import android.content.Context
+import android.content.res.Configuration
+import android.util.Log
+import com.amap.api.maps.AMap
+import com.amap.api.maps.CameraUpdateFactory
+import com.amap.api.maps.MapView
+import com.amap.api.maps.model.CameraPosition
+import com.amap.api.maps.model.LatLng
+import kotlinx.coroutines.*
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * 地图预加载实例数据
+ */
+data class PreloadedMapInstance(
+    val mapView: MapView,
+    val timestamp: Long = System.currentTimeMillis()
+)
+
+/**
+ * 地图预加载管理器单例
+ */
+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 val preloadedMapViews = ConcurrentLinkedQueue<PreloadedMapInstance>()
+    private val isPreloading = AtomicBoolean(false)
+    private val preloadScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    
+    // 性能统计
+    private val totalPreloads = AtomicInteger(0)
+    private val successfulPreloads = AtomicInteger(0)
+    private val failedPreloads = AtomicInteger(0)
+    private val instancesUsed = AtomicInteger(0)
+    private val instancesExpired = AtomicInteger(0)
+    private val totalDuration = AtomicInteger(0)
+    
+    private var appContext: Context? = null
+    private var cleanupJob: Job? = null
+    
+    init {
+        Log.d(TAG, "🔧 初始化预加载管理器")
+    }
+    
+    /**
+     * 初始化管理器（注册内存监听）
+     */
+    fun initialize(context: Context) {
+        appContext = context.applicationContext
+        appContext?.registerComponentCallbacks(this)
+        
+        // 启动定期清理任务
+        startPeriodicCleanup()
+        
+        Log.d(TAG, "✅ 预加载管理器已初始化，已注册内存监听")
+    }
+    
+    /**
+     * 启动定期清理过期实例的任务
+     */
+    private fun startPeriodicCleanup() {
+        cleanupJob?.cancel()
+        cleanupJob = preloadScope.launch {
+            while (isActive) {
+                delay(60_000) // 每分钟检查一次
+                cleanupExpiredInstances()
+            }
+        }
+    }
+    
+    /**
+     * 清理过期的预加载实例
+     */
+    private fun cleanupExpiredInstances() {
+        val now = System.currentTimeMillis()
+        var expiredCount = 0
+        
+        val iterator = preloadedMapViews.iterator()
+        while (iterator.hasNext()) {
+            val instance = iterator.next()
+            if (now - instance.timestamp > INSTANCE_TTL) {
+                try {
+                    instance.mapView.onDestroy()
+                    iterator.remove()
+                    expiredCount++
+                } catch (e: Exception) {
+                    Log.e(TAG, "清理过期实例失败: ${e.message}", e)
+                }
+            }
+        }
+        
+        if (expiredCount > 0) {
+            instancesExpired.addAndGet(expiredCount)
+            Log.i(TAG, "🧹 清理了 $expiredCount 个过期实例（总计: ${instancesExpired.get()}）")
+        }
+    }
+    
+    /**
+     * 内存警告回调
+     */
+    override fun onLowMemory() {
+        Log.w(TAG, "⚠️ 收到低内存警告，清理预加载池")
+        clearPool()
+    }
+    
+    /**
+     * 内存trim回调
+     */
+    override fun onTrimMemory(level: Int) {
+        when (level) {
+            ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL,
+            ComponentCallbacks2.TRIM_MEMORY_COMPLETE -> {
+                Log.w(TAG, "⚠️ 内存严重不足 (level: $level)，清理预加载池")
+                clearPool()
+            }
+            ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW,
+            ComponentCallbacks2.TRIM_MEMORY_MODERATE -> {
+                Log.w(TAG, "⚠️ 内存不足 (level: $level)，清理部分实例")
+                // 只清理一半
+                val halfSize = preloadedMapViews.size / 2
+                repeat(halfSize) {
+                    preloadedMapViews.poll()?.mapView?.onDestroy()
+                }
+            }
+        }
+    }
+    
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        // 不需要处理
+    }
+    
+    /**
+     * 开始预加载地图实例
+     * @param context Android 上下文
+     * @param poolSize 预加载的地图实例数量
+     */
+    fun startPreload(context: Context, poolSize: Int) {
+        if (isPreloading.get()) {
+            Log.w(TAG, "⚠️ 预加载已在进行中")
+            return
+        }
+        
+        // 检查内存是否充足
+        if (!hasEnoughMemory(context)) {
+            Log.w(TAG, "⚠️ 内存不足，跳过预加载")
+            return
+        }
+        
+        isPreloading.set(true)
+        val targetSize = minOf(poolSize, MAX_POOL_SIZE)
+        Log.i(TAG, "🚀 开始预加载 $targetSize 个地图实例")
+        
+        val startTime = System.currentTimeMillis()
+        totalPreloads.incrementAndGet()
+        
+        preloadScope.launch {
+            var successCount = 0
+            
+            repeat(targetSize) { index ->
+                try {
+                    val mapView = createPreloadedMapView(context)
+                    
+                    withContext(Dispatchers.Main) {
+                        val instance = PreloadedMapInstance(mapView)
+                        preloadedMapViews.offer(instance)
+                        successCount++
+                        Log.i(TAG, "✅ 预加载实例 ${index + 1}/$targetSize 完成")
+                        
+                        if (index == targetSize - 1) {
+                            val duration = (System.currentTimeMillis() - startTime).toInt()
+                            isPreloading.set(false)
+                            
+                            if (successCount > 0) {
+                                successfulPreloads.incrementAndGet()
+                                totalDuration.addAndGet(duration)
+                            } else {
+                                failedPreloads.incrementAndGet()
+                            }
+                            
+                            Log.i(TAG, "🎉 所有实例预加载完成（耗时: ${duration}ms）")
+                        }
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "❌ 预加载实例 ${index + 1} 失败: ${e.message}", e)
+                    if (index == targetSize - 1) {
+                        isPreloading.set(false)
+                        if (successCount == 0) {
+                            failedPreloads.incrementAndGet()
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    /**
+     * 检查是否有足够的内存
+     */
+    private fun hasEnoughMemory(context: Context): Boolean {
+        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
+    }
+    
+    /**
+     * 创建预加载的地图视图
+     * @param context Android 上下文
+     * @return 预加载的地图视图实例
+     */
+    private suspend fun createPreloadedMapView(context: Context): MapView {
+        return withContext(Dispatchers.Main) {
+            val mapView = MapView(context)
+            val aMap = mapView.map
+            
+            // 基础配置
+            aMap.mapType = AMap.MAP_TYPE_NORMAL
+            aMap.isMyLocationEnabled = false
+            aMap.uiSettings.isCompassEnabled = false
+            aMap.uiSettings.isScaleControlsEnabled = false
+            aMap.uiSettings.isZoomControlsEnabled = false
+            aMap.uiSettings.isRotateGesturesEnabled = true
+            aMap.uiSettings.isScrollGesturesEnabled = true
+            aMap.uiSettings.isZoomGesturesEnabled = true
+            
+            // 预加载中心区域（北京天安门）
+            val cameraPosition = CameraPosition(
+                LatLng(39.9042, 116.4074),
+                12f,  // zoom
+                0f,   // tilt
+                0f    // bearing
+            )
+            aMap.moveCamera(CameraUpdateFactory.newCameraPosition(cameraPosition))
+            
+            // 触发地图初始化
+            mapView.onCreate(null)
+            
+            mapView
+        }
+    }
+    
+    /**
+     * 获取一个预加载的地图实例
+     * @return 预加载的地图视图，如果池为空则返回 null
+     */
+    fun getPreloadedMapView(): MapView? {
+        val now = System.currentTimeMillis()
+        
+        // 检查并移除过期实例
+        while (true) {
+            val instance = preloadedMapViews.peek() ?: break
+            
+            if (now - instance.timestamp > INSTANCE_TTL) {
+                preloadedMapViews.poll()
+                try {
+                    instance.mapView.onDestroy()
+                    instancesExpired.incrementAndGet()
+                    Log.i(TAG, "🗑️ 预加载实例已过期，已删除")
+                } catch (e: Exception) {
+                    Log.e(TAG, "清理过期实例失败: ${e.message}", e)
+                }
+            } else {
+                break
+            }
+        }
+        
+        val instance = preloadedMapViews.poll()
+        
+        if (instance != null) {
+            instancesUsed.incrementAndGet()
+            Log.i(TAG, "📤 使用预加载实例，剩余: ${preloadedMapViews.size}，总使用: ${instancesUsed.get()}")
+            
+            // 如果池快空了，记录日志
+            if (preloadedMapViews.isEmpty() && !isPreloading.get()) {
+                Log.w(TAG, "⚠️ 预加载池为空")
+            }
+            
+            return instance.mapView
+        } else {
+            Log.w(TAG, "⚠️ 预加载池为空，返回 null")
+            return null
+        }
+    }
+    
+    /**
+     * 清空预加载池
+     */
+    fun clearPool() {
+        val count = preloadedMapViews.size
+        preloadedMapViews.forEach { instance ->
+            try {
+                instance.mapView.onDestroy()
+            } catch (e: Exception) {
+                Log.e(TAG, "清理地图实例失败: ${e.message}", e)
+            }
+        }
+        preloadedMapViews.clear()
+        Log.i(TAG, "🗑️ 预加载池已清空，清理了 $count 个实例")
+    }
+    
+    /**
+     * 获取预加载状态
+     * @return 预加载状态信息
+     */
+    fun getStatus(): Map<String, Any> {
+        return mapOf(
+            "poolSize" to preloadedMapViews.size,
+            "isPreloading" to isPreloading.get(),
+            "maxPoolSize" to MAX_POOL_SIZE
+        )
+    }
+    
+    /**
+     * 检查是否有可用的预加载实例
+     * @return 是否有可用实例
+     */
+    fun hasPreloadedMapView(): Boolean {
+        return preloadedMapViews.isNotEmpty()
+    }
+    
+    /**
+     * 获取性能统计信息
+     */
+    fun getPerformanceMetrics(): Map<String, Any> {
+        val total = totalPreloads.get()
+        val successful = successfulPreloads.get()
+        val avgDuration = if (successful > 0) totalDuration.get() / successful else 0
+        val successRate = if (total > 0) (successful.toFloat() / total * 100) else 0f
+        
+        return mapOf(
+            "totalPreloads" to total,
+            "successfulPreloads" to successful,
+            "failedPreloads" to failedPreloads.get(),
+            "averageDuration" to avgDuration,
+            "instancesUsed" to instancesUsed.get(),
+            "instancesExpired" to instancesExpired.get(),
+            "successRate" to successRate
+        )
+    }
+    
+    /**
+     * 清理资源
+     */
+    fun cleanup() {
+        clearPool()
+        cleanupJob?.cancel()
+        preloadScope.cancel()
+        appContext?.unregisterComponentCallbacks(this)
+        Log.i(TAG, "🧹 预加载管理器已清理")
+    }
+}

package/android/src/main/java/expo/modules/gaodemap/companion/BitmapDescriptorCache.kt

@@ -0,0 +1,30 @@
+package expo.modules.gaodemap.companion
+
+import com.amap.api.maps.model.BitmapDescriptor
+import com.amap.api.maps.model.BitmapDescriptorFactory
+import android.graphics.Bitmap
+import java.util.concurrent.ConcurrentHashMap
+
+object BitmapDescriptorCache {
+
+    private val cache = ConcurrentHashMap<String, BitmapDescriptor>()
+
+    fun get(key: String): BitmapDescriptor? = cache[key]
+
+    fun put(key: String, bitmap: Bitmap) {
+        val descriptor = BitmapDescriptorFactory.fromBitmap(bitmap)
+        cache[key] = descriptor
+    }
+
+    fun putDescriptor(key: String, descriptor: BitmapDescriptor) {
+        cache[key] = descriptor
+    }
+
+    fun clear() {
+        cache.clear()
+    }
+
+    fun remove(key: String) {
+        cache.remove(key)
+    }
+}

package/android/src/main/java/expo/modules/gaodemap/companion/IconBitmapCache.kt

@@ -0,0 +1,37 @@
+package expo.modules.gaodemap.companion
+
+import android.graphics.Bitmap
+import android.util.LruCache
+
+/**
+ * 简单的 Bitmap LRU 缓存。
+ * key 的格式使用： "<fingerprint>|<width>x<height>"
+ */
+object IconBitmapCache {
+    private val maxMemoryKb = (Runtime.getRuntime().maxMemory() / 1024).toInt()
+    // 使用 1/8 可用内存作为缓存容积（可按需调整）
+    private val cacheSizeKb = maxMemoryKb / 8
+
+    private val cache = object : LruCache<String, Bitmap>(cacheSizeKb) {
+        override fun sizeOf(key: String, value: Bitmap): Int {
+            // 以 KB 为单位
+            return value.byteCount / 1024
+        }
+    }
+
+    fun put(key: String, bitmap: Bitmap) {
+        if (get(key) == null) {
+            cache.put(key, bitmap)
+        }
+    }
+
+    fun get(key: String): Bitmap? = cache.get(key)
+
+    fun remove(key: String) {
+        cache.remove(key)
+    }
+
+    fun clear() {
+        cache.evictAll()
+    }
+}