expo-gaode-map 2.2.5-next.0 → 2.2.5-next.2

package/ios/overlays/MarkerView.swift

@@ -52,6 +52,8 @@ class MarkerView: ExpoView {
     private var mapView: MAMapView?
     /// 标记点对象
     var annotation: MAPointAnnotation?
+    /// 在 MarkerView 中新增属性
+    var cacheKey: String?
     /// 标记是否正在被移除（防止重复移除）
     private var isRemoving: Bool = false
     /// 标记点视图
@@ -124,19 +126,19 @@ class MarkerView: ExpoView {
     }
     
     /**
-     * 更新标记点（批量处理，避免频繁更新）
+     * 更新标记点（立即执行，与其他覆盖物保持一致）
      */
     func updateAnnotation() {
-        // 取消之前的延迟更新
-        pendingUpdateTask?.cancel()
-        
-        // 延迟 16ms（一帧）批量更新
-        let task = DispatchWorkItem { [weak self] in
-            self?.performUpdateAnnotation()
-        }
-        pendingUpdateTask = task
-        
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.016, execute: task)
+        // 🔑 性能优化：移除延迟机制，立即添加
+        // 原因：延迟会在快速添加多个 Marker 时累积，导致帧率下降
+        performUpdateAnnotation()
+    }
+    
+    // JS 侧可以调用
+    func setCacheKey(_ key: String?) {
+        self.cacheKey = key
+        // 发生变化时刷新 annotation
+        updateAnnotation()
     }
     
     /**
@@ -160,20 +162,29 @@ class MarkerView: ExpoView {
         pendingAddTask = nil
         
         // 移除旧的标记
-        if let oldAnnotation = annotation {
-            mapView.removeAnnotation(oldAnnotation)
+//        if let oldAnnotation = annotation {
+//            mapView.removeAnnotation(oldAnnotation)
+//        }
+//        
+//        // 创建新的标记
+//        let annotation = MAPointAnnotation()
+        // 如果已有 annotation，尝试更新坐标与属性，避免 remove/add
+        if let existing = annotation {
+            existing.coordinate = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
+            existing.title = title
+            existing.subtitle = markerDescription
+            // 如果 annotationView 已存在且需要刷新图片（比如 cacheKey 改变或 children 变化），我们后面会处理
+            return
         }
-        
-        // 创建新的标记
+
+        // 如果没有，则创建并添加
         let annotation = MAPointAnnotation()
         annotation.coordinate = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
         annotation.title = title
         annotation.subtitle = markerDescription
-        
         self.annotation = annotation
         
-        // 🔑 关键修复：立即添加到地图（与 CircleView 等保持一致）
-        // 不再使用延迟添加，避免新架构下的时序问题
+        // 立即添加到地图（与 CircleView 等保持一致）
         mapView.addAnnotation(annotation)
     }
     
@@ -184,43 +195,63 @@ class MarkerView: ExpoView {
         
         // 🔑 如果有 children，使用自定义视图
         if self.subviews.count > 0 {
-            let reuseId = "custom_marker_children_\(ObjectIdentifier(self).hashValue)"
+            // 使用 class-level reuseId，便于系统复用 view，减少内存
+            let reuseId = "custom_marker_children"
             var annotationView = mapView.dequeueReusableAnnotationView(withIdentifier: reuseId)
-            
             if annotationView == nil {
                 annotationView = MAAnnotationView(annotation: annotation, reuseIdentifier: reuseId)
             }
-            
             annotationView?.annotation = annotation
-            // 🔑 关键修复：有自定义内容时不显示默认 callout（信息窗口）
             annotationView?.canShowCallout = false
             annotationView?.isDraggable = draggable
             self.annotationView = annotationView
-            
-            if let image = self.createImageFromSubviews() {
-                annotationView?.image = image
-                annotationView?.centerOffset = CGPoint(x: 0, y: -image.size.height / 2)
-            } else {
-                // 🔑 关键修复：不返回 nil，而是设置透明图片，然后延迟重试
-                let size = CGSize(width: CGFloat(customViewWidth > 0 ? customViewWidth : 200),
-                                  height: CGFloat(customViewHeight > 0 ? customViewHeight : 40))
-                UIGraphicsBeginImageContextWithOptions(size, false, 0.0)
-                let transparentImage = UIGraphicsGetImageFromCurrentImageContext()
-                UIGraphicsEndImageContext()
-                annotationView?.image = transparentImage
+
+            // 生成 cacheKey 或 fallback 到 identifier
+            let key = cacheKey ?? "children_\(ObjectIdentifier(self).hashValue)"
+
+            // 1) 如果缓存命中，直接同步返回图像（fast path）
+            if let cached = IconBitmapCache.shared.image(forKey: key) {
+                annotationView?.image = cached
+                // 🔑 修复:自定义视图使用中心偏移,不需要底部偏移
+                annotationView?.centerOffset = CGPoint(x: 0, y: 0)
+                return annotationView
+            }
+
+            // 2) 缓存未命中：返回占位（透明），并异步在主线程生成图像然后回填
+            let size = CGSize(width: CGFloat(customViewWidth > 0 ? customViewWidth : 200),
+                              height: CGFloat(customViewHeight > 0 ? customViewHeight : 40))
+            UIGraphicsBeginImageContextWithOptions(size, false, 0.0)
+            let transparentImage = UIGraphicsGetImageFromCurrentImageContext()
+            UIGraphicsEndImageContext()
+            annotationView?.image = transparentImage
+
+            // 🔑 修复:延长延迟时间,给 React Native Image 更多加载时间
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self, weak annotationView] in
+                guard let self = self, let annotationView = annotationView else { return }
+                // 再次检查缓存（避免重复渲染）
+                if let cached = IconBitmapCache.shared.image(forKey: key) {
+                    print("🔄 iOS Marker: 使用缓存图片, key: \(key)")
+                    annotationView.image = cached
+                    annotationView.centerOffset = CGPoint(x: 0, y: 0)
+                    return
+                }
                 
-                // 延迟重试创建图片
-                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self, weak annotationView] in
-                    guard let self = self, let annotationView = annotationView else { return }
-                    if let image = self.createImageFromSubviews() {
-                        annotationView.image = image
-                        annotationView.centerOffset = CGPoint(x: 0, y: -image.size.height / 2)
-                    }
+                print("⏰ iOS Marker: 0.5秒后开始渲染, key: \(key)")
+                // 调用你的原生渲染逻辑（保留空白检测、多次 layout）
+                if let generated = self.createImageFromSubviews() {
+                    // 写入缓存（仅当用户传了 cacheKey 才缓存；否则建议仍缓存由 fingerprint 决定）
+                    IconBitmapCache.shared.setImage(generated, forKey: key)
+                    annotationView.image = generated
+                    annotationView.centerOffset = CGPoint(x: 0, y: 0)
+                    print("✅ iOS Marker: 渲染成功并显示, size: \(generated.size)")
+                } else {
+                    print("⚠️ iOS Marker: 渲染失败,图片为空")
                 }
             }
-            
+
             return annotationView
         }
+
         
         // 🔑 如果有 icon 属性，使用自定义图标
         if let iconUri = iconUri, !iconUri.isEmpty {
@@ -237,33 +268,53 @@ class MarkerView: ExpoView {
             annotationView?.isDraggable = draggable
             self.annotationView = annotationView
             
-            // 加载自定义图标
-            loadIcon(iconUri: iconUri) { [weak self] image in
-                guard let self = self, let image = image else {
-                    return
-                }
+            // 构建 key
+            let key = cacheKey ?? "icon|\(iconUri)|\(Int(iconWidth))x\(Int(iconHeight))"
+            if let cached = IconBitmapCache.shared.image(forKey: key) {
+                annotationView?.image = cached
+                annotationView?.centerOffset = CGPoint(x: 0, y: -cached.size.height / 2)
+                return annotationView
+            }
+
+            // 原有异步加载，不变：只是在回调里先缓存 then set
+            loadIcon(iconUri: iconUri) { [weak self, weak annotationView] image in
+                guard let self = self, let image = image else { return }
                 let size = CGSize(width: self.iconWidth, height: self.iconHeight)
-                
                 UIGraphicsBeginImageContextWithOptions(size, false, 0.0)
                 image.draw(in: CGRect(origin: .zero, size: size))
                 let resizedImage = UIGraphicsGetImageFromCurrentImageContext()
                 UIGraphicsEndImageContext()
-                
+
                 DispatchQueue.main.async {
-                    annotationView?.image = resizedImage
-                    annotationView?.centerOffset = CGPoint(x: 0, y: -self.iconHeight / 2)
+                    if let img = resizedImage {
+                        IconBitmapCache.shared.setImage(img, forKey: key)
+                        annotationView?.image = img
+                        annotationView?.centerOffset = CGPoint(x: 0, y: -img.size.height / 2)
+                    }
                 }
             }
+
             
             return annotationView
         }
         
         // 🔑 既没有 children 也没有 icon，使用系统默认大头针
-        let reuseId = "pin_marker_\(ObjectIdentifier(self).hashValue)"
+        // 🔑 性能优化：使用颜色作为 reuseId，让系统复用相同颜色的大头针
+        let reuseId = "pin_marker_\(pinColor)"
         var pinView = mapView.dequeueReusableAnnotationView(withIdentifier: reuseId) as? MAPinAnnotationView
         
         if pinView == nil {
             pinView = MAPinAnnotationView(annotation: annotation, reuseIdentifier: reuseId)
+            
+            // 🔑 创建时设置颜色（只在创建时设置一次）
+            switch pinColor.lowercased() {
+            case "green":
+                pinView?.pinColor = .green
+            case "purple":
+                pinView?.pinColor = .purple
+            default:
+                pinView?.pinColor = .red
+            }
         }
         
         pinView?.annotation = annotation
@@ -271,16 +322,6 @@ class MarkerView: ExpoView {
         pinView?.isDraggable = draggable
         pinView?.animatesDrop = animatesDrop
         
-        // 设置大头针颜色
-        switch pinColor.lowercased() {
-        case "green":
-            pinView?.pinColor = .green
-        case "purple":
-            pinView?.pinColor = .purple
-        default:
-            pinView?.pinColor = .red
-        }
-        
         self.annotationView = pinView
         return pinView
     }
@@ -318,12 +359,16 @@ class MarkerView: ExpoView {
      * 将子视图转换为图片
      */
     private func createImageFromSubviews() -> UIImage? {
+        // 🔑 如果有 cacheKey 且命中缓存，直接返回缓存图片
+        if let key = cacheKey, let cachedImage = IconBitmapCache.shared.image(forKey: key) {
+            return cachedImage
+        }
+        
         guard let firstSubview = subviews.first else {
             return nil
         }
         
         // 优先使用 customViewWidth/customViewHeight（用于 children），其次使用子视图尺寸，最后使用默认值
-        // 注意：iconWidth/iconHeight 是用于自定义图标的，不用于 children
         let width: CGFloat
         let height: CGFloat
         
@@ -348,7 +393,7 @@ class MarkerView: ExpoView {
         // 强制子视图使用指定尺寸布局
         firstSubview.frame = CGRect(origin: .zero, size: size)
         
-        // 🔑 关键修复：多次强制布局，确保 React Native Text 完全渲染
+        // 🔑 多次强制布局，确保 React Native Text 完全渲染
         for _ in 0..<3 {
             forceLayoutRecursively(view: firstSubview)
             RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.01))
@@ -357,46 +402,53 @@ class MarkerView: ExpoView {
         UIGraphicsBeginImageContextWithOptions(size, false, 0.0)
         defer { UIGraphicsEndImageContext() }
         
-        guard let context = UIGraphicsGetCurrentContext() else {
+        guard let _ = UIGraphicsGetCurrentContext() else {
             return nil
         }
         
         // 使用 drawHierarchy 而不是 layer.render，这样能正确渲染 Text
-        let success = firstSubview.drawHierarchy(in: CGRect(origin: .zero, size: size), afterScreenUpdates: true)
+        firstSubview.drawHierarchy(in: CGRect(origin: .zero, size: size), afterScreenUpdates: true)
         
         guard let image = UIGraphicsGetImageFromCurrentImageContext() else {
             return nil
         }
         
-        // 🔑 关键：检查图片是否真的有内容（不是空白图片）
-        guard let cgImage = image.cgImage else {
-            return nil
-        }
+        // 🔑 检查图片是否真的有内容（不是空白图片）
+        // 暂时禁用空白检测,因为 React Native Image 可能需要额外的渲染时间
+        // guard let cgImage = image.cgImage else {
+        //     print("⚠️ iOS Marker: cgImage 为 nil")
+        //     return nil
+        // }
         
-        // 检查图片数据是否为空白
-        let dataProvider = cgImage.dataProvider
-        let data = dataProvider?.data
-        let buffer = CFDataGetBytePtr(data)
-        
-        var isBlank = true
-        if let buffer = buffer {
-            let length = CFDataGetLength(data)
-            // 检查前 100 个字节是否都是 0（空白）
-            let checkLength = min(100, length)
-            for i in 0..<checkLength {
-                if buffer[i] != 0 {
-                    isBlank = false
-                    break
-                }
-            }
-        }
+        // let dataProvider = cgImage.dataProvider
+        // let data = dataProvider?.data
+        // let buffer = CFDataGetBytePtr(data)
         
-        if isBlank {
-            return nil
+        // var isBlank = true
+        // if let buffer = buffer {
+        //     let length = CFDataGetLength(data)
+        //     let checkLength = min(100, length)
+        //     for i in 0..<checkLength {
+        //         if buffer[i] != 0 {
+        //             isBlank = false
+        //             break
+        //         }
+        //     }
+        // }
+        
+        // if isBlank {
+        //     print("⚠️ iOS Marker: 渲染的图片是空白的")
+        //     return nil
+        // }
+        
+        // 🔑 写入缓存
+        if let key = cacheKey {
+            IconBitmapCache.shared.setImage(image, forKey: key)
         }
         
         return image
     }
+
     
     /**
      * 递归强制布局视图及其所有子视图
@@ -429,21 +481,17 @@ class MarkerView: ExpoView {
     private func removeAnnotationFromMap() {
         guard !isRemoving else { return }
         isRemoving = true
-        
-        // 取消任何待处理的延迟任务
-        pendingAddTask?.cancel()
-        pendingAddTask = nil
-        pendingUpdateTask?.cancel()
-        pendingUpdateTask = nil
-        
-        // 立即保存引用并清空属性，避免在异步块中访问 self
-        guard let mapView = mapView, let annotation = annotation else {
-            return
-        }
+        pendingAddTask?.cancel(); pendingAddTask = nil
+        pendingUpdateTask?.cancel(); pendingUpdateTask = nil
+
+        guard let mapView = mapView, let annotation = annotation else { return }
         self.annotation = nil
         self.annotationView = nil
-        
-        // 同步移除，避免对象在异步块执行时已被释放
+
+        // 🔑 修复：不要在移除时删除缓存
+        // 理由：多个 Marker 可能共享同一 cacheKey，删除会影响其他 Marker
+        // 缓存由 NSCache 自动管理，内存不足时会自动清理
+
         if Thread.isMainThread {
             mapView.removeAnnotation(annotation)
         } else {
@@ -452,7 +500,7 @@ class MarkerView: ExpoView {
             }
         }
     }
-    
+
     override func willRemoveSubview(_ subview: UIView) {
         super.willRemoveSubview(subview)
         
@@ -616,3 +664,45 @@ class MarkerView: ExpoView {
         lastSetMapView = nil
     }
 }
+
+
+/// 增强版内存缓存（带 cost 与清理）
+class IconBitmapCache {
+    static let shared = IconBitmapCache()
+    private init() {
+        // 设置 totalCostLimit = 1/8 可用内存（以字节计）
+        let mem = ProcessInfo.processInfo.physicalMemory
+        // 限制在可用物理内存的 1/8（可按需调整）
+        let limit = Int(mem / 8)
+        cache.totalCostLimit = limit
+    }
+
+    private var cache = NSCache<NSString, UIImage>()
+
+    func image(forKey key: String) -> UIImage? {
+        return cache.object(forKey: key as NSString)
+    }
+
+    func setImage(_ image: UIImage, forKey key: String) {
+        // 以 bitmap 字节数作为 cost（更可靠）
+        let cost = imageCostInBytes(image)
+        cache.setObject(image, forKey: key as NSString, cost: cost)
+    }
+
+    func removeImage(forKey key: String) {
+        cache.removeObject(forKey: key as NSString)
+    }
+
+    func clear() {
+        cache.removeAllObjects()
+    }
+
+    private func imageCostInBytes(_ image: UIImage) -> Int {
+        if let cg = image.cgImage {
+            return cg.bytesPerRow * cg.height
+        }
+        // fallback estimate
+        return Int(image.size.width * image.size.height * 4)
+    }
+}
+

package/ios/overlays/MarkerViewModule.swift

@@ -64,7 +64,9 @@ public class MarkerViewModule: Module {
             Prop("canShowCallout") { (view: MarkerView, show: Bool) in
                 view.setCanShowCallout(show)
             }
-            
+             Prop("cacheKey") { (view: MarkerView, key: String) in
+                view.setCacheKey(key)
+            }
         }
     }
 }

package/ios/utils/PermissionManager.swift

@@ -1,15 +1,40 @@
+#if os(iOS)
 import Foundation
 import CoreLocation
+import UIKit
 
 /**
  * 位置权限管理器
- * 
+ *
  * 负责:
- * - 请求位置权限
+ * - 请求位置权限（支持 iOS 17+ 新特性）
  * - 监听权限状态变化
  * - 返回权限结果
+ * - 提供权限诊断信息
  */
 class PermissionManager: NSObject, CLLocationManagerDelegate {
+    
+    // MARK: - iOS 版本检测
+    
+    /**
+     * 检查是否为 iOS 17+
+     */
+    static func isIOS17Plus() -> Bool {
+        if #available(iOS 17.0, *) {
+            return true
+        }
+        return false
+    }
+    
+    /**
+     * 检查是否为 iOS 14+（引入精确位置权限）
+     */
+    static func isIOS14Plus() -> Bool {
+        if #available(iOS 14.0, *) {
+            return true
+        }
+        return false
+    }
     /// 位置管理器实例
     private var locationManager: CLLocationManager?
     /// 权限请求回调
@@ -34,7 +59,14 @@ class PermissionManager: NSObject, CLLocationManagerDelegate {
             let currentStatus = CLLocationManager.authorizationStatus()
             
             // 如果已经有权限,直接返回
-            if currentStatus == .authorizedAlways || currentStatus == .authorizedWhenInUse {
+            var hasPermission = false
+            if #available(iOS 8.0, *) {
+                hasPermission = currentStatus == .authorizedWhenInUse || currentStatus == .authorizedAlways
+            } else {
+                hasPermission = currentStatus == .authorizedAlways
+            }
+            
+            if hasPermission {
                 self.permissionCallback?(true, self.getAuthorizationStatusString(currentStatus))
                 self.permissionCallback = nil
                 return
@@ -75,7 +107,12 @@ class PermissionManager: NSObject, CLLocationManagerDelegate {
         }
         
         // 状态已确定(授予或拒绝),返回结果
-        let granted = status == .authorizedAlways || status == .authorizedWhenInUse
+        var granted = false
+        if #available(iOS 8.0, *) {
+            granted = status == .authorizedWhenInUse || status == .authorizedAlways
+        } else {
+            granted = status == .authorizedAlways
+        }
         let statusString = getAuthorizationStatusString(status)
         
         permissionCallback?(granted, statusString)
@@ -96,6 +133,87 @@ class PermissionManager: NSObject, CLLocationManagerDelegate {
         }
     }
     
+    // MARK: - iOS 17+ 新功能
+    
+    /**
+     * 检查是否有精确位置权限（iOS 14+）
+     */
+    func hasAccuracyAuthorization() -> Bool {
+        guard let manager = locationManager else { return true }
+        
+        if #available(iOS 14.0, *) {
+            return manager.accuracyAuthorization == .fullAccuracy
+        }
+        return true // iOS 14 以下默认为精确位置
+    }
+    
+    /**
+     * 请求临时精确位置权限（iOS 14+）
+     * @param purposeKey Info.plist 中配置的用途键
+     * @param callback 结果回调 (granted)
+     */
+    func requestTemporaryFullAccuracy(purposeKey: String, callback: @escaping (Bool) -> Void) {
+        guard let manager = locationManager else {
+            callback(false)
+            return
+        }
+        
+        if #available(iOS 14.0, *) {
+            manager.requestTemporaryFullAccuracyAuthorization(withPurposeKey: purposeKey) { error in
+                if let error = error {
+                    callback(false)
+                } else {
+                    let hasAccuracy = manager.accuracyAuthorization == .fullAccuracy
+                    callback(hasAccuracy)
+                }
+            }
+        } else {
+            // iOS 14 以下默认为精确位置
+            callback(true)
+        }
+    }
+    
+    // MARK: - 诊断信息
+    
+    /**
+     * 获取权限诊断信息
+     */
+    static func getDiagnosticInfo() -> [String: Any] {
+        let currentStatus = CLLocationManager.authorizationStatus()
+        let statusString = getStaticAuthorizationStatusString(currentStatus)
+        
+        var info: [String: Any] = [
+            "platform": "ios",
+            "systemVersion": UIDevice.current.systemVersion,
+            "isIOS17Plus": isIOS17Plus(),
+            "isIOS14Plus": isIOS14Plus(),
+            "currentStatus": statusString,
+            "granted": currentStatus == .authorizedAlways || currentStatus == .authorizedWhenInUse
+        ]
+        
+        // iOS 14+ 精确位置信息
+        if #available(iOS 14.0, *) {
+            let manager = CLLocationManager()
+            info["hasAccuracyAuthorization"] = manager.accuracyAuthorization == .fullAccuracy
+        }
+        
+        return info
+    }
+    
+    /**
+     * 静态方法：将权限状态转换为字符串
+     */
+    private static func getStaticAuthorizationStatusString(_ status: CLAuthorizationStatus) -> String {
+        switch status {
+        case .notDetermined: return "notDetermined"
+        case .restricted: return "restricted"
+        case .denied: return "denied"
+        case .authorizedAlways: return "authorizedAlways"
+        case .authorizedWhenInUse: return "authorizedWhenInUse"
+        @unknown default: return "unknown"
+        }
+    }
+    
     /**
      * 析构函数 - 清理资源
      */
