expo-gaode-map-navigation 2.0.12-next.0 → 2.0.13

package/shared/cpp/GeometryEngine.cpp

@@ -3,6 +3,7 @@
 #include <cmath>
 #include <map>
 #include <algorithm>
+#include <limits>
 
 namespace gaodemap {
 
@@ -19,6 +20,54 @@ static inline double geo_toDegrees(double radians) {
     return radians * kRadiansToDegrees;
 }
 
+static inline double clampMercatorLatitude(double lat) {
+    static constexpr double kMaxMercatorLatitude = 85.05112878;
+    if (lat > kMaxMercatorLatitude) return kMaxMercatorLatitude;
+    if (lat < -kMaxMercatorLatitude) return -kMaxMercatorLatitude;
+    return lat;
+}
+
+static inline double mercatorX01(double lon) {
+    double wrapped = std::fmod(lon + 180.0, 360.0);
+    if (wrapped < 0.0) {
+        wrapped += 360.0;
+    }
+    return wrapped / 360.0;
+}
+
+static inline double mercatorY01(double lat) {
+    const double clampedLat = clampMercatorLatitude(lat);
+    const double latRad = geo_toRadians(clampedLat);
+    const double y = (1.0 - std::asinh(std::tan(latRad)) / kPi) * 0.5;
+    if (y < 0.0) return 0.0;
+    if (y > 1.0) return 1.0;
+    return y;
+}
+
+static double wrappedSpan01(std::vector<double> xs) {
+    if (xs.size() <= 1) {
+        return 0.0;
+    }
+
+    std::sort(xs.begin(), xs.end());
+    double maxGap = 0.0;
+
+    for (size_t i = 0; i + 1 < xs.size(); ++i) {
+        const double gap = xs[i + 1] - xs[i];
+        if (gap > maxGap) {
+            maxGap = gap;
+        }
+    }
+
+    const double endGap = xs.front() + 1.0 - xs.back();
+    if (endGap > maxGap) {
+        maxGap = endGap;
+    }
+
+    const double span = 1.0 - maxGap;
+    return span < 0.0 ? 0.0 : span;
+}
+
 double calculateDistance(double lat1, double lon1, double lat2, double lon2) {
     const double radLat1 = geo_toRadians(lat1);
     const double radLat2 = geo_toRadians(lat2);
@@ -512,6 +561,69 @@ GeoPoint pixelToLatLng(double x, double y, int zoom) {
     return {lat, lon};
 }
 
+double calculateFitZoomForPoints(
+    const std::vector<GeoPoint>& points,
+    double viewportWidthPx,
+    double viewportHeightPx,
+    double paddingPx,
+    int minZoom,
+    int maxZoom
+) {
+    if (minZoom > maxZoom) {
+        std::swap(minZoom, maxZoom);
+    }
+    if (points.empty()) {
+        return static_cast<double>(minZoom);
+    }
+    if (points.size() == 1) {
+        return static_cast<double>(maxZoom);
+    }
+
+    const double safeViewportWidth = viewportWidthPx > 1.0 ? viewportWidthPx : 390.0;
+    const double safeViewportHeight = viewportHeightPx > 1.0 ? viewportHeightPx : 844.0;
+    const double safePadding = std::max(0.0, paddingPx);
+    const double availableWidth = std::max(1.0, safeViewportWidth - safePadding * 2.0);
+    const double availableHeight = std::max(1.0, safeViewportHeight - safePadding * 2.0);
+
+    std::vector<double> projectedXs;
+    projectedXs.reserve(points.size());
+
+    double minY = std::numeric_limits<double>::max();
+    double maxY = -std::numeric_limits<double>::max();
+
+    for (const auto& p : points) {
+        projectedXs.push_back(mercatorX01(p.lon));
+        const double y = mercatorY01(p.lat);
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+    }
+
+    const double spanX = wrappedSpan01(projectedXs);
+    const double spanY = std::max(0.0, maxY - minY);
+    static constexpr double kTileSize = 256.0;
+    static constexpr double kSpanEpsilon = 1e-12;
+
+    const double zoomX = spanX <= kSpanEpsilon
+        ? static_cast<double>(maxZoom)
+        : std::log2(availableWidth / (kTileSize * spanX));
+    const double zoomY = spanY <= kSpanEpsilon
+        ? static_cast<double>(maxZoom)
+        : std::log2(availableHeight / (kTileSize * spanY));
+
+    double fitZoom = std::min(zoomX, zoomY);
+    if (!std::isfinite(fitZoom)) {
+        fitZoom = static_cast<double>(minZoom);
+    }
+
+    if (fitZoom < static_cast<double>(minZoom)) {
+        fitZoom = static_cast<double>(minZoom);
+    } else if (fitZoom > static_cast<double>(maxZoom)) {
+        fitZoom = static_cast<double>(maxZoom);
+    }
+
+    return fitZoom;
+}
+
 // --- 批量地理围栏与热力图 ---
 
 int findPointInPolygons(double pointLat, double pointLon, const std::vector<std::vector<GeoPoint>>& polygons) {

package/shared/cpp/GeometryEngine.hpp

@@ -125,6 +125,27 @@ PixelResult latLngToPixel(double lat, double lon, int zoom);
  */
 GeoPoint pixelToLatLng(double x, double y, int zoom);
 
+/**
+ * 根据一组坐标点和视口尺寸计算“可同时看到所有点”的推荐缩放级别。
+ * 使用 Web Mercator 投影，在跨经线场景下会自动取更小经度跨度。
+ *
+ * @param points 坐标点集合，至少 1 个
+ * @param viewportWidthPx 视口宽度（像素）
+ * @param viewportHeightPx 视口高度（像素）
+ * @param paddingPx 四周预留的内边距（像素）
+ * @param minZoom 最小缩放级别
+ * @param maxZoom 最大缩放级别
+ * @return 推荐 zoom（已在 [minZoom, maxZoom] 范围内）
+ */
+double calculateFitZoomForPoints(
+    const std::vector<GeoPoint>& points,
+    double viewportWidthPx,
+    double viewportHeightPx,
+    double paddingPx,
+    int minZoom,
+    int maxZoom
+);
+
 // --- 批量地理围栏与热力图 ---
 
 /**

package/widget-template/README.md

@@ -0,0 +1,46 @@
+# iOS Live Activity Widget Extension 模板
+
+该目录提供 `ActivityConfiguration` 示例，用于展示 `expo-gaode-map-navigation` 在 iOS 锁屏和灵动岛的实时导航信息。
+
+## 文件
+
+- `ios/NavigationLiveActivityWidget.swift`：Widget Extension 入口与 UI。
+
+## 接入步骤
+
+1. 在 Xcode 中给你的 iOS App 新建 `Widget Extension`（iOS 16.1+）。
+2. 把 `ios/NavigationLiveActivityWidget.swift` 拖入新 Extension target，并确保 target membership 只勾选 Extension。
+3. Extension 代码需要 `import ExpoGaodeMapNavigation`，并使用库里提供的 `NavigationLiveActivityAttributes`。
+4. 在 `app.json/app.config.ts` 开启插件配置：
+
+```json
+[
+  "expo-gaode-map-navigation",
+  {
+    "enableIOSLiveActivity": true,
+    "enableIOSLiveActivityFrequentUpdates": true
+  }
+]
+```
+
+5. 导航组件开启运行时开关：
+
+```tsx
+<ExpoGaodeMapNaviView iosLiveActivityEnabled />
+```
+
+## Podfile（含 Extension 时）
+
+如果 Extension 无法 import `ExpoGaodeMapNavigation`，在 `ios/Podfile` 中为 Extension target 加上 `use_expo_modules!`：
+
+```ruby
+target 'YourNavigationWidgetExtension' do
+  use_expo_modules!
+end
+```
+
+然后执行：
+
+```bash
+cd ios && pod install
+```

package/widget-template/ios/NavigationLiveActivityWidget.swift

@@ -0,0 +1,367 @@
+import ActivityKit
+import SwiftUI
+import UIKit
+import WidgetKit
+import ExpoGaodeMapNavigation
+
+private struct TurnMeta {
+  let action: String
+}
+
+private func turnMeta(for iconType: Int) -> TurnMeta {
+  switch iconType {
+  case 2:
+    return TurnMeta(action: "左转")
+  case 3:
+    return TurnMeta(action: "右转")
+  case 4:
+    return TurnMeta(action: "左前方")
+  case 5:
+    return TurnMeta(action: "右前方")
+  case 6:
+    return TurnMeta(action: "左后方")
+  case 7:
+    return TurnMeta(action: "右后方")
+  case 8:
+    return TurnMeta(action: "左转调头")
+  case 9, 20:
+    return TurnMeta(action: "直行")
+  case 11, 12:
+    return TurnMeta(action: "环岛")
+  case 15:
+    return TurnMeta(action: "到达目的地")
+  case 19:
+    return TurnMeta(action: "右转调头")
+  case 65:
+    return TurnMeta(action: "靠左行驶")
+  case 66:
+    return TurnMeta(action: "靠右行驶")
+  default:
+    return TurnMeta(action: "继续")
+  }
+}
+
+private func formatDistanceCN(_ meters: Int, spacedUnit: Bool = false) -> String {
+  let safeMeters = max(meters, 0)
+  if safeMeters >= 1000 {
+    let kilometers = Double(safeMeters) / 1000.0
+    let value = kilometers >= 10 ? String(format: "%.0f", kilometers) : String(format: "%.1f", kilometers)
+    return spacedUnit ? "\(value) 公里" : "\(value)公里"
+  }
+  return spacedUnit ? "\(safeMeters) 米" : "\(safeMeters)米"
+}
+
+private func formatTimeCN(_ seconds: Int) -> String {
+  let safeSeconds = max(seconds, 0)
+  if safeSeconds >= 3600 {
+    return "约\(safeSeconds / 3600)小时\((safeSeconds % 3600) / 60)分钟"
+  }
+  return "约\(max(safeSeconds / 60, 1))分钟"
+}
+
+private func preferredRoadName(current: String, next: String) -> String {
+  if !next.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+    return next.trimmingCharacters(in: .whitespacesAndNewlines)
+  }
+  if !current.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+    return current.trimmingCharacters(in: .whitespacesAndNewlines)
+  }
+  return ""
+}
+
+private func compactInstruction(distanceMeters: Int, roadName: String, action: String) -> String {
+  if distanceMeters > 0 {
+    if roadName.isEmpty {
+      return "\(formatDistanceCN(distanceMeters))后\(action)"
+    }
+    return "\(formatDistanceCN(distanceMeters))后进入\(roadName)"
+  }
+
+  if !roadName.isEmpty {
+    return "进入\(roadName)"
+  }
+  return "正在导航"
+}
+
+private func liveTurnIconImage(base64: String?) -> Image? {
+  guard let base64, !base64.isEmpty, let data = Data(base64Encoded: base64) else {
+    return nil
+  }
+  guard let image = UIImage(data: data) else {
+    return nil
+  }
+  return Image(uiImage: image).renderingMode(.original)
+}
+
+private func routeProgress(remainDistance: Int, totalDistance: Int) -> Double {
+  guard totalDistance > 0 else {
+    return 0
+  }
+  let safeRemain = min(max(remainDistance, 0), totalDistance)
+  let finished = totalDistance - safeRemain
+  return min(max(Double(finished) / Double(totalDistance), 0), 1)
+}
+
+private func clampedProgress(_ value: Double) -> Double {
+  min(max(value, 0), 1)
+}
+
+private struct NavigationProgressTrack: View {
+  let progress: Double
+  var showsIndicator: Bool = true
+  var trackHeight: CGFloat = 7
+
+  var body: some View {
+    GeometryReader { proxy in
+      let width = max(proxy.size.width, 1)
+      let normalizedProgress = clampedProgress(progress)
+      let carWidth: CGFloat = 34
+      let trackYOffset: CGFloat = showsIndicator ? 5 : 0
+      let indicatorOffset = min(max(0, normalizedProgress * max(width - carWidth, 0)), max(width - carWidth, 0))
+      let fillWidth = min(width, max(trackHeight, indicatorOffset + (carWidth * 0.45)))
+
+      ZStack(alignment: .leading) {
+        Capsule(style: .continuous)
+          .fill(Color.white.opacity(0.18))
+          .frame(height: trackHeight)
+          .offset(y: trackYOffset)
+
+        Capsule(style: .continuous)
+          .fill(
+            LinearGradient(
+              colors: [
+                Color(red: 0.32, green: 0.78, blue: 0.98),
+                Color(red: 0.24, green: 0.70, blue: 0.98)
+              ],
+              startPoint: .leading,
+              endPoint: .trailing
+            )
+          )
+          .frame(width: fillWidth, height: trackHeight)
+          .offset(y: trackYOffset)
+
+        if showsIndicator {
+          ZStack {
+            Circle()
+              .fill(
+                LinearGradient(
+                  colors: [
+                    Color(red: 0.08, green: 0.66, blue: 0.96),
+                    Color(red: 0.18, green: 0.80, blue: 0.98)
+                  ],
+                  startPoint: .topLeading,
+                  endPoint: .bottomTrailing
+                )
+              )
+            Image(systemName: "car.side.fill")
+              .font(.system(size: 12, weight: .bold))
+              .foregroundStyle(.white)
+          }
+          .frame(width: 24, height: 24)
+          .shadow(color: Color.black.opacity(0.16), radius: 2, x: 0, y: 1)
+          .offset(x: indicatorOffset, y: trackYOffset)
+        }
+      }
+      .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .leading)
+    }
+    .frame(height: showsIndicator ? 24 : max(trackHeight, 4))
+  }
+}
+
+@main
+struct NavigationLiveActivityWidgetBundle: WidgetBundle {
+  var body: some Widget {
+    NavigationLiveActivityWidget()
+  }
+}
+
+struct NavigationLiveActivityWidget: Widget {
+  var body: some WidgetConfiguration {
+    ActivityConfiguration(for: NavigationLiveActivityAttributes.self) { context in
+      LockScreenNavigationLiveActivityView(context: context)
+        .activityBackgroundTint(.clear)
+        .activitySystemActionForegroundColor(.white)
+    } dynamicIsland: { context in
+      let meta = turnMeta(for: context.state.iconType)
+      let roadName = preferredRoadName(current: context.state.currentRoadName, next: context.state.nextRoadName)
+      let totalDistance = max(context.state.routeTotalDistance, max(context.state.pathRetainDistance, 0))
+      let progress = routeProgress(
+        remainDistance: context.state.pathRetainDistance,
+        totalDistance: totalDistance
+      )
+      let instruction = compactInstruction(
+        distanceMeters: max(context.state.curStepRetainDistance, 0),
+        roadName: roadName,
+        action: meta.action
+      )
+
+      return DynamicIsland {
+        DynamicIslandExpandedRegion(.leading) {
+          Group {
+            if let turnIconImage = liveTurnIconImage(base64: context.state.turnIconBase64) {
+              turnIconImage
+                .resizable()
+                .scaledToFit()
+                .padding(6)
+            } else {
+              Color.clear
+            }
+          }
+          .frame(width: 34, height: 34)
+        }
+
+        DynamicIslandExpandedRegion(.center) {
+          VStack(alignment: .leading, spacing: 4) {
+            Text(context.attributes.appName)
+              .font(.caption2)
+              .foregroundStyle(.white.opacity(0.75))
+            Text(instruction)
+              .font(.subheadline.weight(.semibold))
+              .foregroundStyle(.white)
+              .lineLimit(1)
+            NavigationProgressTrack(progress: progress, showsIndicator: false, trackHeight: 4)
+              .frame(height: 6)
+          }
+        }
+
+        DynamicIslandExpandedRegion(.trailing) {
+          Text(formatDistanceCN(context.state.pathRetainDistance))
+            .font(.caption.weight(.semibold))
+            .foregroundStyle(.white.opacity(0.92))
+        }
+      } compactLeading: {
+        Group {
+          if let turnIconImage = liveTurnIconImage(base64: context.state.turnIconBase64) {
+            turnIconImage
+              .resizable()
+              .scaledToFit()
+          } else {
+            Color.clear
+          }
+        }
+      } compactTrailing: {
+        Text(formatDistanceCN(context.state.curStepRetainDistance))
+          .font(.caption2)
+          .foregroundStyle(.white)
+      } minimal: {
+        Group {
+          if let turnIconImage = liveTurnIconImage(base64: context.state.turnIconBase64) {
+            turnIconImage
+              .resizable()
+              .scaledToFit()
+          } else {
+            Color.clear
+          }
+        }
+      }
+      .keylineTint(.white)
+    }
+  }
+}
+
+private struct LockScreenNavigationLiveActivityView: View {
+  let context: ActivityViewContext<NavigationLiveActivityAttributes>
+
+  private var meta: TurnMeta {
+    turnMeta(for: context.state.iconType)
+  }
+
+  private var roadName: String {
+    preferredRoadName(current: context.state.currentRoadName, next: context.state.nextRoadName)
+  }
+
+  private var stepDistanceText: String {
+    if context.state.iconType == 15 {
+      return "到达目的地"
+    }
+    let step = max(context.state.curStepRetainDistance, 0)
+    guard step > 0 else {
+      return meta.action == "继续" ? "继续前行" : meta.action
+    }
+    return formatDistanceCN(step, spacedUnit: true)
+  }
+
+  private var instructionText: String {
+    if context.state.iconType == 15 {
+      return ""
+    }
+    if !roadName.isEmpty {
+      return "进入 \(roadName)"
+    }
+    return meta.action == "继续" ? "正在导航" : meta.action
+  }
+
+  private var remainText: String {
+    "剩余 \(formatDistanceCN(context.state.pathRetainDistance, spacedUnit: true)) · \(formatTimeCN(context.state.pathRetainTime))"
+  }
+
+  private var routeTotalDistance: Int {
+    max(context.state.routeTotalDistance, max(context.state.pathRetainDistance, 0))
+  }
+
+  private var progressValue: Double {
+    routeProgress(remainDistance: context.state.pathRetainDistance, totalDistance: routeTotalDistance)
+  }
+
+  var body: some View {
+    ZStack {
+      RoundedRectangle(cornerRadius: 24, style: .continuous)
+        .fill(
+          LinearGradient(
+            colors: [
+              Color(red: 0.10, green: 0.12, blue: 0.19),
+              Color(red: 0.08, green: 0.10, blue: 0.16)
+            ],
+            startPoint: .topLeading,
+            endPoint: .bottomTrailing
+          )
+        )
+
+      VStack(alignment: .leading, spacing: 8) {
+        HStack(spacing: 14) {
+          Group {
+            if let turnIconImage = liveTurnIconImage(base64: context.state.turnIconBase64) {
+              turnIconImage
+                .resizable()
+                .scaledToFit()
+                .padding(12)
+            } else {
+              Color.clear
+            }
+          }
+          .frame(width: 78, height: 78)
+
+          VStack(alignment: .leading, spacing: 6) {
+            Text(stepDistanceText)
+              .font(.system(size: 38, weight: .heavy, design: .rounded))
+              .foregroundStyle(.white)
+              .lineLimit(1)
+              .minimumScaleFactor(0.65)
+
+            if !instructionText.isEmpty {
+              Text(instructionText)
+                .font(.system(size: 23, weight: .semibold, design: .rounded))
+                .foregroundStyle(.white.opacity(0.96))
+                .lineLimit(1)
+            }
+          }
+          .frame(maxWidth: .infinity, alignment: .leading)
+        }
+
+        NavigationProgressTrack(progress: progressValue, showsIndicator: true, trackHeight: 8)
+          .frame(height: 24)
+          .frame(maxWidth: .infinity, alignment: .leading)
+
+        Text(remainText)
+          .font(.system(size: 13, weight: .medium))
+          .foregroundStyle(.white.opacity(0.72))
+          .lineLimit(1)
+          .frame(maxWidth: .infinity, alignment: .center)
+      }
+      .frame(maxWidth: .infinity, alignment: .leading)
+      .padding(.horizontal, 16)
+      .padding(.vertical, 14)
+    }
+    .padding(.horizontal, 2)
+  }
+}