expo-gaode-map-navigation 1.1.5-next.1 → 1.1.5-next.2

package/ios/map/ExpoGaodeMapViewModule.swift

@@ -4,104 +4,126 @@ import AMapNaviKit
 /**
  * 高德地图视图 Module
  */
-public class NaviMapViewModule: Module {
+public class ExpoGaodeMapViewModule: Module {
     public func definition() -> ModuleDefinition {
-        Name("NaviMapView")
+        Name("ExpoGaodeMapView")
         
-        View(NaviMapView.self) {
+        View(ExpoGaodeMapView.self) {
             Events("onMapPress", "onMapLongPress", "onLoad", "onLocation", "onCameraMove", "onCameraIdle")
             
-            Prop("mapType") { (view: NaviMapView, type: Int) in
+            Prop("mapType") { (view: ExpoGaodeMapView, type: Int) in
                 view.mapType = type
             }
             
-            Prop("initialCameraPosition") { (view: NaviMapView, position: [String: Any]?) in
+            Prop("initialCameraPosition") { (view: ExpoGaodeMapView, position: [String: Any]?) in
                 view.initialCameraPosition = position
             }
             
-            Prop("maxZoom") { (view: NaviMapView, zoom: Double) in
+            Prop("maxZoom") { (view: ExpoGaodeMapView, zoom: Double) in
                 view.setMaxZoom(zoom)
             }
             
-            Prop("minZoom") { (view: NaviMapView, zoom: Double) in
+            Prop("minZoom") { (view: ExpoGaodeMapView, zoom: Double) in
                 view.setMinZoom(zoom)
             }
             
-            Prop("zoomControlsEnabled") { (view: NaviMapView, show: Bool) in
+            Prop("zoomControlsEnabled") { (view: ExpoGaodeMapView, show: Bool) in
                 view.showsZoomControls = show
             }
             
-            Prop("compassEnabled") { (view: NaviMapView, show: Bool) in
+            Prop("compassEnabled") { (view: ExpoGaodeMapView, show: Bool) in
                 view.showsCompass = show
             }
             
-            Prop("scaleControlsEnabled") { (view: NaviMapView, show: Bool) in
+            Prop("scaleControlsEnabled") { (view: ExpoGaodeMapView, show: Bool) in
                 view.showsScale = show
             }
             
-            Prop("zoomGesturesEnabled") { (view: NaviMapView, enabled: Bool) in
+            Prop("zoomGesturesEnabled") { (view: ExpoGaodeMapView, enabled: Bool) in
                 view.isZoomEnabled = enabled
             }
             
-            Prop("scrollGesturesEnabled") { (view: NaviMapView, enabled: Bool) in
+            Prop("scrollGesturesEnabled") { (view: ExpoGaodeMapView, enabled: Bool) in
                 view.isScrollEnabled = enabled
             }
             
-            Prop("rotateGesturesEnabled") { (view: NaviMapView, enabled: Bool) in
+            Prop("rotateGesturesEnabled") { (view: ExpoGaodeMapView, enabled: Bool) in
                 view.isRotateEnabled = enabled
             }
             
-            Prop("tiltGesturesEnabled") { (view: NaviMapView, enabled: Bool) in
+            Prop("tiltGesturesEnabled") { (view: ExpoGaodeMapView, enabled: Bool) in
                 view.isTiltEnabled = enabled
             }
             
-            Prop("myLocationEnabled") { (view: NaviMapView, show: Bool) in
+            Prop("myLocationEnabled") { (view: ExpoGaodeMapView, show: Bool) in
                 view.setShowsUserLocation(show)
             }
             
-            Prop("followUserLocation") { (view: NaviMapView, follow: Bool) in
+            Prop("followUserLocation") { (view: ExpoGaodeMapView, follow: Bool) in
                 view.setFollowUserLocation(follow)
             }
             
-            Prop("userLocationRepresentation") { (view: NaviMapView, config: [String: Any]) in
+            Prop("userLocationRepresentation") { (view: ExpoGaodeMapView, config: [String: Any]) in
                 view.setUserLocationRepresentation(config)
             }
             
-            Prop("trafficEnabled") { (view: NaviMapView, show: Bool) in
+            Prop("trafficEnabled") { (view: ExpoGaodeMapView, show: Bool) in
                 view.setShowsTraffic(show)
             }
             
-            Prop("buildingsEnabled") { (view: NaviMapView, show: Bool) in
+            Prop("buildingsEnabled") { (view: ExpoGaodeMapView, show: Bool) in
                 view.setShowsBuildings(show)
             }
             
-            Prop("indoorViewEnabled") { (view: NaviMapView, show: Bool) in
+            Prop("indoorViewEnabled") { (view: ExpoGaodeMapView, show: Bool) in
                 view.setShowsIndoorMap(show)
             }
             
-            OnViewDidUpdateProps { (view: NaviMapView) in
+            Prop("customMapStyle") { (view: ExpoGaodeMapView, styleData: [String: Any]?) in
+                if let styleData = styleData {
+                    view.setCustomMapStyle(styleData)
+                }
+            }
+            
+            Prop("worldMapSwitchEnabled") { (view: ExpoGaodeMapView, enabled: Bool) in
+                view.enableWorldMapSwitch = enabled
+            }
+            
+            OnViewDidUpdateProps { (view: ExpoGaodeMapView) in
                 view.applyProps()
             }
             
-            AsyncFunction("moveCamera") { (view: NaviMapView, position: [String: Any], duration: Int) in
+            AsyncFunction("moveCamera") { (view: ExpoGaodeMapView, position: [String: Any], duration: Int) in
                 view.moveCamera(position: position, duration: duration)
             }
             
-            AsyncFunction("getLatLng") { (view: NaviMapView, point: [String: Double]) -> [String: Double] in
+            AsyncFunction("getLatLng") { (view: ExpoGaodeMapView, point: [String: Double]) -> [String: Double] in
                 return view.getLatLng(point: point)
             }
             
-            AsyncFunction("setCenter") { (view: NaviMapView, center: [String: Double], animated: Bool) in
+            AsyncFunction("setCenter") { (view: ExpoGaodeMapView, center: [String: Double], animated: Bool) in
                 view.setCenter(center: center, animated: animated)
             }
             
-            AsyncFunction("setZoom") { (view: NaviMapView, zoom: Double, animated: Bool) in
+            AsyncFunction("setZoom") { (view: ExpoGaodeMapView, zoom: Double, animated: Bool) in
                 view.setZoom(zoom: zoom, animated: animated)
             }
             
-            AsyncFunction("getCameraPosition") { (view: NaviMapView) -> [String: Any] in
+            AsyncFunction("getCameraPosition") { (view: ExpoGaodeMapView) -> [String: Any] in
                 return view.getCameraPosition()
             }
+            
+            AsyncFunction("takeSnapshot") { (view: ExpoGaodeMapView, promise: Promise) in
+                DispatchQueue.main.async {
+                    view.takeSnapshot { path, error in
+                        if let path = path {
+                            promise.resolve(path)
+                        } else {
+                            promise.reject("SNAPSHOT_FAILED", error?.localizedDescription ?? "Failed to take snapshot")
+                        }
+                    }
+                }
+            }
           
         }
     }

package/ios/map/MapPreloadManager.swift

@@ -0,0 +1,348 @@
+/**
+ * 地图预加载管理器 (iOS)
+ * 在后台预先初始化地图实例，提升首次显示速度
+ */
+
+import Foundation
+import AMapFoundationKit
+import AMapNaviKit
+
+/// 预加载实例数据
+struct PreloadedMapInstance {
+    let mapView: MAMapView
+    let timestamp: Date
+}
+
+/// 地图预加载管理器
+///
+class MapPreloadManager {
+    static let shared = MapPreloadManager()
+    
+    // 动态池大小配置（根据内存自适应）
+    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 currentMaxPoolSize = 2
+    private var currentTTL: TimeInterval = 5 * 60
+    private var memoryPressureLevel = 0  // 0=正常, 1=压力, 2=严重
+    
+    // 定期清理任务
+    private var cleanupTimer: Timer?
+
+    private init() {
+     
+        
+        // 注册内存警告监听
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleMemoryWarning),
+            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 {
+        }
+    }
+    
+    /// 处理内存警告
+    @objc private func handleMemoryWarning() {
+      
+        clearPool()
+    }
+    
+    /// 开始预加载地图实例（自适应版本）
+    /// - Parameter poolSize: 预加载的地图实例数量（会根据内存自适应调整）
+    func startPreload(poolSize: Int) {
+        guard !isPreloading else {
+         
+            return
+        }
+        
+        // 动态计算最优池大小
+        let adaptiveMaxPoolSize = calculateAdaptivePoolSize()
+        currentMaxPoolSize = adaptiveMaxPoolSize
+        
+        // 动态调整 TTL
+        currentTTL = calculateAdaptiveTTL()
+        
+        // 检查内存是否充足
+        guard hasEnoughMemory() else {
+           
+            return
+        }
+        
+        isPreloading = true
+        let targetSize = min(poolSize, adaptiveMaxPoolSize)
+        
+        for _ in 0..<targetSize {
+            preloadGroup.enter()  // 进入预加载队列
+            
+            preloadQueue.async { [weak self] in
+                guard let self = self else { return }
+                autoreleasepool {
+                    // 创建地图视图
+                    let mapView = self.createPreloadedMapView()
+
+                    // 将地图实例添加到池中（带时间戳）
+                    DispatchQueue.main.async {
+                        let instance = PreloadedMapInstance(mapView: mapView, timestamp: Date())
+                        self.preloadedMapInstances.append(instance)
+                        self.preloadGroup.leave()
+                    }
+                }
+            }
+        }
+        
+        // 等待所有实例加载完成
+        preloadGroup.notify(queue: DispatchQueue.main) {
+            self.isPreloading = false
+        }
+    }
+    
+    /// 创建预加载的地图视图
+    /// - Returns: 预加载的地图视图实例
+    private func createPreloadedMapView() -> MAMapView {
+        var mapView: MAMapView!
+        
+        // 检查是否已在主线程，避免死锁
+        if Thread.isMainThread {
+            mapView = MAMapView()
+            configureMapView(mapView)
+        } else {
+            // 确保在主线程中创建 MAMapView
+            DispatchQueue.main.sync {
+                mapView = MAMapView()
+                self.configureMapView(mapView)
+            }
+        }
+        return mapView
+    }
+    
+    /// 配置地图视图的基础属性
+    /// - Parameter mapView: 需要配置的地图视图
+    private func configureMapView(_ mapView: MAMapView) {
+        // 基础配置
+        mapView.mapType = .standard
+        mapView.showsUserLocation = false
+        mapView.showsCompass = false
+        mapView.showsScale = false
+        mapView.isZoomEnabled = true
+        mapView.isScrollEnabled = true
+        mapView.isRotateEnabled = true
+        
+        // 预加载中心区域（北京天安门）
+        let centerCoordinate = CLLocationCoordinate2D(latitude: 39.9042, longitude: 116.4074)
+        mapView.setCenter(centerCoordinate, animated: false)
+        mapView.setZoomLevel(12, animated: false)
+        
+        // 设置一个最小的 frame 以触发地图渲染
+        mapView.frame = CGRect(x: 0, y: 0, width: 1, height: 1)
+        
+        // 触发地图初始化
+        mapView.layoutIfNeeded()
+    }
+    
+    /// 计算自适应池大小
+    /// 根据可用内存动态调整池大小
+    private func calculateAdaptivePoolSize() -> Int {
+        let availableMB = getAvailableMemoryMB()
+        
+        switch availableMB {
+        case 500...:
+            return maxPoolSizeHighMemory
+        case 300..<500:
+            return maxPoolSizeMediumMemory
+        case 150..<300:
+            return maxPoolSizeLowMemory
+        default:
+            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
+            return ttlNormal
+        case 60..<80:
+            memoryPressureLevel = 1
+            return ttlMemoryPressure
+        default:
+            memoryPressureLevel = 2
+            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
+    }
+    
+
+    /// 清空预加载池
+    func clearPool() {
+        _ = preloadedMapInstances.count
+        preloadedMapInstances.removeAll()
+    }
+    
+    /// 获取预加载状态（包含动态配置信息）
+    /// - Returns: 预加载状态信息
+    func getStatus() -> [String: Any] {
+        return [
+            "poolSize": preloadedMapInstances.count,
+            "isPreloading": isPreloading,
+            "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
+        ]
+    }
+    
+    /// 获取一个预加载的地图实例（使用动态 TTL）
+    /// - Returns: 预加载的地图视图，如果池为空则返回 null
+    func getPreloadedMapView() -> MAMapView? {
+        let now = Date()
+        
+        // 检查并移除过期实例
+        while let instance = preloadedMapInstances.first {
+            if now.timeIntervalSince(instance.timestamp) > currentTTL {
+                preloadedMapInstances.removeFirst()
+                // 可以在这里做一些清理工作，比如清理 delegate
+            } else {
+                break
+            }
+        }
+        
+        if !preloadedMapInstances.isEmpty {
+            let instance = preloadedMapInstances.removeFirst()
+            
+            // 触发自动补充（延迟执行，避免影响当前页面渲染）
+            triggerRefill()
+            
+            return instance.mapView
+        }
+        
+        // 尝试触发补充，以便下次使用
+        triggerRefill()
+        
+        return nil
+    }
+    
+    /// 触发自动补充机制
+    private func triggerRefill() {
+        guard !isPreloading else { return }
+        
+        // 延迟 5 秒后尝试补充，避免抢占当前 UI 资源
+        DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) { [weak self] in
+            guard let self = self else { return }
+            
+            if !self.isPreloading && self.preloadedMapInstances.count < self.currentMaxPoolSize {
+              
+                self.startPreload(poolSize: self.currentMaxPoolSize)
+            }
+        }
+    }
+
+    /// 检查是否有可用的预加载实例
+    /// - Returns: 是否有可用实例
+    func hasPreloadedMapView() -> Bool {
+        return !preloadedMapInstances.isEmpty
+    }
+
+    func cleanup() {
+        cleanupTimer?.invalidate()
+        cleanupTimer = nil
+        clearPool()
+    }
+    
+    deinit {
+        cleanupTimer?.invalidate()
+        NotificationCenter.default.removeObserver(self)
+    }
+}
+

package/ios/map/cpp/ClusterEngine.cpp

@@ -0,0 +1,110 @@
+#include "ClusterEngine.hpp"
+#include "QuadTree.hpp"
+#include <cmath>
+#include <algorithm>
+
+namespace gaodemap {
+
+// Removed duplicate toRadians definition, using inline or shared utility in future
+// For now, let's keep it static but rename to avoid conflict in unity build
+static inline double cluster_toRadians(double degrees) {
+    return degrees * 0.017453292519943295;
+}
+
+static double haversineMeters(const ClusterPoint& a, const ClusterPoint& b) {
+    const double lat1 = cluster_toRadians(a.lat);
+    const double lat2 = cluster_toRadians(b.lat);
+    const double dLat = lat2 - lat1;
+    const double dLon = cluster_toRadians(b.lon - a.lon);
+
+    const double sinHalfLat = std::sin(dLat * 0.5);
+    const double sinHalfLon = std::sin(dLon * 0.5);
+
+    const double h = sinHalfLat * sinHalfLat + std::cos(lat1) * std::cos(lat2) * sinHalfLon * sinHalfLon;
+    const double c = 2.0 * std::atan2(std::sqrt(h), std::sqrt(1.0 - h));
+
+    return 6371000.0 * c;
+}
+
+std::vector<ClusterOutput> clusterPoints(const std::vector<ClusterPoint>& points, double radiusMeters) {
+    std::vector<ClusterOutput> clusters;
+
+    if (points.empty() || radiusMeters <= 0.0) {
+        return clusters;
+    }
+
+    // 1. Build QuadTree
+    // Determine bounds
+    double minLat = 90.0, maxLat = -90.0, minLon = 180.0, maxLon = -180.0;
+    int maxIndex = -1;
+    
+    for (const auto& p : points) {
+        if (p.lat < minLat) minLat = p.lat;
+        if (p.lat > maxLat) maxLat = p.lat;
+        if (p.lon < minLon) minLon = p.lon;
+        if (p.lon > maxLon) maxLon = p.lon;
+        if (p.index > maxIndex) maxIndex = p.index;
+    }
+    
+    // Add some buffer
+    BoundingBox worldBounds{minLat - 1.0, minLon - 1.0, maxLat + 1.0, maxLon + 1.0};
+    QuadTree tree(worldBounds);
+    
+    for (const auto& p : points) {
+        tree.insert(p);
+    }
+
+    // 2. Cluster
+    // Use maxIndex to size the visited array correctly.
+    // If points is empty, maxIndex is -1, but we checked empty above.
+    // Ensure vector size is at least maxIndex + 1
+    std::vector<bool> globalVisited((maxIndex >= 0 ? maxIndex + 1 : 0), false);
+    
+    // Approximate degrees for radius (very rough, improves performance)
+    // 1 degree lat ~= 111km. 
+    double latDegree = radiusMeters / 111000.0;
+    
+    for (const auto& p : points) {
+        if (p.index < 0 || p.index >= globalVisited.size()) continue; // Safety check
+        if (globalVisited[p.index]) continue;
+
+        ClusterOutput cluster;
+        cluster.centerIndex = p.index;
+        cluster.indices.push_back(p.index);
+        globalVisited[p.index] = true;
+
+        // Query QuadTree
+        // Adjust lonDegree based on current latitude
+        // cos can be 0 at poles, handle it
+        double cosLat = std::cos(cluster_toRadians(p.lat));
+        double lonDegree;
+        if (std::abs(cosLat) < 0.00001) {
+             lonDegree = 360.0; // At poles, everything is close in longitude
+        } else {
+             lonDegree = radiusMeters / (111000.0 * std::abs(cosLat));
+        }
+        
+        // Bounding box for query
+        BoundingBox range{p.lat - latDegree, p.lon - lonDegree, p.lat + latDegree, p.lon + lonDegree};
+        
+        std::vector<ClusterPoint> neighbors;
+        tree.query(range, neighbors);
+
+        for (const auto& neighbor : neighbors) {
+            if (neighbor.index < 0 || neighbor.index >= globalVisited.size()) continue;
+            if (globalVisited[neighbor.index]) continue;
+            
+            // Precise check
+            if (haversineMeters(p, neighbor) <= radiusMeters) {
+                cluster.indices.push_back(neighbor.index);
+                globalVisited[neighbor.index] = true;
+            }
+        }
+        
+        clusters.push_back(std::move(cluster));
+    }
+
+    return clusters;
+}
+
+}

package/ios/map/cpp/ClusterEngine.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <vector>
+
+namespace gaodemap {
+
+struct ClusterPoint {
+    double lat;
+    double lon;
+    int index;
+};
+
+struct ClusterOutput {
+    int centerIndex;
+    std::vector<int> indices;
+};
+
+std::vector<ClusterOutput> clusterPoints(const std::vector<ClusterPoint>& points, double radiusMeters);
+
+}