@@ -104,4 +222,5 @@ class PermissionManager: NSObject, CLLocationManagerDelegate {
         locationManager = nil
         permissionCallback = nil
     }
-}
+}
+#endif

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "expo-gaode-map",
-  "version": "2.2.5-next.0",
+  "version": "2.2.5-next.2",
   "description": "一个功能完整的高德地图 React Native 组件库，基于 Expo Modules 开发，提供地图显示、定位、覆盖物等功能。",
   "main": "build/index.js",
   "types": "build/index.d.ts",
+  "files": [
+    "build",
+    "android",
+    "ios",
+    "app.plugin.js",
+    "expo-module.config.json",
+    "plugin/build"
+  ],
   "keywords": [
     "react-native",
     "expo",
@@ -15,7 +23,7 @@
   "bugs": {
     "url": "https://github.com/TomWq/expo-gaode-map/issues"
   },
-  "author": "尚博信_王强 <wangqiang03@sunboxsoft.com> (https://github.com/TomWq)",
+  "author": "<TomWq>(https://github.com/TomWq)",
   "license": "MIT",
   "homepage": "https://github.com/TomWq/expo-gaode-map#readme",
   "dependencies": {
@@ -23,10 +31,17 @@
   },
   "devDependencies": {
     "@expo/config-plugins": "^9.1.7",
+    "@testing-library/react-native": "^13.3.3",
+    "@types/jest": "^29.5.14",
     "@types/react": "~19.1.0",
+    "@types/supercluster": "^7.1.3",
+    "babel-preset-expo": "^54.0.8",
     "expo": "^54.0.18",
     "expo-module-scripts": "^5.0.7",
+    "jest": "^30.2.0",
+    "jest-expo": "^54.0.16",
     "react-native": "0.81.5",
+    "react-test-renderer": "19.1.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {