expo-gaode-map-navigation 1.0.1-next.0

package/android/src/main/java/expo/modules/gaodemap/navigation/ExpoGaodeMapNaviViewModule.kt

@@ -0,0 +1,115 @@
+package expo.modules.gaodemap.navigation
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * 高德导航视图 Module
+ */
+class ExpoGaodeMapNaviViewModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoGaodeMapNaviView")
+
+    View(ExpoGaodeMapNaviView::class) {
+      Events(
+        "onNavigationReady",
+        "onNavigationStarted",
+        "onNavigationFailed",
+        "onNavigationEnded",
+        "onLocationUpdate",
+        "onNavigationText",
+        "onArriveDestination",
+        "onRouteCalculated",
+        "onRouteRecalculate",
+        "onWayPointArrived",
+        "onGpsStatusChanged",
+        "onNavigationInfoUpdate",
+        "onGpsSignalWeak"
+      )
+
+      OnViewDestroys { view: ExpoGaodeMapNaviView ->
+        view.onDestroy()
+      }
+
+      // Props
+      Prop<Int>("naviType") { view, type ->
+        view.applyNaviType(type)
+      }
+      
+      Prop<Boolean>("enableVoice") { view, enabled ->
+        view.applyEnableVoice(enabled)
+      }
+      
+      Prop<Boolean>("autoLockCar") { view, enabled ->
+        view.applyAutoLockCar(enabled)
+      }
+      
+      Prop<Boolean>("autoChangeZoom") { view, enabled ->
+        view.applyAutoChangeZoom(enabled)
+      }
+      
+      Prop<Boolean>("trafficLayerEnabled") { view, enabled ->
+        view.applyTrafficLayerEnabled(enabled)
+      }
+      
+      Prop<Boolean>("realCrossDisplay") { view, enabled ->
+        view.applyRealCrossDisplay(enabled)
+      }
+      
+      Prop<Int>("naviMode") { view, mode ->
+        view.applyNaviMode(mode)
+      }
+      
+      Prop<Int>("showMode") { view, mode ->
+        view.applyShowMode(mode)
+      }
+      
+      Prop<Boolean>("isNightMode") { view, enabled ->
+        view.applyNightMode(enabled)
+      }
+      
+      Prop<Boolean>("carOverlayVisible") { view, visible ->
+        view.applyCarOverlayVisible(visible)
+      }
+      
+      Prop<Boolean>("trafficLightsVisible") { view, visible ->
+        view.applyTrafficLightsVisible(visible)
+      }
+      
+      Prop<Map<String, Boolean>?>("routeMarkerVisible") { view, config ->
+        config?.let {
+          val showStartEndVia = it["showStartEndVia"] as? Boolean ?: true
+          val showFootFerry = it["showFootFerry"] as? Boolean ?: true
+          val showForbidden = it["showForbidden"] as? Boolean ?: true
+          val showRouteStartIcon = it["showRouteStartIcon"] as? Boolean ?: true
+          val showRouteEndIcon = it["showRouteEndIcon"] as? Boolean ?: true
+          view.applyRouteMarkerVisible(showStartEndVia, showFootFerry, showForbidden, showRouteStartIcon, showRouteEndIcon)
+        }
+      }
+      
+      // 路线转向箭头可见性控制
+      Prop<Boolean>("naviArrowVisible") { view, visible ->
+        view.applyNaviArrowVisible(visible)
+      }
+      
+      // 是否显示拥堵气泡
+      Prop<Boolean>("showDriveCongestion") { view, show ->
+        view.applyShowDriveCongestion(show)
+      }
+      
+      // 是否显示红绿灯倒计时气泡
+      Prop<Boolean>("showTrafficLightView") { view, show ->
+        view.applyShowTrafficLightView(show)
+      }
+      
+      // 方法
+      AsyncFunction("startNavigation") { view: ExpoGaodeMapNaviView, startLat: Double, startLng: Double, endLat: Double, endLng: Double, promise: expo.modules.kotlin.Promise ->
+        view.startNavigation(startLat, startLng, endLat, endLng, promise)
+      }
+      
+      AsyncFunction("stopNavigation") { view: ExpoGaodeMapNaviView, promise: expo.modules.kotlin.Promise ->
+        view.stopNavigation(promise)
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/gaodemap/navigation/ExpoGaodeMapNavigationModule.kt

@@ -0,0 +1,317 @@
+package expo.modules.gaodemap.navigation
+
+import android.content.Context
+import com.amap.api.navi.AMapNavi
+import com.amap.api.navi.model.AMapCarInfo
+import com.amap.api.navi.model.AMapNaviPathGroup
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.gaodemap.navigation.routes.drive.DriveTruckRouteCalculator
+import expo.modules.gaodemap.navigation.routes.walkride.WalkRideRouteCalculator
+import expo.modules.gaodemap.navigation.routes.ebike.EbikeRouteCalculator
+import expo.modules.gaodemap.navigation.listeners.IndependentRouteListener
+import expo.modules.gaodemap.navigation.utils.Converters
+import expo.modules.gaodemap.navigation.managers.IndependentRouteManager
+import expo.modules.gaodemap.navigation.services.IndependentRouteService
+
+
+/**
+ * 高德地图导航模块
+ *
+ * 仅保留：路径规划（拆分为与官方文档一致的类别）
+ * 1. 驾车/货车 路线规划（routes/drive）
+ * 2. 骑行/步行 路线规划（routes/walkride）
+ * 3. 独立路径规划（归属到各自类别的算路能力；不涉及 UI）
+ * 4. 摩托车路径规划（临时以骑行 API 代替，后续可独立扩展）
+ * 5. 骑行电动车路径规划（临时以骑行 API 代替，后续可独立扩展）
+ *
+ * 说明：
+ * - 官方导航界面请使用 NaviView 组件（ExpoGaodeMapNaviViewModule）
+ * - 不包含：智能巡航、语音控制、无界面导航控制等
+ */
+class ExpoGaodeMapNavigationModule : Module() {
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exception("React context is null")
+
+  // 分门别类的算路计算器（与官方文档分类一致）
+  private var driveTruckCalculator: DriveTruckRouteCalculator? = null
+  private var walkRideCalculator: WalkRideRouteCalculator? = null
+  private var ebikeCalculator: EbikeRouteCalculator? = null
+
+  // 独立路径规划：在原生侧暂存路线组，委托独立管理器，避免 Module 膨胀
+  private val independentRouteManager = IndependentRouteManager()
+  private var independentRouteService: IndependentRouteService? = null
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoGaodeMapNavigation")
+
+    // 仅保留算路相关事件（用于需要事件的场景；Promise 也会在 Listener 中完成）
+    Events(
+      "onCalculateRouteSuccess",
+      "onCalculateRouteFailure"
+    )
+
+    OnDestroy {
+      driveTruckCalculator?.destroy()
+      walkRideCalculator?.destroy()
+      ebikeCalculator?.destroy()
+      driveTruckCalculator = null
+      walkRideCalculator = null
+      ebikeCalculator = null
+      independentRouteService = null
+      independentRouteManager.clearAll()
+    }
+
+    /**
+     * 可选：初始化（提前创建内部实例）
+     */
+    Function("initNavigation") {
+      ensureDriveTruck()
+      ensureWalkRide()
+    }
+
+    /**
+     * 清理所有路径计算实例
+     * 用于页面切换时释放资源，避免"Another route calculation is in progress"错误
+     */
+    Function("destroyAllCalculators") {
+      driveTruckCalculator?.destroy()
+      walkRideCalculator?.destroy()
+      ebikeCalculator?.destroy()
+      driveTruckCalculator = null
+      walkRideCalculator = null
+      ebikeCalculator = null
+      independentRouteService = null
+      independentRouteManager.clearAll()
+    }
+
+    // ---------------- 1. 驾车/货车 路线规划 ----------------
+
+    AsyncFunction("calculateDriveRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        ensureDriveTruck().calculateDriveRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    AsyncFunction("calculateTruckRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        ensureDriveTruck().calculateTruckRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    // ---------------- 2. 骑行/步行 路线规划 ----------------
+
+    AsyncFunction("calculateWalkRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        ensureWalkRide().calculateWalkRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    AsyncFunction("calculateRideRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        ensureWalkRide().calculateRideRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    // ---------------- 3. 独立路径规划 ----------------
+    // 使用 AMapNavi.independentCalculateRoute，不影响当前导航状态
+    // 委托给 IndependentRouteService 处理，避免 Module 文件臃肿
+    
+    AsyncFunction("independentDriveRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        ensureIndependentService().independentDriveRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    AsyncFunction("independentTruckRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        ensureIndependentService().independentTruckRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    AsyncFunction("independentWalkRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        ensureIndependentService().independentWalkRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    AsyncFunction("independentRideRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        ensureIndependentService().independentRideRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    // 独立摩托车 路线规划（与驾车一致，依赖车辆信息 carType=11）
+    AsyncFunction("independentMotorcycleRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        ensureIndependentService().independentMotorcycleRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    // 提供对独立路径组的操作能力：选路/启动/清理
+
+    /**
+     * 选择独立路径组中的主路线
+     * 参数：
+     * - token: Int（independentXXX 接口返回的 token）
+     * - routeId: Int（12/13/14...，优先）
+     * - routeIndex: Int（0/1/2，对 routeId 的便捷封装，若 routeId 未传则使用）
+     */
+    AsyncFunction("selectIndependentRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        val token = (options["token"] as? Number)?.toInt() ?: throw Exception("token is required")
+        val routeId = (options["routeId"] as? Number)?.toInt()
+        val routeIndex = (options["routeIndex"] as? Number)?.toInt()
+        val ok = independentRouteManager.select(token, routeId, routeIndex)
+        if (!ok) throw Exception("select route failed")
+        promise.resolve(true)
+      } catch (e: Exception) {
+        promise.reject("SELECT_ROUTE_ERROR", e.message, e)
+      }
+    }
+
+    /**
+     * 使用指定独立路径组启动导航
+     * 参数：
+     * - token: Int
+     * - naviType: Int（0=GPS，1=EMULATOR；默认0）
+     * - routeId/routeIndex: 可选，启动前选择主路线
+     */
+    AsyncFunction("startNaviWithIndependentPath") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        val token = (options["token"] as? Number)?.toInt() ?: throw Exception("token is required")
+        val routeId = (options["routeId"] as? Number)?.toInt()
+        val routeIndex = (options["routeIndex"] as? Number)?.toInt()
+        val naviType = (options["naviType"] as? Number)?.toInt() ?: 0
+        val ok = independentRouteManager.start(context, token, naviType, routeId, routeIndex)
+        if (!ok) throw Exception("startNaviWithPath failed")
+        promise.resolve(true)
+      } catch (e: Exception) {
+        promise.reject("START_NAVI_ERROR", e.message, e)
+      }
+    }
+
+    /**
+     * 清除独立路径组
+     * - token: Int
+     */
+    AsyncFunction("clearIndependentRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        val token = (options["token"] as? Number)?.toInt() ?: throw Exception("token is required")
+        independentRouteManager.clear(token)
+        promise.resolve(true)
+      } catch (e: Exception) {
+        promise.reject("CLEAR_ROUTE_ERROR", e.message, e)
+      }
+    }
+
+    // ---------------- 4. 摩托车 路线规划 ----------------
+    // 注意：摩托车是收费能力；务必在算路前设置 carType=11 和排量，否则不生效
+    AsyncFunction("calculateMotorcycleRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        // 设置摩托车车辆信息（车牌可选、排量可选）
+        try {
+          val carNumber = options["carNumber"] as? String
+          val motorcycleCC = (options["motorcycleCC"] as? Number)?.toInt()
+          val carInfo = AMapCarInfo().apply {
+            if (carNumber != null) setCarNumber(carNumber)
+              carType = "11" // 11 = 摩托车
+            if (motorcycleCC != null) {
+              try {
+                  this.motorcycleCC = motorcycleCC
+              } catch (_: Exception) {}
+            }
+          }
+          AMapNavi.getInstance(context).setCarInfo(carInfo)
+        } catch (_: Exception) {
+          // ignore
+        }
+
+        // 复用驾车算路逻辑（含 strategyConvert / 途经点等）
+        ensureDriveTruck().calculateDriveRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    // ---------------- 5. 骑行电动车 路线规划 ----------------
+    // 暂无单独 SDK API，先复用骑行算路（后续如有官方专门接口，再独立 Calculator）
+    AsyncFunction("calculateEBikeRoute") { options: Map<String, Any?>, promise: Promise ->
+      try {
+        // 使用电动车专用 Calculator，对齐 SDK 的 calculateEleBikeRoute 三种重载
+        ensureEbike().calculateEleBikeRoute(options, promise)
+      } catch (e: Exception) {
+        promise.reject("CALCULATE_ERROR", e.message, e)
+      }
+    }
+
+    // （可选）公交：官方文档归属搜索/出行服务，导航 SDK 内无直算支持；保持未实现提示
+//    AsyncFunction("calculateBusRoute") { @Suppress("UNUSED_PARAMETER") options: Map<String, Any?>, promise: Promise ->
+//      promise.reject("NOT_IMPLEMENTED", "Bus route calculation requires search service", null)
+//    }
+  }
+
+  // MARK: - Private
+
+  /**
+   * 存储独立路径组并返回 token
+   * 由 IndependentRouteListener 在算路成功时调用
+   */
+  internal fun storeIndependentGroup(group: AMapNaviPathGroup): Int {
+    return independentRouteManager.store(group)
+  }
+
+  private fun ensureDriveTruck(): DriveTruckRouteCalculator {
+    if (driveTruckCalculator == null) {
+      driveTruckCalculator = DriveTruckRouteCalculator(context, this)
+    }
+    return driveTruckCalculator!!
+  }
+
+  private fun ensureWalkRide(): WalkRideRouteCalculator {
+    if (walkRideCalculator == null) {
+      walkRideCalculator = WalkRideRouteCalculator(context, this)
+    }
+    return walkRideCalculator!!
+  }
+
+  private fun ensureEbike(): EbikeRouteCalculator {
+    if (ebikeCalculator == null) {
+      ebikeCalculator = EbikeRouteCalculator(context, this)
+    }
+    return ebikeCalculator!!
+  }
+
+  private fun ensureIndependentService(): IndependentRouteService {
+    if (independentRouteService == null) {
+      independentRouteService = IndependentRouteService(context, this)
+    }
+    return independentRouteService!!
+  }
+
+  /**
+   * 发送事件到 JS 层
+   */
+  internal fun sendEvent(name: String, params: Map<String, Any?>?) {
+    this@ExpoGaodeMapNavigationModule.sendEvent(name, params)
+  }
+}

package/android/src/main/java/expo/modules/gaodemap/navigation/listeners/IndependentRouteListener.kt

@@ -0,0 +1,87 @@
+package expo.modules.gaodemap.navigation.listeners
+
+import com.amap.api.navi.AMapNaviIndependentRouteListener
+import com.amap.api.navi.model.AMapCalcRouteResult
+import com.amap.api.navi.model.AMapNaviPathGroup
+import expo.modules.gaodemap.navigation.ExpoGaodeMapNavigationModule
+import expo.modules.gaodemap.navigation.utils.Converters
+import expo.modules.kotlin.Promise
+
+/**
+ * 独立路径规划监听器
+ *
+ * - 对应 AMapNavi.independentCalculateRoute 的结果回调
+ * - 将 AMapNaviPathGroup 转换为 JS 可消费的数据结构
+ */
+class IndependentRouteListener(
+  private val module: ExpoGaodeMapNavigationModule,
+  private val promise: Promise
+) : AMapNaviIndependentRouteListener {
+
+  override fun onIndependentCalculateSuccess(group: AMapNaviPathGroup?) {
+    try {
+      if (group == null) {
+        promise.reject("INDEPENDENT_CALCULATE_ERROR", "Path group is null", null)
+        module.sendEvent("onCalculateRouteFailure", mapOf("errorCode" to -1, "error" to "Path group is null"))
+        return
+      }
+
+      // 将路径组存储在模块内，返回一个可供后续操作（选路/启动导航/清理）的 token
+      val token = module.storeIndependentGroup(group)
+
+      val result = convertGroupToResult(group).toMutableMap().apply {
+        put("token", token)
+      }
+      promise.resolve(result)
+      module.sendEvent("onCalculateRouteSuccess", result)
+    } catch (e: Exception) {
+      promise.reject("INDEPENDENT_CALCULATE_ERROR", e.message, e)
+      module.sendEvent("onCalculateRouteFailure", mapOf("errorCode" to -1, "error" to (e.message ?: "unknown")))
+    }
+  }
+
+  override fun onIndependentCalculateFail(routeResult: AMapCalcRouteResult?) {
+    val errorCode = routeResult?.errorCode ?: -1
+    val errorMsg = "Independent route calculation failed with code: $errorCode"
+    promise.reject("INDEPENDENT_CALCULATE_ERROR", errorMsg, null)
+    module.sendEvent("onCalculateRouteFailure", mapOf("errorCode" to errorCode))
+  }
+
+  /**
+   * 将 AMapNaviPathGroup 转换为轻量结构：
+   * {
+   *   independent: true,
+   *   count: number,
+   *   mainPathIndex: number,
+   *   routeIds: number[],   // 12/13/14 ...
+   *   routes: RouteResult[] // 复用 Converters.convertNaviPath
+   * }
+   */
+  private fun convertGroupToResult(group: AMapNaviPathGroup): Map<String, Any?> {
+    val count = try { group.pathCount } catch (_: Exception) { 0 }
+    val mainIndex = try { group.mainPathIndex } catch (_: Exception) { 0 }
+
+    val routes = ArrayList<Map<String, Any?>>(count)
+    val routeIds = ArrayList<Int>(count)
+
+    for (i in 0 until count) {
+      try {
+        val path = group.getPath(i)
+        val converted = Converters.convertNaviPath(path)
+        routes.add(converted)
+        // 文档说明：第一条为12，第二条为13，第三条为14
+        routeIds.add(12 + i)
+      } catch (_: Exception) {
+        // 忽略单条路线转换失败，保持稳健性
+      }
+    }
+
+    return mapOf(
+      "independent" to true,
+      "count" to count,
+      "mainPathIndex" to mainIndex,
+      "routeIds" to routeIds,
+      "routes" to routes
+    )
+  }
+}

package/android/src/main/java/expo/modules/gaodemap/navigation/listeners/RouteCalculateListener.kt

@@ -0,0 +1,134 @@
+package expo.modules.gaodemap.navigation.listeners
+
+import com.amap.api.navi.AMapNaviListener
+import com.amap.api.navi.model.*
+import expo.modules.kotlin.Promise
+import expo.modules.gaodemap.navigation.ExpoGaodeMapNavigationModule
+import expo.modules.gaodemap.navigation.utils.Converters
+
+/**
+ * 路径规划监听器
+ */
+class RouteCalculateListener(
+  private val module: ExpoGaodeMapNavigationModule
+) : AMapNaviListener {
+  
+  var currentPromise: Promise? = null
+  // scene: "drive" | "truck" | "walk" | "ride"
+  var scene: String? = null
+  // whether caller expects multiple routes
+  var multiple: Boolean = false
+
+  override fun onInitNaviSuccess() {
+    // 初始化成功
+  }
+
+  override fun onInitNaviFailure() {
+    currentPromise?.reject("INIT_ERROR", "Failed to initialize navigation", null)
+    currentPromise = null
+  }
+
+  @Deprecated("Deprecated in Java")
+  override fun onCalculateRouteSuccess(routeIds: IntArray?) {
+    android.util.Log.d("RouteCalculateListener", "Deprecated onCalculateRouteSuccess 被调用，忽略")
+    // 这个方法已被废弃，不处理，避免与新的 onCalculateRouteSuccess 重复调用
+  }
+  
+  override fun onCalculateRouteSuccess(routeResult: AMapCalcRouteResult?) {
+    android.util.Log.d("RouteCalculateListener", "onCalculateRouteSuccess 被调用")
+    android.util.Log.d("RouteCalculateListener", "场景: $scene, 多路线: $multiple")
+    android.util.Log.d("RouteCalculateListener", "routeResult: $routeResult")
+    
+    try {
+      val navi = com.amap.api.navi.AMapNavi.getInstance(module.appContext.reactContext)
+      val isWalkOrRide = scene == "walk" || scene == "ride" || scene == "ebike"
+      
+      android.util.Log.d("RouteCalculateListener", "naviPaths 数量: ${navi.naviPaths?.size}")
+      val result = if (isWalkOrRide) {
+        if (multiple) {
+          Converters.convertDriveRouteResult(navi.naviPaths)
+        } else {
+          val path = navi.naviPath
+          if (path != null) Converters.convertNaviPath(path) else mapOf<String, Any?>()
+        }
+      } else {
+        Converters.convertDriveRouteResult(navi.naviPaths)
+      }
+      
+      android.util.Log.d("RouteCalculateListener", "转换结果: $result")
+      currentPromise?.resolve(result)
+      currentPromise = null
+      
+      module.sendEvent("onCalculateRouteSuccess", result)
+    } catch (e: Exception) {
+      android.util.Log.e("RouteCalculateListener", "处理路径规划结果时出错", e)
+      currentPromise?.reject("CALCULATE_ERROR", e.message, e)
+      currentPromise = null
+    }
+  }
+
+  @Deprecated("Deprecated in Java")
+  override fun onCalculateRouteFailure(errorCode: Int) {
+    val errorMsg = "Route calculation failed with code: $errorCode"
+    currentPromise?.reject("CALCULATE_ERROR", errorMsg, null)
+    currentPromise = null
+    
+    module.sendEvent("onCalculateRouteFailure", mapOf("errorCode" to errorCode))
+  }
+  
+  override fun onCalculateRouteFailure(routeResult: AMapCalcRouteResult?) {
+    val errorCode = routeResult?.errorCode ?: -1
+    val errorMsg = "Route calculation failed with code: $errorCode"
+    
+    android.util.Log.e("RouteCalculateListener", "onCalculateRouteFailure 被调用")
+    android.util.Log.e("RouteCalculateListener", "错误码: $errorCode")
+    android.util.Log.e("RouteCalculateListener", "错误信息: ${routeResult?.errorDescription}")
+    
+    currentPromise?.reject("CALCULATE_ERROR", errorMsg, null)
+    currentPromise = null
+    
+    module.sendEvent("onCalculateRouteFailure", mapOf("errorCode" to errorCode))
+  }
+
+  // 以下是必须实现但暂不使用的接口方法
+  override fun onNaviInfoUpdate(info: NaviInfo?) {}
+  override fun onStartNavi(type: Int) {}
+  override fun onEndEmulatorNavi() {}
+  override fun onArriveDestination() {}
+  override fun onReCalculateRouteForYaw() {}
+  override fun onReCalculateRouteForTrafficJam() {}
+  override fun onGetNavigationText(type: Int, text: String?) {}
+  @Deprecated("Deprecated in Java")
+  override fun onGetNavigationText(text: String?) {}
+  override fun onTrafficStatusUpdate() {}
+  override fun onGpsOpenStatus(enabled: Boolean) {}
+  override fun onLocationChange(location: AMapNaviLocation?) {}
+  override fun updateCameraInfo(cameras: Array<out AMapNaviCameraInfo>?) {}
+  override fun updateIntervalCameraInfo(camera: AMapNaviCameraInfo?, camera2: AMapNaviCameraInfo?, type: Int) {}
+  override fun onServiceAreaUpdate(infos: Array<out AMapServiceAreaInfo>?) {}
+  override fun showCross(bitmap: AMapNaviCross?) {}
+  override fun hideCross() {}
+  override fun showModeCross(crossInfo: AMapModelCross?) {}
+  override fun hideModeCross() {}
+  @Deprecated("Deprecated in Java")
+  override fun showLaneInfo(laneInfos: Array<out AMapLaneInfo>?, laneBackgroundInfo: ByteArray?, laneRecommendedInfo: ByteArray?) {}
+    override fun showLaneInfo(p0: AMapLaneInfo?) {
+
+    }
+
+    override fun hideLaneInfo() {}
+  @Deprecated("Deprecated in Java")
+  override fun notifyParallelRoad(parallelRoadType: Int) {}
+  override fun onArrivedWayPoint(wayPointIndex: Int) {}
+  override fun onNaviRouteNotify(notifyData: AMapNaviRouteNotifyData?) {}
+  override fun onGpsSignalWeak(isWeak: Boolean) {}
+  @Deprecated("Deprecated in Java")
+  override fun OnUpdateTrafficFacility(trafficFacilityInfo: AMapNaviTrafficFacilityInfo?) {}
+  @Deprecated("Deprecated in Java")
+  override fun OnUpdateTrafficFacility(aMapNaviTrafficFacilityInfos: Array<out AMapNaviTrafficFacilityInfo>?) {}
+  @Deprecated("Deprecated in Java")
+  override fun updateAimlessModeStatistics(aimlessModeStatistics: AimLessModeStat?) {}
+  @Deprecated("Deprecated in Java")
+  override fun updateAimlessModeCongestionInfo(aimlessModeStatistics: AimLessModeCongestionInfo?) {}
+  override fun onPlayRing(ring: Int) {}
+}