expo-gaode-map 2.2.9-next.0 → 2.2.10-next.0

package/ios/ExpoGaodeMapView.swift

@@ -49,6 +49,8 @@ class ExpoGaodeMapView: ExpoView, MAMapViewDelegate {
     var showsBuildings: Bool = false
     /// 是否显示室内地图
     var showsIndoorMap: Bool = false
+    /// 自定义地图样式配置
+    var customMapStyleData: [String: Any]?
     
     // MARK: - 事件派发器
     
@@ -78,6 +80,17 @@ class ExpoGaodeMapView: ExpoView, MAMapViewDelegate {
     /// 显式跟踪所有覆盖物视图（新架构下 subviews 可能不可靠）
     private var overlayViews: [UIView] = []
     
+    // MARK: - 事件节流控制
+    
+    /// 相机移动事件节流间隔(秒)
+    private let cameraMoveThrottleInterval: TimeInterval = 0.1
+    /// 上次触发相机移动事件的时间戳
+    private var lastCameraMoveTime: TimeInterval = 0
+    /// 缓存的相机移动事件数据
+    private var pendingCameraMoveData: [String: Any]?
+    /// 节流定时器
+    private var throttleTimer: Timer?
+    
     // MARK: - 初始化
     
     required init(appContext: AppContext? = nil) {
@@ -481,6 +494,18 @@ class ExpoGaodeMapView: ExpoView, MAMapViewDelegate {
         uiManager.setShowsIndoorMap(show)
     }
     
+    /**
+     * 设置自定义地图样式
+     * @param styleData 样式配置
+     */
+    func setCustomMapStyle(_ styleData: [String: Any]) {
+        customMapStyleData = styleData
+        // 如果地图已加载，立即应用样式
+        if isMapLoaded {
+            uiManager.setCustomMapStyle(styleData)
+        }
+    }
+    
     func setFollowUserLocation(_ follow: Bool) {
         followUserLocation = follow
         uiManager.setShowsUserLocation(showsUserLocation, followUser: follow)
@@ -516,6 +541,11 @@ class ExpoGaodeMapView: ExpoView, MAMapViewDelegate {
      * 当视图从层级中移除并释放时自动调用
      */
     deinit {
+        // 清理节流定时器
+        throttleTimer?.invalidate()
+        throttleTimer = nil
+        pendingCameraMoveData = nil
+        
         // 清理代理,停止接收回调
         mapView?.delegate = nil
         
@@ -547,18 +577,25 @@ extension ExpoGaodeMapView {
     public func mapViewDidFinishLoadingMap(_ mapView: MAMapView) {
         guard !isMapLoaded else { return }
         isMapLoaded = true
+        
+        // 地图加载完成后，应用自定义样式
+        if let styleData = customMapStyleData {
+            uiManager.setCustomMapStyle(styleData)
+        }
+        
         onLoad(["loaded": true])
     }
     
     /**
-     * 地图区域即将改变时触发
+     * 地图区域即将改变时触发 - 应用节流优化
      */
     public func mapView(_ mapView: MAMapView, regionWillChangeAnimated animated: Bool) {
-        // 相机开始移动
+        // 相机开始移动 - 应用节流优化
+        let currentTime = Date().timeIntervalSince1970
         let cameraPosition = cameraManager.getCameraPosition()
         let visibleRegion = mapView.region
         
-        onCameraMove([
+        let eventData: [String: Any] = [
             "cameraPosition": cameraPosition,
             "latLngBounds": [
                 "northeast": [
@@ -570,7 +607,31 @@ extension ExpoGaodeMapView {
                     "longitude": visibleRegion.center.longitude - visibleRegion.span.longitudeDelta / 2
                 ]
             ]
-        ])
+        ]
+        
+        // 节流逻辑：0.1秒 内只触发一次
+        if currentTime - lastCameraMoveTime >= cameraMoveThrottleInterval {
+            // 超过节流时间，立即触发事件
+            lastCameraMoveTime = currentTime
+            onCameraMove(eventData)
+            // 清除待处理的事件和定时器
+            throttleTimer?.invalidate()
+            throttleTimer = nil
+            pendingCameraMoveData = nil
+        } else {
+            // 在节流时间内，缓存事件数据，使用定时器延迟触发
+            pendingCameraMoveData = eventData
+            throttleTimer?.invalidate()
+            
+            let delay = cameraMoveThrottleInterval - (currentTime - lastCameraMoveTime)
+            throttleTimer = Timer.scheduledTimer(withTimeInterval: delay, repeats: false) { [weak self] _ in
+                guard let self = self, let data = self.pendingCameraMoveData else { return }
+                self.lastCameraMoveTime = Date().timeIntervalSince1970
+                self.onCameraMove(data)
+                self.pendingCameraMoveData = nil
+                self.throttleTimer = nil
+            }
+        }
     }
     
     /**

package/ios/ExpoGaodeMapViewModule.swift

@@ -79,6 +79,12 @@ public class ExpoGaodeMapViewModule: Module {
                 view.setShowsIndoorMap(show)
             }
             
+            Prop("customMapStyle") { (view: ExpoGaodeMapView, styleData: [String: Any]?) in
+                if let styleData = styleData {
+                    view.setCustomMapStyle(styleData)
+                }
+            }
+            
             OnViewDidUpdateProps { (view: ExpoGaodeMapView) in
                 view.applyProps()
             }

package/ios/MapPreloadManager.swift

@@ -7,19 +7,43 @@ import Foundation
 import AMapFoundationKit
 import MAMapKit
 
+/// 预加载实例数据
+struct PreloadedMapInstance {
+    let mapView: MAMapView
+    let timestamp: Date
+}
+
 /// 地图预加载管理器
 ///
 class MapPreloadManager {
     static let shared = MapPreloadManager()
     
-    private var preloadedMapViews: [MAMapView] = []
-    private let maxPoolSize = 3
+    // 动态池大小配置（根据内存自适应）
+    private let maxPoolSizeHighMemory = 3      // 高内存设备：>= 500MB
+    private let maxPoolSizeMediumMemory = 2    // 中等内存：300-500MB
+    private let maxPoolSizeLowMemory = 1       // 低内存设备：150-300MB
+    private let minMemoryThresholdMB: UInt64 = 150  // 最低内存要求
+    
+    // 动态 TTL 配置（根据内存压力自适应）
+    private let ttlNormal: TimeInterval = 5 * 60        // 正常：5分钟
+    private let ttlMemoryPressure: TimeInterval = 2 * 60  // 内存压力：2分钟
+    private let ttlLowMemory: TimeInterval = 1 * 60       // 低内存：1分钟
+    
+    private var preloadedMapInstances: [PreloadedMapInstance] = []
     private var isPreloading = false
     private let preloadQueue = DispatchQueue(label: "com.expo.gaodemap.preload", qos: .background)
-    private var preloadGroup = DispatchGroup()  // 用于同步异步任务
+    private var preloadGroup = DispatchGroup()
+    
+    // 动态配置
+    private var currentMaxPoolSize = 2
+    private var currentTTL: TimeInterval = 5 * 60
+    private var memoryPressureLevel = 0  // 0=正常, 1=压力, 2=严重
+    
+    // 定期清理任务
+    private var cleanupTimer: Timer?
 
     private init() {
-        print("🔧 [MapPreload] 初始化预加载管理器")
+        print("🔧 [MapPreload] 初始化预加载管理器（自适应版本）")
         
         // 注册内存警告监听
         NotificationCenter.default.addObserver(
@@ -28,6 +52,35 @@ class MapPreloadManager {
             name: UIApplication.didReceiveMemoryWarningNotification,
             object: nil
         )
+        
+        // 启动定期清理任务
+        startPeriodicCleanup()
+    }
+    
+    /// 启动定期清理过期实例的任务
+    private func startPeriodicCleanup() {
+        cleanupTimer?.invalidate()
+        cleanupTimer = Timer.scheduledTimer(withTimeInterval: 60, repeats: true) { [weak self] _ in
+            self?.cleanupExpiredInstances()
+        }
+    }
+    
+    /// 清理过期的预加载实例（使用动态 TTL）
+    private func cleanupExpiredInstances() {
+        let now = Date()
+        var expiredCount = 0
+        
+        preloadedMapInstances.removeAll { instance in
+            let isExpired = now.timeIntervalSince(instance.timestamp) > currentTTL
+            if isExpired {
+                expiredCount += 1
+            }
+            return isExpired
+        }
+        
+        if expiredCount > 0 {
+            print("🧹 [MapPreload] 清理了 \(expiredCount) 个过期实例（当前TTL: \(Int(currentTTL))秒）")
+        }
     }
     
     /// 处理内存警告
@@ -36,21 +89,30 @@ class MapPreloadManager {
         clearPool()
     }
     
-    deinit {
-        NotificationCenter.default.removeObserver(self)
-    }
-    
-    /// 开始预加载地图实例
-    /// - Parameter poolSize: 预加载的地图实例数量
+    /// 开始预加载地图实例（自适应版本）
+    /// - Parameter poolSize: 预加载的地图实例数量（会根据内存自适应调整）
     func startPreload(poolSize: Int) {
         guard !isPreloading else {
             print("⚠️ [MapPreload] 预加载已在进行中")
             return
         }
         
+        // 动态计算最优池大小
+        let adaptiveMaxPoolSize = calculateAdaptivePoolSize()
+        currentMaxPoolSize = adaptiveMaxPoolSize
+        
+        // 动态调整 TTL
+        currentTTL = calculateAdaptiveTTL()
+        
+        // 检查内存是否充足
+        guard hasEnoughMemory() else {
+            print("⚠️ [MapPreload] 内存不足，跳过预加载")
+            return
+        }
+        
         isPreloading = true
-        let targetSize = min(poolSize, maxPoolSize)
-        print("🚀 [MapPreload] 开始预加载 \(targetSize) 个地图实例")
+        let targetSize = min(poolSize, adaptiveMaxPoolSize)
+        print("🚀 [MapPreload] 开始预加载 \(targetSize) 个地图实例 (自适应池大小: \(adaptiveMaxPoolSize), TTL: \(Int(currentTTL))秒)")
         
         for i in 0..<targetSize {
             preloadGroup.enter()  // 进入预加载队列
@@ -61,11 +123,12 @@ class MapPreloadManager {
                     // 创建地图视图
                     let mapView = self.createPreloadedMapView()
 
-                    // 将地图实例添加到池中
+                    // 将地图实例添加到池中（带时间戳）
                     DispatchQueue.main.async {
-                        self.preloadedMapViews.append(mapView)
+                        let instance = PreloadedMapInstance(mapView: mapView, timestamp: Date())
+                        self.preloadedMapInstances.append(instance)
                         print("✅ [MapPreload] 预加载实例 \(i + 1)/\(targetSize) 完成")
-                        self.preloadGroup.leave()  // 完成当前实例的加载
+                        self.preloadGroup.leave()
                     }
                 }
             }
@@ -121,43 +184,156 @@ class MapPreloadManager {
         mapView.layoutIfNeeded()
     }
     
-    /// 获取一个预加载的地图实例
+    /// 计算自适应池大小
+    /// 根据可用内存动态调整池大小
+    private func calculateAdaptivePoolSize() -> Int {
+        let availableMB = getAvailableMemoryMB()
+        
+        switch availableMB {
+        case 500...:
+            print("📊 [MapPreload] 高内存设备 (\(availableMB)MB)，池大小: \(maxPoolSizeHighMemory)")
+            return maxPoolSizeHighMemory
+        case 300..<500:
+            print("📊 [MapPreload] 中等内存设备 (\(availableMB)MB)，池大小: \(maxPoolSizeMediumMemory)")
+            return maxPoolSizeMediumMemory
+        case 150..<300:
+            print("📊 [MapPreload] 低内存设备 (\(availableMB)MB)，池大小: \(maxPoolSizeLowMemory)")
+            return maxPoolSizeLowMemory
+        default:
+            print("⚠️ [MapPreload] 内存极低 (\(availableMB)MB)，禁用预加载")
+            return 0
+        }
+    }
+    
+    /// 计算自适应 TTL
+    /// 根据内存压力动态调整过期时间
+    private func calculateAdaptiveTTL() -> TimeInterval {
+        let availableMB = getAvailableMemoryMB()
+        let totalMB = getTotalMemoryMB()
+        let usagePercent = Int((Double(totalMB - availableMB) / Double(totalMB)) * 100)
+        
+        switch usagePercent {
+        case 0..<60:
+            memoryPressureLevel = 0
+            print("📊 [MapPreload] 内存充足 (使用率: \(usagePercent)%)，TTL: \(Int(ttlNormal))秒")
+            return ttlNormal
+        case 60..<80:
+            memoryPressureLevel = 1
+            print("📊 [MapPreload] 内存压力 (使用率: \(usagePercent)%)，TTL: \(Int(ttlMemoryPressure))秒")
+            return ttlMemoryPressure
+        default:
+            memoryPressureLevel = 2
+            print("⚠️ [MapPreload] 内存严重不足 (使用率: \(usagePercent)%)，TTL: \(Int(ttlLowMemory))秒")
+            return ttlLowMemory
+        }
+    }
+    
+    /// 获取可用内存（MB）
+    private func getAvailableMemoryMB() -> UInt64 {
+        var info = mach_task_basic_info()
+        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size) / 4
+        
+        let kerr: kern_return_t = withUnsafeMutablePointer(to: &info) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
+                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
+            }
+        }
+        
+        if kerr == KERN_SUCCESS {
+            let usedMB = UInt64(info.resident_size) / 1024 / 1024
+            let totalMB = ProcessInfo.processInfo.physicalMemory / 1024 / 1024
+            return totalMB - usedMB
+        }
+        return 0
+    }
+    
+    /// 获取总内存（MB）
+    private func getTotalMemoryMB() -> UInt64 {
+        return ProcessInfo.processInfo.physicalMemory / 1024 / 1024
+    }
+    
+    /// 检查是否有足够的内存
+    private func hasEnoughMemory() -> Bool {
+        return getAvailableMemoryMB() > minMemoryThresholdMB
+    }
+    
+    /// 获取一个预加载的地图实例（使用动态 TTL）
     /// - Returns: 预加载的地图视图，如果池为空则返回 nil
     func getPreloadedMapView() -> MAMapView? {
-        if let mapView = preloadedMapViews.first {
-            preloadedMapViews.removeFirst()
-            print("📤 [MapPreload] 使用预加载实例，剩余: \(preloadedMapViews.count)")
-            return mapView
+        let now = Date()
+        
+        // 检查并移除过期实例（使用动态 TTL）
+        preloadedMapInstances.removeAll { instance in
+            let isExpired = now.timeIntervalSince(instance.timestamp) > currentTTL
+            if isExpired {
+                print("🗑️ [MapPreload] 预加载实例已过期（TTL: \(Int(currentTTL))秒），已删除")
+            }
+            return isExpired
+        }
+        
+        if let instance = preloadedMapInstances.first {
+            preloadedMapInstances.removeFirst()
+            print("📤 [MapPreload] 使用预加载实例，剩余: \(preloadedMapInstances.count)")
+            return instance.mapView
         }
+        
+        print("⚠️ [MapPreload] 预加载池为空，返回 nil")
         return nil
     }
     
     /// 清空预加载池
     func clearPool() {
-        let count = preloadedMapViews.count
-        preloadedMapViews.removeAll()
+        let count = preloadedMapInstances.count
+        preloadedMapInstances.removeAll()
         print("🗑️ [MapPreload] 预加载池已清空，清理了 \(count) 个实例")
     }
     
-    /// 获取预加载状态
+    /// 获取预加载状态（包含动态配置信息）
     /// - Returns: 预加载状态信息
     func getStatus() -> [String: Any] {
         return [
-            "poolSize": preloadedMapViews.count,
+            "poolSize": preloadedMapInstances.count,
             "isPreloading": isPreloading,
-            "maxPoolSize": maxPoolSize
+            "maxPoolSize": currentMaxPoolSize,
+            "currentTTL": currentTTL,
+            "memoryPressureLevel": memoryPressureLevel,
+            "isAdaptive": true
+        ]
+    }
+    
+    /// 获取性能统计信息（包含内存信息）
+    func getPerformanceMetrics() -> [String: Any] {
+        let availableMB = getAvailableMemoryMB()
+        let totalMB = getTotalMemoryMB()
+        let usagePercent = Int((Double(totalMB - availableMB) / Double(totalMB)) * 100)
+        
+        return [
+            "currentMaxPoolSize": currentMaxPoolSize,
+            "currentTTL": currentTTL,
+            "memoryPressureLevel": memoryPressureLevel,
+            "availableMemoryMB": availableMB,
+            "totalMemoryMB": totalMB,
+            "memoryUsagePercent": usagePercent,
+            "poolSize": preloadedMapInstances.count
         ]
     }
     
     /// 检查是否有可用的预加载实例
     /// - Returns: 是否有可用实例
     func hasPreloadedMapView() -> Bool {
-        return !preloadedMapViews.isEmpty
+        return !preloadedMapInstances.isEmpty
     }
 
     func cleanup() {
+        cleanupTimer?.invalidate()
+        cleanupTimer = nil
         clearPool()
         print("🧹 [MapPreload] 预加载管理器已清理")
     }
+    
+    deinit {
+        cleanupTimer?.invalidate()
+        NotificationCenter.default.removeObserver(self)
+    }
 }
 

package/ios/managers/UIManager.swift

@@ -17,6 +17,9 @@ class UIManager: NSObject, MAMapViewDelegate {
     /// 定位变化回调
     var onLocationChanged: ((_ latitude: Double, _ longitude: Double, _ accuracy: Double) -> Void)?
     
+    /// 缓存的自定义样式配置
+    private var cachedCustomStyleOptions: MAMapCustomStyleOptions?
+    
     init(mapView: MAMapView) {
         self.mapView = mapView
         super.init()
@@ -36,6 +39,13 @@ class UIManager: NSObject, MAMapViewDelegate {
         case 3: mapView.mapType = .navi
         default: mapView.mapType = .standard
         }
+        
+        // 🔑 关键修复：切换地图类型后重新应用自定义样式
+        // 某些地图类型切换可能会重置样式设置
+        if let cachedOptions = cachedCustomStyleOptions {
+            mapView.setCustomMapStyleOptions(cachedOptions)
+            mapView.customMapStyleEnabled = true
+        }
     }
     
     // MARK: - 控件显示
@@ -109,7 +119,8 @@ class UIManager: NSObject, MAMapViewDelegate {
             }
             mapView.showsUserLocation = true
             if followUser {
-                mapView.userTrackingMode = .follow
+                // 🔑 使用 followWithHeading 模式以支持方向指示器
+                mapView.userTrackingMode = .followWithHeading
             } else {
                 mapView.userTrackingMode = .none
             }
@@ -146,6 +157,12 @@ class UIManager: NSObject, MAMapViewDelegate {
         guard let mapView = mapView else { return }
         let representation = MAUserLocationRepresentation()
         
+        // 是否显示定位蓝点 (showMyLocation) - 对应 Android 的 showMyLocation
+        // iOS 通过 mapView.showsUserLocation 控制，这里提供统一的 API
+        if let showMyLocation = config["showMyLocation"] as? Bool {
+            mapView.showsUserLocation = showMyLocation
+        }
+        
         // 精度圈是否显示
         if let showsAccuracyRing = config["showsAccuracyRing"] as? Bool {
             representation.showsAccuracyRing = showsAccuracyRing
@@ -265,4 +282,58 @@ class UIManager: NSObject, MAMapViewDelegate {
     func setShowsIndoorMap(_ show: Bool) {
         mapView?.isShowsIndoorMap = show
     }
+    
+    // MARK: - 自定义地图样式
+    
+    /**
+     * 设置自定义地图样式
+     * @param styleData 样式数据，支持以下格式：
+     *   - styleId: String - 在线样式ID（从高德开放平台获取）
+     *   - styleDataPath: String - 本地样式文件路径
+     *   - extraStyleDataPath: String - 额外样式文件路径（可选）
+     */
+    func setCustomMapStyle(_ styleData: [String: Any]) {
+        guard let mapView = mapView else { return }
+        
+        // 在线样式 ID
+        if let styleId = styleData["styleId"] as? String, !styleId.isEmpty {
+            let customStyle = MAMapCustomStyleOptions()
+            customStyle.styleId = styleId
+            
+            // 🔑 缓存样式配置
+            cachedCustomStyleOptions = customStyle
+            
+            mapView.setCustomMapStyleOptions(customStyle)
+            mapView.customMapStyleEnabled = true
+            return
+        }
+        
+        // 本地样式文件
+        if let styleDataPath = styleData["styleDataPath"] as? String, !styleDataPath.isEmpty {
+            // 读取样式文件数据
+            if let stylePath = Bundle.main.path(forResource: styleDataPath, ofType: nil),
+               let styleFileData = try? Data(contentsOf: URL(fileURLWithPath: stylePath)) {
+                let customStyle = MAMapCustomStyleOptions()
+                customStyle.styleData = styleFileData
+                
+                // 额外样式文件（可选）
+                if let extraPath = styleData["extraStyleDataPath"] as? String, !extraPath.isEmpty,
+                   let extraFilePath = Bundle.main.path(forResource: extraPath, ofType: nil),
+                   let extraFileData = try? Data(contentsOf: URL(fileURLWithPath: extraFilePath)) {
+                    customStyle.styleExtraData = extraFileData
+                }
+                
+                // 🔑 缓存样式配置
+                cachedCustomStyleOptions = customStyle
+                
+                mapView.setCustomMapStyleOptions(customStyle)
+                mapView.customMapStyleEnabled = true
+                return
+            }
+        }
+        
+        // 如果没有提供任何样式，禁用自定义样式并清除缓存
+        cachedCustomStyleOptions = nil
+        mapView.customMapStyleEnabled = false
+    }
 }

package/ios/overlays/MarkerView.swift

@@ -441,8 +441,6 @@ class MarkerView: ExpoView {
         //     return nil
         // }
         
-        print("✅ iOS Marker: 成功渲染图片, size: \(image.size)")
-        
         // 🔑 写入缓存
         if let key = cacheKey {
             IconBitmapCache.shared.setImage(image, forKey: key)