expo-gaode-map-navigation 2.0.10 → 2.0.11

package/ios/ExpoGaodeMapNaviViewModule.swift

@@ -51,6 +51,16 @@ public class ExpoGaodeMapNaviViewModule: Module {
         view.carImageSource = value
       }
 
+      Prop("carImageSize") { (view: ExpoGaodeMapNaviView, value: [String: Double]?) in
+        let width = CGFloat(value?["width"] ?? 0)
+        let height = CGFloat(value?["height"] ?? 0)
+        if width > 0, height > 0 {
+          view.carImageSize = CGSize(width: width, height: height)
+        } else {
+          view.carImageSize = nil
+        }
+      }
+
       Prop("carCompassImage") { (view: ExpoGaodeMapNaviView, value: String?) in
         view.carCompassImageSource = value
       }
@@ -63,6 +73,10 @@ public class ExpoGaodeMapNaviViewModule: Module {
         view.wayPointImageSource = value
       }
 
+      Prop("customWaypointMarkers") { (view: ExpoGaodeMapNaviView, value: [[String: Any]]?) in
+        view.customWaypointMarkerPayloads = value
+      }
+
       Prop("endPointImage") { (view: ExpoGaodeMapNaviView, value: String?) in
         view.endPointImageSource = value
       }
@@ -179,6 +193,14 @@ public class ExpoGaodeMapNaviViewModule: Module {
       Prop("hideNativeLaneInfoLayout") { (view: ExpoGaodeMapNaviView, value: Bool) in
         view.hideNativeLaneInfoLayout = value
       }
+
+      // Android-only prop, keep a no-op mapping on iOS for cross-platform prop compatibility.
+      Prop("androidBackgroundNavigationNotificationEnabled") { (_: ExpoGaodeMapNaviView, _: Bool) in
+      }
+
+      Prop("iosLiveActivityEnabled") { (view: ExpoGaodeMapNaviView, value: Bool) in
+        view.iosLiveActivityEnabled = value
+      }
       
       Prop("mapViewModeType") { (view: ExpoGaodeMapNaviView, value: Int) in
         view.mapViewModeType = value

package/ios/ExpoGaodeMapNavigationModule.swift

@@ -309,8 +309,11 @@ public class ExpoGaodeMapNavigationModule: Module {
     AsyncFunction("calculateMotorcycleRoute") { (options: [String: Any], promise: Promise) in
       do {
         try self.ensureInitialized()
-        // 摩托车复用驾车算路
-        self.ensureDriveTruck().calculateDriveRoute(options: options, promise: promise)
+        var motorcycleOptions = options
+        if motorcycleOptions["carType"] == nil && motorcycleOptions["type"] == nil {
+          motorcycleOptions["carType"] = 11
+        }
+        self.ensureDriveTruck().calculateDriveRoute(options: motorcycleOptions, promise: promise)
       } catch {
         self.rejectInitializationError(promise, error: error)
       }
@@ -321,8 +324,7 @@ public class ExpoGaodeMapNavigationModule: Module {
     AsyncFunction("calculateEBikeRoute") { (options: [String: Any], promise: Promise) in
       do {
         try self.ensureInitialized()
-        // 电动车复用骑行算路
-        self.ensureWalkRide().calculateRideRoute(options: options, promise: promise)
+        self.ensureWalkRide().calculateResolvedEleBikeRoute(options: options, promise: promise)
       } catch {
         self.rejectInitializationError(promise, error: error)
       }

package/ios/managers/IndependentRouteManager.swift

@@ -11,8 +11,14 @@ import AMapNaviKit
 
 class IndependentRouteManager {
   static let shared = IndependentRouteManager()
+
+  private struct Entry {
+    let scene: String
+    let routeGroup: AMapNaviRouteGroup?
+    let routeIds: [Int]
+  }
   
-  private var routeGroups: [Int: AMapNaviRouteGroup] = [:]
+  private var routeGroups: [Int: Entry] = [:]
   private var nextToken: Int = 1
   private let lock = NSLock()
   
@@ -26,10 +32,18 @@ class IndependentRouteManager {
   }
   
   /// 存储路线组（使用指定 token）
-  func storeRouteGroup(token: Int, routeGroup: AMapNaviRouteGroup) {
+  func storeRouteGroup(token: Int, scene: String = "drive", routeGroup: AMapNaviRouteGroup) {
+    lock.lock()
+    defer { lock.unlock() }
+    let routeIds = routeGroup.naviRouteIDs?.map { $0.intValue } ?? []
+    routeGroups[token] = Entry(scene: scene, routeGroup: routeGroup, routeIds: routeIds)
+  }
+
+  /// 存储非驾车场景的独立路径元信息
+  func storeSceneRoutes(token: Int, scene: String, routeIds: [Int]) {
     lock.lock()
     defer { lock.unlock() }
-    routeGroups[token] = routeGroup
+    routeGroups[token] = Entry(scene: scene, routeGroup: nil, routeIds: routeIds)
   }
   
   /// 存储路线组（自动生成 token）
@@ -38,7 +52,8 @@ class IndependentRouteManager {
     defer { lock.unlock() }
     let token = nextToken
     nextToken += 1
-    routeGroups[token] = routeGroup
+    let routeIds = routeGroup.naviRouteIDs?.map { $0.intValue } ?? []
+    routeGroups[token] = Entry(scene: "drive", routeGroup: routeGroup, routeIds: routeIds)
     return token
   }
   
@@ -46,7 +61,14 @@ class IndependentRouteManager {
   func get(_ token: Int) -> AMapNaviRouteGroup? {
     lock.lock()
     defer { lock.unlock() }
-    return routeGroups[token]
+    return routeGroups[token]?.routeGroup
+  }
+
+  /// 获取路线场景
+  func scene(for token: Int) -> String? {
+    lock.lock()
+    defer { lock.unlock() }
+    return routeGroups[token]?.scene
   }
   
   /// 行前选路 - 选择指定路线
@@ -55,32 +77,45 @@ class IndependentRouteManager {
     lock.lock()
     defer { lock.unlock() }
     
-    guard let routeGroup = routeGroups[token] else { return false }
-    
-    // 优先使用 routeId
-    if let routeId = routeId {
-      routeGroup.selectNaviRoute(withRouteID: routeId)
-      return true
+    guard let entry = routeGroups[token] else { return false }
+
+    let resolvedRouteId: Int? = {
+      if let routeId {
+        return routeId
+      }
+      if let routeIndex, routeIndex >= 0, routeIndex < entry.routeIds.count {
+        return entry.routeIds[routeIndex]
+      }
+      return nil
+    }()
+
+    guard let resolvedRouteId else {
+      return false
     }
-    
-    // 使用 routeIndex
-    if let routeIndex = routeIndex, let routeIDs = routeGroup.naviRouteIDs, routeIndex < routeIDs.count {
-      let routeId = routeIDs[routeIndex].intValue
-      routeGroup.selectNaviRoute(withRouteID: routeId)
+
+    if let routeGroup = entry.routeGroup {
+      routeGroup.selectNaviRoute(withRouteID: resolvedRouteId)
       return true
     }
-    
-    return false
+
+    switch entry.scene {
+    case "walk":
+      return AMapNaviWalkManager.sharedInstance().selectNaviRoute(withRouteID: resolvedRouteId)
+    case "ride":
+      return AMapNaviRideManager.sharedInstance().selectNaviRoute(withRouteID: resolvedRouteId)
+    default:
+      return false
+    }
   }
   
   /// 启动导航
   /// 官方方法：startGPSNavi: / startEmulatorNavi:
   func start(token: Int, naviType: Int, routeId: Int?, routeIndex: Int?) -> Bool {
     lock.lock()
-    let routeGroup = routeGroups[token]
+    let entry = routeGroups[token]
     lock.unlock()
     
-    guard let routeGroup = routeGroup else { return false }
+    guard let entry = entry else { return false }
     
     // 先选择路线
     if routeId != nil || routeIndex != nil {
@@ -89,13 +124,41 @@ class IndependentRouteManager {
     
     // 启动导航
     // naviType: 0 = GPS导航, 1 = 模拟导航
-    if naviType == 1 {
-      AMapNaviDriveManager.sharedInstance().startEmulatorNavi(routeGroup)
-    } else {
-      AMapNaviDriveManager.sharedInstance().startGPSNavi(routeGroup)
+    switch entry.scene {
+    case "walk":
+      if let routeGroup = entry.routeGroup {
+        if naviType == 1 {
+          return AMapNaviWalkManager.sharedInstance().startEmulatorNavi(routeGroup)
+        } else {
+          return AMapNaviWalkManager.sharedInstance().startGPSNavi(routeGroup)
+        }
+      }
+      if naviType == 1 {
+        return AMapNaviWalkManager.sharedInstance().startEmulatorNavi()
+      } else {
+        return AMapNaviWalkManager.sharedInstance().startGPSNavi()
+      }
+    case "ride":
+      if let routeGroup = entry.routeGroup {
+        if naviType == 1 {
+          return AMapNaviRideManager.sharedInstance().startEmulatorNavi(routeGroup)
+        } else {
+          return AMapNaviRideManager.sharedInstance().startGPSNavi(routeGroup)
+        }
+      }
+      if naviType == 1 {
+        return AMapNaviRideManager.sharedInstance().startEmulatorNavi()
+      } else {
+        return AMapNaviRideManager.sharedInstance().startGPSNavi()
+      }
+    default:
+      guard let routeGroup = entry.routeGroup else { return false }
+      if naviType == 1 {
+        return AMapNaviDriveManager.sharedInstance().startEmulatorNavi(routeGroup)
+      } else {
+        return AMapNaviDriveManager.sharedInstance().startGPSNavi(routeGroup)
+      }
     }
-    
-    return true
   }
   
   /// 清除指定路线组

package/ios/map/ExpoGaodeMapModule.swift

@@ -736,17 +736,31 @@ public class ExpoGaodeMapModule: Module {
                 promise.reject("FOREGROUND_PERMISSION_REQUIRED", "必须先授予前台位置权限才能请求后台位置权限")
                 return
             }
-            
-            // iOS 上后台权限通过 Info.plist 配置 + 系统设置
-            // 这里返回当前状态
-            let hasBackground = status == .authorizedAlways
-            
-            promise.resolve([
-                "granted": hasBackground,
-                "backgroundLocation": hasBackground,
-                "status": self.getAuthorizationStatusString(status),
-                "message": hasBackground ? "已授予后台权限" : "需要在系统设置中手动授予'始终'权限"
-            ])
+
+            if self.permissionManager == nil {
+                self.permissionManager = PermissionManager()
+            }
+
+            guard let permissionManager = self.permissionManager else {
+                promise.reject("PERMISSION_MANAGER_INIT_FAILED", "权限管理器初始化失败")
+                return
+            }
+
+            permissionManager.requestAlwaysPermission { _, _ in
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                    let finalStatus = self.currentAuthorizationStatus()
+                    let hasBackground = finalStatus == .authorizedAlways
+
+                    promise.resolve([
+                        "granted": hasBackground,
+                        "backgroundLocation": hasBackground,
+                        "status": self.getAuthorizationStatusString(finalStatus),
+                        "message": hasBackground
+                            ? "已授予后台权限"
+                            : "后台权限未授予，请在系统设置中将定位权限改为“始终允许”"
+                    ])
+                }
+            }
         }
         
   

package/ios/map/modules/LocationManager.swift

@@ -90,7 +90,16 @@ class LocationManager: NSObject, AMapLocationManagerDelegate {
                 return
             }
         }
-        ensureLocationManager()?.allowsBackgroundLocationUpdates = allows
+        guard let manager = ensureLocationManager() else {
+            return
+        }
+        manager.allowsBackgroundLocationUpdates = allows
+        if #available(iOS 11.0, *) {
+            let indicatorSelector = NSSelectorFromString("setShowsBackgroundLocationIndicator:")
+            if manager.responds(to: indicatorSelector) {
+                manager.setValue(allows, forKey: "showsBackgroundLocationIndicator")
+            }
+        }
     }
 
     func setGeoLanguage(_ language: Int) {

package/ios/map/utils/PermissionManager.swift

@@ -39,6 +39,39 @@ class PermissionManager: NSObject, CLLocationManagerDelegate {
     private var locationManager: CLLocationManager?
     /// 权限请求回调
     private var permissionCallback: ((Bool, String) -> Void)?
+    /// 后台（始终）权限请求回调
+    private var backgroundPermissionCallback: ((Bool, String) -> Void)?
+    /// 在 notDetermined 状态下，先申请前台权限，再升级为始终权限
+    private var pendingAlwaysAuthorizationUpgrade = false
+
+    private func resolveBackgroundPermissionIfNeeded(_ status: CLAuthorizationStatus) {
+        guard let backgroundPermissionCallback else {
+            return
+        }
+        let backgroundGranted = status == .authorizedAlways
+        backgroundPermissionCallback(backgroundGranted, getAuthorizationStatusString(status))
+        self.backgroundPermissionCallback = nil
+    }
+
+    private func scheduleAlwaysAuthorizationFallback(_ manager: CLLocationManager) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) { [weak self] in
+            guard let self else {
+                return
+            }
+            guard self.backgroundPermissionCallback != nil else {
+                return
+            }
+
+            let latestStatus: CLAuthorizationStatus
+            if #available(iOS 14.0, *) {
+                latestStatus = manager.authorizationStatus
+            } else {
+                latestStatus = CLLocationManager.authorizationStatus()
+            }
+            self.pendingAlwaysAuthorizationUpgrade = false
+            self.resolveBackgroundPermissionIfNeeded(latestStatus)
+        }
+    }
     
     /**
      * 请求位置权限
@@ -92,6 +125,61 @@ class PermissionManager: NSObject, CLLocationManagerDelegate {
             locationManager.requestWhenInUseAuthorization()
         }
     }
+
+    /**
+     * 请求后台（始终）位置权限
+     * @param callback 权限结果回调 (granted, status)
+     */
+    func requestAlwaysPermission(callback: @escaping (Bool, String) -> Void) {
+        self.backgroundPermissionCallback = callback
+
+        DispatchQueue.main.async {
+            if self.locationManager == nil {
+                self.locationManager = CLLocationManager()
+            }
+
+            guard let locationManager = self.locationManager else {
+                self.backgroundPermissionCallback?(false, "unknown")
+                self.backgroundPermissionCallback = nil
+                self.pendingAlwaysAuthorizationUpgrade = false
+                return
+            }
+
+            locationManager.delegate = self
+
+            let currentStatus: CLAuthorizationStatus
+            if #available(iOS 14.0, *) {
+                currentStatus = locationManager.authorizationStatus
+            } else {
+                currentStatus = CLLocationManager.authorizationStatus()
+            }
+
+            if currentStatus == .authorizedAlways {
+                self.backgroundPermissionCallback?(true, self.getAuthorizationStatusString(currentStatus))
+                self.backgroundPermissionCallback = nil
+                self.pendingAlwaysAuthorizationUpgrade = false
+                return
+            }
+
+            if currentStatus == .denied || currentStatus == .restricted {
+                self.backgroundPermissionCallback?(false, self.getAuthorizationStatusString(currentStatus))
+                self.backgroundPermissionCallback = nil
+                self.pendingAlwaysAuthorizationUpgrade = false
+                return
+            }
+
+            if currentStatus == .authorizedWhenInUse {
+                self.pendingAlwaysAuthorizationUpgrade = false
+                locationManager.requestAlwaysAuthorization()
+                self.scheduleAlwaysAuthorizationFallback(locationManager)
+                return
+            }
+
+            // notDetermined: 先请求前台定位，再在回调中升级到始终权限
+            self.pendingAlwaysAuthorizationUpgrade = true
+            locationManager.requestWhenInUseAuthorization()
+        }
+    }
     
     /**
      * 权限状态变化回调 (iOS 14+)
@@ -115,6 +203,18 @@ class PermissionManager: NSObject, CLLocationManagerDelegate {
         if status == .notDetermined {
             return
         }
+
+        if pendingAlwaysAuthorizationUpgrade && status == .authorizedWhenInUse {
+            pendingAlwaysAuthorizationUpgrade = false
+            if let locationManager {
+                locationManager.requestAlwaysAuthorization()
+                scheduleAlwaysAuthorizationFallback(locationManager)
+            } else {
+                resolveBackgroundPermissionIfNeeded(status)
+            }
+            return
+        }
+        pendingAlwaysAuthorizationUpgrade = false
         
         // 状态已确定(授予或拒绝),返回结果
         var granted = false
@@ -125,6 +225,8 @@ class PermissionManager: NSObject, CLLocationManagerDelegate {
         }
         let statusString = getAuthorizationStatusString(status)
         
+        resolveBackgroundPermissionIfNeeded(status)
+
         permissionCallback?(granted, statusString)
         permissionCallback = nil
     }
@@ -236,6 +338,8 @@ class PermissionManager: NSObject, CLLocationManagerDelegate {
         locationManager?.delegate = nil
         locationManager = nil
         permissionCallback = nil
+        backgroundPermissionCallback = nil
+        pendingAlwaysAuthorizationUpgrade = false
     }
 }
 #endif