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

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

@@ -2,7 +2,17 @@ package expo.modules.gaodemap.navigation
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.RectF
+import android.graphics.Typeface
+import android.net.Uri
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
 import android.view.View
 import android.view.ViewGroup
@@ -11,18 +21,60 @@ import com.amap.api.navi.AMapNaviListener
 import com.amap.api.navi.AMapNaviView
 import com.amap.api.navi.AMapNaviViewListener
 import com.amap.api.navi.AMapNaviViewOptions
+import com.amap.api.maps.model.BitmapDescriptorFactory
+import com.amap.api.maps.model.LatLng
+import com.amap.api.maps.model.Marker
+import com.amap.api.maps.model.MarkerOptions
 import com.amap.api.navi.enums.MapStyle
 import com.amap.api.navi.enums.NaviType
 import com.amap.api.navi.model.*
 import expo.modules.gaodemap.map.modules.SDKInitializer
+import expo.modules.gaodemap.navigation.managers.IndependentRouteManager
+import expo.modules.gaodemap.navigation.services.NavigationForegroundService
+import expo.modules.gaodemap.navigation.services.NavigationNotificationSnapshot
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.viewevent.EventDispatcher
 import expo.modules.kotlin.views.ExpoView
-import java.util.IdentityHashMap
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.security.MessageDigest
+import java.util.Collections
+import java.util.WeakHashMap
+import java.net.URL
+import kotlin.math.roundToInt
+
+private data class NaviCustomWaypointMarkerModel(
+    val latitude: Double,
+    val longitude: Double,
+    val title: String,
+    val arrived: Boolean = false
+)
 
 @SuppressLint("ViewConstructor")
 @Suppress("DEPRECATION", "OVERRIDE_DEPRECATION")
 class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+    companion object {
+        private val activeViews =
+            Collections.newSetFromMap(WeakHashMap<ExpoGaodeMapNaviView, Boolean>())
+
+        private fun snapshotActiveViews(): List<ExpoGaodeMapNaviView> =
+            synchronized(activeViews) { activeViews.toList() }
+
+        fun resumeActiveViews() {
+            snapshotActiveViews().forEach { it.onHostActivityForeground() }
+        }
+
+        fun pauseActiveViews() {
+            snapshotActiveViews().forEach { it.onHostActivityBackground() }
+        }
+
+        fun destroyActiveViews() {
+            snapshotActiveViews().forEach { it.onDestroy() }
+        }
+    }
+
+    private val independentRouteManager = IndependentRouteManager.shared
     
     // 事件派发器
     private val onNavigationReady by EventDispatcher()
@@ -38,6 +90,9 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
     private val onGpsStatusChanged by EventDispatcher()
     private val onNavigationInfoUpdate by EventDispatcher()
     private val onGpsSignalWeak by EventDispatcher()
+    private val onNavigationVisualStateUpdate by EventDispatcher()
+    private val onLaneInfoUpdate by EventDispatcher()
+    private val onTrafficStatusesUpdate by EventDispatcher()
     
     // Props - 使用 internal 避免自动生成 setter
     internal var showCamera: Boolean = true
@@ -50,16 +105,41 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
     internal var showUIElements: Boolean = true
     internal var androidTrafficBarEnabled: Boolean = true
     internal var isRouteListButtonShow: Boolean = true
-    internal var isTrafficLayerEnabled: Boolean = true
+    internal var isTrafficButtonVisible: Boolean = true
     internal var autoChangeZoom : Boolean = true
     internal var autoLockCar: Boolean = true
-    internal var isTrafficLine: Boolean = true
+    internal var isTrafficLineEnabled: Boolean = true
     internal var isRealCrossDisplayShow : Boolean = true
     internal var isNaviArrowVisible : Boolean = true
-    internal var isAfterRouteAutoGray: Boolean = false
+    internal var isLaneInfoVisible: Boolean = true
+    internal var isModeCrossDisplayVisible: Boolean = true
+    internal var isEyrieCrossDisplayVisible: Boolean = true
+    internal var isSecondActionVisible: Boolean = true
+    internal var isBackupOverlayVisible: Boolean = true
+    internal var isAfterRouteAutoGray: Boolean = true
     internal var isVectorLineShow: Boolean = true
     internal var isNaviTravelView : Boolean = false
     internal var isCompassEnabled: Boolean = true
+    internal var isNaviStatusBarEnabled: Boolean = false
+    internal var lockZoomLevel: Int = 18
+    internal var lockTilt: Int = 35
+    internal var isEagleMapVisible: Boolean = false
+    internal var pointToCenterX: Double = 0.0
+    internal var pointToCenterY: Double = 0.0
+    internal var hideNativeTopInfoLayout: Boolean = false
+    internal var androidBackgroundNavigationNotificationEnabled: Boolean = false
+    internal var naviModeValue: Int = AMapNaviView.CAR_UP_MODE
+    internal var mapViewModeTypeValue: Int = 0
+    internal var carImageUri: String? = null
+    internal var carImageWidthDp: Double? = null
+    internal var carImageHeightDp: Double? = null
+    internal var fourCornersImageUri: String? = null
+    internal var startPointImageUri: String? = null
+    internal var wayPointImageUri: String? = null
+    internal var endPointImageUri: String? = null
+    private var customWaypointMarkers: List<NaviCustomWaypointMarkerModel> = emptyList()
+    private val renderedCustomWaypointMarkers = mutableListOf<Marker>()
+    private var activeIndependentRouteId: Int? = null
     private val naviView: AMapNaviView by lazy(LazyThreadSafetyMode.NONE) {
         AMapNaviView(context)
     }
@@ -68,15 +148,803 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
     private var endCoordinate: NaviLatLng? = null
 
     private var lastAppliedTopPaddingPx: Int? = null
+    private var isDestroyed = false
+    private var isCrossVisible = false
+    private var isModeCrossVisible = false
+    private var isLaneInfoCurrentlyVisible = false
+    private var currentRouteTotalLength: Int? = null
+    private var sourceCarBitmap: Bitmap? = null
+    private var customCarBitmap: Bitmap? = null
+    private var customFourCornersBitmap: Bitmap? = null
+    private var customStartPointBitmap: Bitmap? = null
+    private var customWayPointBitmap: Bitmap? = null
+    private var customEndPointBitmap: Bitmap? = null
+    private var routeMarkerShowStartEndVia: Boolean = true
+    private var routeMarkerShowFootFerry: Boolean = true
+    private var routeMarkerShowForbidden: Boolean = true
+    private var routeMarkerShowRouteStartIcon: Boolean = true
+    private var routeMarkerShowRouteEndIcon: Boolean = true
+    private var cachedTurnIconImageUri: String? = null
+    private var cachedTurnIconContentHash: String? = null
+    private var hasLoggedMissingTurnIconBitmapApi = false
+    private var hasLoggedMissingNaviStatusBarApi = false
+    private var hasLoggedMissingNaviModeApi = false
+    private var isHostActivityInBackground: Boolean = false
+    private var isNavigationRunning: Boolean = false
+    private var latestNavigationNotificationSnapshot: NavigationNotificationSnapshot? = null
+
+    private fun registerActiveView() {
+        synchronized(activeViews) {
+            activeViews.add(this)
+        }
+    }
+
+    private fun unregisterActiveView() {
+        synchronized(activeViews) {
+            activeViews.remove(this)
+        }
+    }
 
-    private var topInsetPx: Int = 0
-    private var overlayHooked: Boolean = false
-    private val overlayStates = IdentityHashMap<View, OverlayState>()
+    private fun buildNavigationNotificationSnapshot(naviInfo: NaviInfo?): NavigationNotificationSnapshot {
+        if (naviInfo == null) {
+            return latestNavigationNotificationSnapshot ?: NavigationNotificationSnapshot(
+                pathRetainDistance = currentRouteTotalLength,
+                routeTotalDistance = currentRouteTotalLength,
+                turnIconImageUri = cachedTurnIconImageUri
+            )
+        }
 
-    private data class OverlayState(
-        val translationY: Float,
-        val paddingTop: Int
-    )
+        return NavigationNotificationSnapshot(
+            currentRoadName = naviInfo.currentRoadName,
+            nextRoadName = naviInfo.nextRoadName,
+            pathRetainDistance = naviInfo.pathRetainDistance,
+            routeTotalDistance = currentRouteTotalLength,
+            pathRetainTime = naviInfo.pathRetainTime,
+            curStepRetainDistance = naviInfo.curStepRetainDistance,
+            iconType = naviInfo.iconType,
+            turnIconImageUri = cachedTurnIconImageUri
+        )
+    }
+
+    private fun shouldRunBackgroundNavigationNotification(): Boolean {
+        return androidBackgroundNavigationNotificationEnabled &&
+            isNavigationRunning &&
+            isHostActivityInBackground
+    }
+
+    private fun syncNavigationForegroundService(reason: String) {
+        val shouldRun = shouldRunBackgroundNavigationNotification()
+        Log.d(
+            "ExpoGaodeMapNaviView",
+            "syncNavigationForegroundService reason=$reason, shouldRun=$shouldRun, " +
+              "propEnabled=$androidBackgroundNavigationNotificationEnabled, " +
+              "isNavigationRunning=$isNavigationRunning, isHostActivityInBackground=$isHostActivityInBackground"
+        )
+        if (shouldRunBackgroundNavigationNotification()) {
+            val snapshot = latestNavigationNotificationSnapshot ?: buildNavigationNotificationSnapshot(null)
+            Log.d(
+                "ExpoGaodeMapNaviView",
+                "startOrUpdate notification snapshot: stepDistance=${snapshot.curStepRetainDistance}, " +
+                  "remainDistance=${snapshot.pathRetainDistance}, routeTotal=${snapshot.routeTotalDistance}, " +
+                  "remainTime=${snapshot.pathRetainTime}, " +
+                  "nextRoad=${snapshot.nextRoadName}, turnIconUri=${snapshot.turnIconImageUri}"
+            )
+            NavigationForegroundService.startOrUpdate(context, snapshot)
+            Log.d("ExpoGaodeMapNaviView", "Navigation foreground notification enabled: $reason")
+        } else {
+            NavigationForegroundService.stop(context)
+            Log.d("ExpoGaodeMapNaviView", "Navigation foreground notification disabled: $reason")
+        }
+    }
+
+    private fun updateNavigationNotification(naviInfo: NaviInfo) {
+        latestNavigationNotificationSnapshot = buildNavigationNotificationSnapshot(naviInfo)
+        Log.d(
+            "ExpoGaodeMapNaviView",
+            "updateNavigationNotification: stepDistance=${naviInfo.curStepRetainDistance}, " +
+              "remainDistance=${naviInfo.pathRetainDistance}, routeTotal=${latestNavigationNotificationSnapshot?.routeTotalDistance}, " +
+              "remainTime=${naviInfo.pathRetainTime}, " +
+              "currentRoad=${naviInfo.currentRoadName}, nextRoad=${naviInfo.nextRoadName}, " +
+              "turnIconUri=${latestNavigationNotificationSnapshot?.turnIconImageUri}"
+        )
+        if (shouldRunBackgroundNavigationNotification()) {
+            NavigationForegroundService.startOrUpdate(context, latestNavigationNotificationSnapshot)
+        }
+    }
+
+    fun onHostActivityForeground() {
+        Log.d("ExpoGaodeMapNaviView", "onHostActivityForeground")
+        isHostActivityInBackground = false
+        onResume()
+        syncNavigationForegroundService("host_foreground")
+    }
+
+    fun onHostActivityBackground() {
+        Log.d("ExpoGaodeMapNaviView", "onHostActivityBackground")
+        isHostActivityInBackground = true
+        onPause()
+        syncNavigationForegroundService("host_background")
+    }
+
+    private fun applyNaviStatusBarEnabledCompat(
+        options: AMapNaviViewOptions,
+        enabled: Boolean
+    ) {
+        try {
+            val method = options.javaClass.getMethod(
+                "setNaviStatusBarEnabled",
+                java.lang.Boolean.TYPE
+            )
+            method.invoke(options, enabled)
+        } catch (_: NoSuchMethodException) {
+            if (!hasLoggedMissingNaviStatusBarApi) {
+                hasLoggedMissingNaviStatusBarApi = true
+                Log.w(
+                    "ExpoGaodeMapNaviView",
+                    "AMapNaviViewOptions#setNaviStatusBarEnabled is unavailable in the current AMap SDK; skip applying naviStatusBarEnabled"
+                )
+            }
+        } catch (error: Throwable) {
+            Log.w(
+                "ExpoGaodeMapNaviView",
+                "Failed to apply naviStatusBarEnabled compatibly",
+                error
+            )
+        }
+    }
+
+    private fun applyNaviModeCompat(
+        options: AMapNaviViewOptions,
+        mode: Int
+    ) {
+        try {
+            val method = options.javaClass.getMethod(
+                "setNaviMode",
+                Integer.TYPE
+            )
+            method.invoke(options, mode)
+        } catch (_: NoSuchMethodException) {
+            if (!hasLoggedMissingNaviModeApi) {
+                hasLoggedMissingNaviModeApi = true
+                Log.w(
+                    "ExpoGaodeMapNaviView",
+                    "AMapNaviViewOptions#setNaviMode is unavailable in the current AMap SDK; skip applying naviMode on options"
+                )
+            }
+        } catch (error: Throwable) {
+            Log.w(
+                "ExpoGaodeMapNaviView",
+                "Failed to apply naviMode compatibly",
+                error
+            )
+        }
+    }
+
+    private fun applyAutoNaviViewNightModeCompat(
+        options: AMapNaviViewOptions,
+        enabled: Boolean
+    ) {
+        try {
+            val method = options.javaClass.getMethod(
+                "setAutoNaviViewNightMode",
+                java.lang.Boolean.TYPE
+            )
+            method.invoke(options, enabled)
+        } catch (_: NoSuchMethodException) {
+            Log.w(
+                "ExpoGaodeMapNaviView",
+                "AMapNaviViewOptions#setAutoNaviViewNightMode is unavailable in the current AMap SDK; skip applying auto night mode"
+            )
+        } catch (error: Throwable) {
+            Log.w(
+                "ExpoGaodeMapNaviView",
+                "Failed to apply auto navi night mode compatibly",
+                error
+            )
+        }
+    }
+
+    private fun applyNaviNightCompat(
+        options: AMapNaviViewOptions,
+        enabled: Boolean
+    ) {
+        try {
+            val method = options.javaClass.getMethod(
+                "setNaviNight",
+                java.lang.Boolean.TYPE
+            )
+            method.invoke(options, enabled)
+            return
+        } catch (_: NoSuchMethodException) {
+            Log.w(
+                "ExpoGaodeMapNaviView",
+                "AMapNaviViewOptions#setNaviNight is unavailable in the current AMap SDK; fallback to setMapStyle"
+            )
+        } catch (error: Throwable) {
+            Log.w(
+                "ExpoGaodeMapNaviView",
+                "Failed to apply navi night compatibly, fallback to setMapStyle",
+                error
+            )
+        }
+
+        if (enabled) {
+            options.setMapStyle(MapStyle.NIGHT, null)
+        } else {
+            options.setMapStyle(MapStyle.DAY, null)
+        }
+    }
+
+    private fun applyMapViewModeTypeCompat(
+        options: AMapNaviViewOptions,
+        mode: Int
+    ) {
+        when (mode) {
+            0 -> {
+                applyAutoNaviViewNightModeCompat(options, false)
+                applyNaviNightCompat(options, false)
+            }
+            1 -> {
+                applyAutoNaviViewNightModeCompat(options, false)
+                applyNaviNightCompat(options, true)
+            }
+            2 -> {
+                applyAutoNaviViewNightModeCompat(options, true)
+            }
+            3 -> {
+                // Android custom map style requires style path API that is not exposed yet.
+                applyAutoNaviViewNightModeCompat(options, false)
+                applyNaviNightCompat(options, false)
+                Log.w(
+                    "ExpoGaodeMapNaviView",
+                    "mapViewModeType=3 (custom) requires custom map style path support on Android; fallback to day mode"
+                )
+            }
+            else -> {
+                applyAutoNaviViewNightModeCompat(options, false)
+                applyNaviNightCompat(options, false)
+                Log.w(
+                    "ExpoGaodeMapNaviView",
+                    "Unknown mapViewModeType=$mode; fallback to day mode"
+                )
+            }
+        }
+    }
+
+    private fun createInitialViewOptions(): AMapNaviViewOptions {
+        return AMapNaviViewOptions().also { options ->
+            applyAllViewOptions(options)
+        }
+    }
+
+    private fun applyAllViewOptions(options: AMapNaviViewOptions) {
+        options.isLayoutVisible = showUIElements
+        options.isSettingMenuEnabled = true
+        options.isCompassEnabled = isCompassEnabled
+        options.isTrafficBarEnabled = androidTrafficBarEnabled
+        options.isRouteListButtonShow = isRouteListButtonShow
+        applyNaviStatusBarEnabledCompat(options, isNaviStatusBarEnabled)
+
+        options.isTrafficLayerEnabled = isTrafficButtonVisible
+        options.isTrafficLine = isTrafficLineEnabled
+
+        options.isRealCrossDisplayShow = isRealCrossDisplayShow
+        options.setModeCrossDisplayShow(isModeCrossDisplayVisible)
+        options.isLaneInfoShow = isLaneInfoVisible
+        options.isEyrieCrossDisplay = isEyrieCrossDisplayVisible
+
+        options.isCameraBubbleShow = showCamera
+        options.isShowCameraDistance = true
+        options.isWidgetOverSpeedPulseEffective = true
+
+        options.isAutoDrawRoute = true
+        options.isNaviArrowVisible = isNaviArrowVisible
+        options.isSecondActionVisible = isSecondActionVisible
+        options.isDrawBackUpOverlay = isBackupOverlayVisible
+        applyLeaderLineSetting(options, isVectorLineShow)
+
+        options.isAutoLockCar = autoLockCar
+        options.lockMapDelayed = 5000L
+        options.isAutoDisplayOverview = false
+        options.isAutoChangeZoom = autoChangeZoom
+        options.zoom = lockZoomLevel.coerceIn(14, 18)
+        options.tilt = lockTilt.coerceIn(0, 60)
+        applyNaviModeCompat(options, naviModeValue)
+        if (pointToCenterX > 0.0 && pointToCenterY > 0.0) {
+            options.setPointToCenter(pointToCenterX, pointToCenterY)
+        }
+
+        options.isAfterRouteAutoGray = isAfterRouteAutoGray
+        options.isSensorEnable = true
+        applyMapViewModeTypeCompat(options, mapViewModeTypeValue)
+        options.isEagleMapVisible = isEagleMapVisible
+        applyCustomAnnotationBitmaps(options)
+    }
+
+    private fun applyBitmapOptionCompat(
+        options: AMapNaviViewOptions,
+        methodName: String,
+        bitmap: Bitmap?
+    ) {
+        try {
+            val method = options.javaClass.getMethod(methodName, Bitmap::class.java)
+            method.invoke(options, bitmap)
+        } catch (_: NoSuchMethodException) {
+            Log.w(
+                "ExpoGaodeMapNaviView",
+                "AMapNaviViewOptions#$methodName is unavailable in the current AMap SDK; skip applying custom bitmap"
+            )
+        } catch (error: Throwable) {
+            Log.w(
+                "ExpoGaodeMapNaviView",
+                "Failed to apply $methodName compatibly",
+                error
+            )
+        }
+    }
+
+    private fun applyCustomAnnotationBitmaps(options: AMapNaviViewOptions) {
+        applyBitmapOptionCompat(options, "setCarBitmap", customCarBitmap)
+        applyBitmapOptionCompat(options, "setFourCornersBitmap", customFourCornersBitmap)
+        applyBitmapOptionCompat(options, "setStartPointBitmap", customStartPointBitmap)
+        applyBitmapOptionCompat(options, "setWayPointBitmap", customWayPointBitmap)
+        applyBitmapOptionCompat(options, "setEndPointBitmap", customEndPointBitmap)
+    }
+
+    private fun refreshViewOptionsFromState(reason: String) {
+        if (isDestroyed) {
+            return
+        }
+        naviView.viewOptions = createInitialViewOptions()
+        refreshNaviUILayout(reason)
+    }
+
+    private fun loadBitmapFromSource(imagePath: String): Bitmap? {
+        return try {
+            when {
+                imagePath.startsWith("http://") || imagePath.startsWith("https://") -> {
+                    URL(imagePath).openStream().use { BitmapFactory.decodeStream(it) }
+                }
+                imagePath.startsWith("file://") -> {
+                    BitmapFactory.decodeFile(imagePath.substring(7))
+                }
+                else -> {
+                    val fileName = imagePath.substringBeforeLast('.')
+                    val resId = context.resources.getIdentifier(
+                        fileName,
+                        "drawable",
+                        context.packageName
+                    )
+                    if (resId != 0) {
+                        BitmapFactory.decodeResource(context.resources, resId)
+                    } else {
+                        BitmapFactory.decodeFile(imagePath)
+                    }
+                }
+            }
+        } catch (_: Throwable) {
+            null
+        }
+    }
+
+    private fun resizeCarBitmapIfNeeded(source: Bitmap?): Bitmap? {
+        val rawBitmap = source ?: return null
+        val widthDp = carImageWidthDp?.takeIf { it > 0.0 }
+        val heightDp = carImageHeightDp?.takeIf { it > 0.0 }
+        if (widthDp == null || heightDp == null) {
+            return rawBitmap
+        }
+
+        val density = context.resources.displayMetrics.density
+        val widthPx = (widthDp * density).roundToInt().coerceAtLeast(1)
+        val heightPx = (heightDp * density).roundToInt().coerceAtLeast(1)
+
+        if (rawBitmap.width == widthPx && rawBitmap.height == heightPx) {
+            return rawBitmap
+        }
+
+        return Bitmap.createScaledBitmap(rawBitmap, widthPx, heightPx, true)
+    }
+
+    private fun updateCustomAnnotationBitmap(
+        uri: String?,
+        getCurrentUri: () -> String?,
+        setCurrentUri: (String?) -> Unit,
+        setBitmap: (Bitmap?) -> Unit,
+        reason: String
+    ) {
+        val normalizedUri = uri?.takeIf { it.isNotBlank() }
+        setCurrentUri(normalizedUri)
+
+        if (normalizedUri == null) {
+            setBitmap(null)
+            refreshViewOptionsFromState("clear-$reason")
+            return
+        }
+
+        Thread {
+            val bitmap = loadBitmapFromSource(normalizedUri)
+            Handler(Looper.getMainLooper()).post {
+                if (isDestroyed || getCurrentUri() != normalizedUri) {
+                    return@post
+                }
+                setBitmap(bitmap)
+                refreshViewOptionsFromState("apply-$reason")
+            }
+        }.start()
+    }
+
+    private fun applyRouteMarkerVisibleFromState() {
+        naviView.setRouteMarkerVisible(
+            routeMarkerShowStartEndVia,
+            routeMarkerShowFootFerry,
+            routeMarkerShowForbidden,
+            routeMarkerShowRouteStartIcon,
+            routeMarkerShowRouteEndIcon
+        )
+    }
+
+    private fun commitViewOptions(mutator: (AMapNaviViewOptions) -> Unit) {
+        val options = naviView.viewOptions ?: AMapNaviViewOptions()
+        mutator(options)
+        naviView.viewOptions = options
+        refreshNaviUILayout("commitViewOptions")
+    }
+
+    private fun logCurrentNaviPathState(reason: String) {
+        val naviPath = aMapNavi?.naviPath
+        val waypointCount = naviPath?.wayPoint?.size ?: 0
+        val waypointIndexCount = naviPath?.wayPointIndex?.size ?: 0
+        Log.d(
+            "ExpoGaodeMapNaviView",
+            "pathState[$reason]: routeType=${naviPath?.routeType} length=${naviPath?.allLength} time=${naviPath?.allTime} labels=${naviPath?.labels} labelId=${naviPath?.labelId} waypointCount=$waypointCount waypointIndexCount=$waypointIndexCount start=${naviPath?.startPoint} end=${naviPath?.endPoint}"
+        )
+    }
+
+    private fun stabilizeIndependentRouteRendering(reason: String) {
+        val routeId = activeIndependentRouteId ?: return
+        val delays = longArrayOf(0L, 180L, 420L)
+        delays.forEach { delayMillis ->
+            naviView.postDelayed({
+                if (isDestroyed) {
+                    return@postDelayed
+                }
+                try {
+                    val selected = aMapNavi?.selectRouteId(routeId)
+                    Log.d(
+                        "ExpoGaodeMapNaviView",
+                        "stabilizeIndependentRouteRendering[$reason/$delayMillis]: routeId=$routeId selected=$selected"
+                    )
+                    applyRouteMarkerVisibleFromState()
+                    logCurrentNaviPathState("stabilize-$reason-$delayMillis")
+                } catch (error: Exception) {
+                    Log.e(
+                        "ExpoGaodeMapNaviView",
+                        "Failed to stabilize independent route rendering: reason=$reason delay=$delayMillis routeId=$routeId",
+                        error
+                    )
+                }
+            }, delayMillis)
+        }
+    }
+
+    private fun refreshNaviUILayout(reason: String) {
+        if (isDestroyed) {
+            return
+        }
+
+        naviView.post {
+            if (isDestroyed) {
+                return@post
+            }
+
+            updateTopInsetPadding()
+            updateNativeTopInfoLayoutVisibility()
+
+            val needsAggressiveRefresh =
+                hideNativeTopInfoLayout ||
+                !showUIElements ||
+                androidStatusBarPaddingTopDp != null
+
+            if (needsAggressiveRefresh) {
+                naviView.requestLayout()
+                naviView.forceLayout()
+                naviView.invalidate()
+                naviView.postInvalidateOnAnimation()
+                requestLayout()
+                invalidate()
+                postInvalidateOnAnimation()
+            }
+
+            Log.d("ExpoGaodeMapNaviView", "refreshNaviUILayout: $reason")
+        }
+    }
+
+    private fun shouldHideNativeTopInfoView(view: View): Boolean {
+        val className = view.javaClass.name
+        return className.contains("BaseNaviInfoLayout") ||
+            className.contains("NaviInfoLayout_")
+    }
+
+    private fun updateNativeTopInfoLayoutVisibility() {
+        if (isDestroyed) {
+            return
+        }
+
+        if (!hideNativeTopInfoLayout) {
+            return
+        }
+
+        val queue = ArrayDeque<View>()
+        val targetVisibility = View.GONE
+        queue.add(naviView)
+
+        while (queue.isNotEmpty()) {
+            val current = queue.removeFirst()
+            if (current is ViewGroup) {
+                for (index in 0 until current.childCount) {
+                    queue.add(current.getChildAt(index))
+                }
+            }
+
+            if (!shouldHideNativeTopInfoView(current)) {
+                continue
+            }
+
+            if (current.visibility != targetVisibility) {
+                current.visibility = targetVisibility
+                current.requestLayout()
+                current.invalidate()
+            }
+        }
+    }
+
+    private fun suppressNativeTopInfoLayoutFlash() {
+        if (!hideNativeTopInfoLayout || isDestroyed) {
+            return
+        }
+
+        val delays = longArrayOf(0L, 16L, 48L, 96L, 180L)
+        delays.forEach { delayMs ->
+            naviView.postDelayed({
+                if (!isDestroyed) {
+                    updateNativeTopInfoLayoutVisibility()
+                }
+            }, delayMs)
+        }
+    }
+
+    private fun emitVisualStateUpdate() {
+        onNavigationVisualStateUpdate(
+            mapOf(
+                "isCrossVisible" to isCrossVisible,
+                "isModeCrossVisible" to isModeCrossVisible,
+                "isLaneInfoVisible" to isLaneInfoCurrentlyVisible
+            )
+        )
+    }
+
+    private fun extractLaneValues(raw: Any?): List<Int> {
+        return when (raw) {
+            is IntArray -> raw.map { it.toInt() }
+            is ByteArray -> raw.map { it.toInt() and 0xFF }
+            is ShortArray -> raw.map { it.toInt() }
+            is Array<*> -> raw.mapNotNull { (it as? Number)?.toInt() }
+            else -> emptyList()
+        }
+    }
+
+    private fun getLaneArrayValue(laneInfo: AMapLaneInfo, fieldName: String): List<Int> {
+        val reflectedValue = runCatching {
+            laneInfo.javaClass.getField(fieldName).get(laneInfo)
+        }.getOrElse {
+            runCatching {
+                val getterName = "get" + fieldName.replaceFirstChar { char ->
+                    if (char.isLowerCase()) {
+                        char.titlecase()
+                    } else {
+                        char.toString()
+                    }
+                }
+                laneInfo.javaClass.getMethod(getterName).invoke(laneInfo)
+            }.getOrNull()
+        }
+
+        return extractLaneValues(reflectedValue)
+    }
+
+    private fun resolveLaneCount(laneInfo: AMapLaneInfo): Int {
+        val reflectedCount = runCatching {
+            laneInfo.javaClass.getField("laneCount").get(laneInfo) as? Number
+        }.getOrElse {
+            runCatching {
+                laneInfo.javaClass.getMethod("getLaneCount").invoke(laneInfo) as? Number
+            }.getOrNull()
+        }
+
+        return reflectedCount?.toInt()?.coerceAtLeast(0) ?: 0
+    }
+
+    private fun serializeLaneInfo(laneInfo: AMapLaneInfo?): Map<String, Any>? {
+        if (laneInfo == null) {
+            return null
+        }
+
+        val backgroundLane = getLaneArrayValue(laneInfo, "backgroundLane")
+        val frontLane = getLaneArrayValue(laneInfo, "frontLane")
+        val declaredCount = resolveLaneCount(laneInfo)
+        val sentinelIndex = backgroundLane.indexOf(255).takeIf { it >= 0 }
+
+        val resolvedCount = listOfNotNull(
+            sentinelIndex,
+            declaredCount.takeIf { it > 0 },
+            backgroundLane.size.takeIf { it > 0 },
+            frontLane.size.takeIf { it > 0 }
+        ).minOrNull() ?: 0
+
+        if (resolvedCount <= 0) {
+            return null
+        }
+
+        val normalizedBackground = (0 until resolvedCount).map { index ->
+            backgroundLane.getOrNull(index) ?: 255
+        }
+        val normalizedFront = (0 until resolvedCount).map { index ->
+            frontLane.getOrNull(index) ?: 255
+        }
+
+        return mapOf(
+            "laneCount" to resolvedCount,
+            "backgroundLane" to normalizedBackground,
+            "frontLane" to normalizedFront
+        )
+    }
+
+    private fun resolveNextTurnIconType(currentSegmentIndex: Int): Int? {
+        if (currentSegmentIndex < 0) {
+            return null
+        }
+
+        val steps = aMapNavi?.naviPath?.steps ?: return null
+        val nextSegmentIndex = currentSegmentIndex + 1
+        if (nextSegmentIndex !in steps.indices) {
+            return null
+        }
+
+        return try {
+            steps[nextSegmentIndex].iconType
+        } catch (_: Throwable) {
+            null
+        }
+    }
+
+    /**
+     * Android 导航 SDK 仅透出当前转向图 bitmap，且不同版本方法可见性不完全一致，
+     * 这里走反射兼容，避免因为 SDK 小版本差异导致编译直接中断。
+     */
+    private fun extractTurnIconBitmap(naviInfo: NaviInfo): Bitmap? {
+        return try {
+            val method = naviInfo.javaClass.getMethod("getIconBitmap")
+            method.invoke(naviInfo) as? Bitmap
+        } catch (_: NoSuchMethodException) {
+            if (!hasLoggedMissingTurnIconBitmapApi) {
+                hasLoggedMissingTurnIconBitmapApi = true
+                Log.w(
+                    "ExpoGaodeMapNaviView",
+                    "NaviInfo#getIconBitmap is unavailable in the current AMap SDK; turnIconImage will be omitted on Android"
+                )
+            }
+            null
+        } catch (error: Throwable) {
+            Log.w("ExpoGaodeMapNaviView", "Failed to extract turn icon bitmap", error)
+            null
+        }
+    }
+
+    private fun bitmapToPngBytes(bitmap: Bitmap): ByteArray? {
+        return try {
+            val outputStream = ByteArrayOutputStream()
+            bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
+            outputStream.toByteArray()
+        } catch (error: Throwable) {
+            Log.w("ExpoGaodeMapNaviView", "Failed to serialize turn icon bitmap", error)
+            null
+        }
+    }
+
+    private fun sha1Hex(bytes: ByteArray): String {
+        val digest = MessageDigest.getInstance("SHA-1").digest(bytes)
+        return digest.joinToString("") { "%02x".format(it) }
+    }
+
+    private fun cacheTurnIconBitmap(bytes: ByteArray, prefix: String, contentHash: String): String? {
+        return try {
+            val directory = File(context.cacheDir, "expo_gaode_map_navigation_icons")
+            if (!directory.exists()) {
+                directory.mkdirs()
+            }
+            val file = File(directory, "${prefix}_${contentHash}.png")
+            if (!file.exists()) {
+                FileOutputStream(file).use { stream ->
+                    stream.write(bytes)
+                }
+            }
+            Uri.fromFile(file).toString()
+        } catch (error: Throwable) {
+            Log.w("ExpoGaodeMapNaviView", "Failed to cache turn icon bitmap", error)
+            null
+        }
+    }
+
+    private fun deleteCachedIconFile(uriString: String?) {
+        if (uriString.isNullOrBlank()) {
+            return
+        }
+        runCatching {
+            val path = Uri.parse(uriString).path ?: return
+            File(path).delete()
+        }
+    }
+
+    private fun updateCachedTurnIconImage(naviInfo: NaviInfo): String? {
+        val bitmap = extractTurnIconBitmap(naviInfo)
+        if (bitmap == null) {
+            deleteCachedIconFile(cachedTurnIconImageUri)
+            cachedTurnIconImageUri = null
+            cachedTurnIconContentHash = null
+            return null
+        }
+
+        val bytes = bitmapToPngBytes(bitmap) ?: return cachedTurnIconImageUri
+        val contentHash = sha1Hex(bytes)
+        if (contentHash == cachedTurnIconContentHash && !cachedTurnIconImageUri.isNullOrBlank()) {
+            return cachedTurnIconImageUri
+        }
+
+        val nextUri = cacheTurnIconBitmap(bytes, "turn_icon", contentHash) ?: return cachedTurnIconImageUri
+        val previousUri = cachedTurnIconImageUri
+        cachedTurnIconImageUri = nextUri
+        cachedTurnIconContentHash = contentHash
+        if (previousUri != nextUri) {
+            deleteCachedIconFile(previousUri)
+        }
+        return nextUri
+    }
+
+    private fun emitTrafficStatusesUpdate(retainDistance: Int? = null) {
+        val trafficStatuses = try {
+            aMapNavi?.getTrafficStatuses(0, 0)
+        } catch (_: Throwable) {
+            null
+        } ?: emptyList()
+
+        val totalLength = try {
+            aMapNavi?.naviPath?.allLength
+        } catch (_: Throwable) {
+            null
+        } ?: currentRouteTotalLength
+
+        currentRouteTotalLength = totalLength ?: currentRouteTotalLength
+
+        val payload = mutableMapOf<String, Any>(
+            "items" to trafficStatuses.map { status ->
+                mapOf(
+                    "status" to status.status,
+                    "length" to status.length
+                )
+            }
+        )
+
+        if ((totalLength ?: 0) > 0) {
+            payload["totalLength"] = totalLength as Int
+        }
+
+        if (retainDistance != null) {
+            payload["retainDistance"] = retainDistance
+        }
+
+        onTrafficStatusesUpdate(payload)
+    }
     
     // 导航监听器
     @Suppress("DEPRECATION", "OVERRIDE_DEPRECATION")
@@ -94,6 +962,10 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
 
         override fun onStartNavi(type: Int) {
             Log.d("ExpoGaodeMapNaviView", "导航开始: type=$type")
+            isNavigationRunning = true
+            syncNavigationForegroundService("on_start_navi")
+            logCurrentNaviPathState("onStartNavi")
+            stabilizeIndependentRouteRendering("onStartNavi")
             onNavigationStarted(mapOf(
                 "type" to type,
                 "isEmulator" to (type == 1)
@@ -101,7 +973,7 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
         }
 
         override fun onTrafficStatusUpdate() {
-            // 交通状态更新
+            emitTrafficStatusesUpdate()
         }
 
         override fun onLocationChange(location: AMapNaviLocation?) {
@@ -135,10 +1007,18 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
         }
 
         override fun onEndEmulatorNavi() {
+            isNavigationRunning = false
+            syncNavigationForegroundService("on_end_emulator_navi")
+            resetCustomWaypointMarkerArrivalState()
+            activeIndependentRouteId = null
             onNavigationEnded(emptyMap())
         }
 
         override fun onArriveDestination() {
+            isNavigationRunning = false
+            syncNavigationForegroundService("on_arrive_destination")
+            resetCustomWaypointMarkerArrivalState()
+            activeIndependentRouteId = null
             onArriveDestination(emptyMap())
         }
 
@@ -156,6 +1036,14 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
                 // GPS 导航
                 aMapNavi?.startNavi(NaviType.GPS)
             }
+            Handler(Looper.getMainLooper()).post {
+                try {
+                    applyRouteMarkerVisibleFromState()
+                    refreshCustomWaypointMarkers("calculate-route-success")
+                } catch (e: Exception) {
+                    Log.e("ExpoGaodeMapNaviView", "Failed to reapply route marker visibility after route success", e)
+                }
+            }
         }
 
         override fun onCalculateRouteSuccess(result: AMapCalcRouteResult?) {
@@ -172,9 +1060,19 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
                 // GPS 导航
                 aMapNavi?.startNavi(NaviType.GPS)
             }
+            Handler(Looper.getMainLooper()).post {
+                try {
+                    applyRouteMarkerVisibleFromState()
+                    refreshCustomWaypointMarkers("calculate-route-success-result")
+                } catch (e: Exception) {
+                    Log.e("ExpoGaodeMapNaviView", "Failed to reapply route marker visibility after route success", e)
+                }
+            }
         }
 
         override fun onCalculateRouteFailure(errorCode: Int) {
+            isNavigationRunning = false
+            syncNavigationForegroundService("calculate_route_failure_code")
             onRouteCalculated(mapOf(
                 "success" to false,
                 "errorCode" to errorCode
@@ -182,6 +1080,8 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
         }
 
         override fun onCalculateRouteFailure(result: AMapCalcRouteResult?) {
+            isNavigationRunning = false
+            syncNavigationForegroundService("calculate_route_failure_result")
             onRouteCalculated(mapOf(
                 "success" to false,
                 "errorInfo" to (result?.errorDescription ?: "Unknown error")
@@ -201,6 +1101,7 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
         }
 
         override fun onArrivedWayPoint(wayPointIndex: Int) {
+            markCustomWaypointArrived(wayPointIndex)
             onWayPointArrived(mapOf(
                 "index" to wayPointIndex
             ))
@@ -214,14 +1115,47 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
 
         override fun onNaviInfoUpdate(naviInfo: NaviInfo?) {
             naviInfo?.let {
-                onNavigationInfoUpdate(mapOf(
+                val allLength = try {
+                    aMapNavi?.naviPath?.allLength
+                } catch (_: Throwable) {
+                    null
+                }
+                val safeRetainDistance = it.pathRetainDistance.coerceAtLeast(0)
+                currentRouteTotalLength = maxOf(
+                    currentRouteTotalLength ?: 0,
+                    allLength ?: 0,
+                    safeRetainDistance
+                ).takeIf { total -> total > 0 } ?: currentRouteTotalLength
+                val nextIconType = resolveNextTurnIconType(it.curStep)
+                val turnIconImage = updateCachedTurnIconImage(it)
+                val payload = mutableMapOf<String, Any>(
+                    "naviMode" to it.naviType,
                     "currentRoadName" to (it.currentRoadName ?: ""),
                     "nextRoadName" to (it.nextRoadName ?: ""),
                     "pathRetainDistance" to it.pathRetainDistance,
                     "pathRetainTime" to it.pathRetainTime,
                     "curStepRetainDistance" to it.curStepRetainDistance,
-                    "curStepRetainTime" to it.curStepRetainTime
-                ))
+                    "curStepRetainTime" to it.curStepRetainTime,
+                    "currentSpeed" to it.currentSpeed,
+                    "iconType" to it.iconType,
+                    "iconDirection" to it.iconType,
+                    "currentSegmentIndex" to it.curStep,
+                    "currentLinkIndex" to it.curLink,
+                    "currentPointIndex" to it.curPoint,
+                    "routeRemainTrafficLightCount" to it.routeRemainLightCount,
+                    "driveDistance" to 0,
+                    "driveTime" to 0
+                )
+                if (nextIconType != null) {
+                    payload["nextIconType"] = nextIconType
+                }
+                if (!turnIconImage.isNullOrBlank()) {
+                    payload["turnIconImage"] = turnIconImage
+                }
+                onNavigationInfoUpdate(payload)
+                updateNavigationNotification(it)
+                emitTrafficStatusesUpdate(it.pathRetainDistance)
+                refreshNaviUILayout("onNaviInfoUpdate")
             }
         }
 
@@ -239,30 +1173,57 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
 
         override fun showCross(crossImg: AMapNaviCross?) {
             // 显示路口放大图
+            isCrossVisible = true
+            emitVisualStateUpdate()
+            suppressNativeTopInfoLayoutFlash()
+            refreshNaviUILayout("showCross")
         }
 
         override fun hideCross() {
             // 隐藏路口放大图
+            isCrossVisible = false
+            emitVisualStateUpdate()
+            suppressNativeTopInfoLayoutFlash()
+            refreshNaviUILayout("hideCross")
         }
 
         override fun showModeCross(modelCross: AMapModelCross?) {
             // 显示路口3D模型
+            isModeCrossVisible = true
+            emitVisualStateUpdate()
+            suppressNativeTopInfoLayoutFlash()
+            refreshNaviUILayout("showModeCross")
         }
 
         override fun hideModeCross() {
             // 隐藏路口3D模型
+            isModeCrossVisible = false
+            emitVisualStateUpdate()
+            suppressNativeTopInfoLayoutFlash()
+            refreshNaviUILayout("hideModeCross")
         }
 
         override fun showLaneInfo(laneInfo: AMapLaneInfo?) {
             // 显示车道信息
+            isLaneInfoCurrentlyVisible = true
+            emitVisualStateUpdate()
+            serializeLaneInfo(laneInfo)?.let { onLaneInfoUpdate(it) }
+            refreshNaviUILayout("showLaneInfo")
         }
 
         override fun showLaneInfo(laneInfos: Array<out AMapLaneInfo>?, laneBackgroundInfo: ByteArray?, laneRecommendedInfo: ByteArray?) {
             // 显示车道信息（重载方法）
+            isLaneInfoCurrentlyVisible = true
+            emitVisualStateUpdate()
+            serializeLaneInfo(laneInfos?.firstOrNull())?.let { onLaneInfoUpdate(it) }
+            refreshNaviUILayout("showLaneInfoArray")
         }
 
         override fun hideLaneInfo() {
             // 隐藏车道信息
+            isLaneInfoCurrentlyVisible = false
+            emitVisualStateUpdate()
+            refreshNaviUILayout("hideLaneInfo")
         }
 
         override fun notifyParallelRoad(parallelRoadType: Int) {
@@ -306,12 +1267,13 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
             SDKInitializer.restorePersistedState(appCtx)
             if (!SDKInitializer.isPrivacyReady()) {
                 throw IllegalStateException(
-                    "隐私协议未完成确认，请先调用 setPrivacyConfig（或 setPrivacyShow/setPrivacyAgree）"
+                    "隐私协议未完成确认，请先调用 setPrivacyConfig"
                 )
             }
 
             // 初始化导航视图
             naviView.onCreate(Bundle())
+            naviView.viewOptions = createInitialViewOptions()
             naviView.layoutParams = android.widget.FrameLayout.LayoutParams(
                 android.widget.FrameLayout.LayoutParams.MATCH_PARENT,
                 android.widget.FrameLayout.LayoutParams.MATCH_PARENT
@@ -323,8 +1285,6 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
             naviView.clipChildren = false
             naviView.clipToPadding = false
             
-            ensureOverlayInsetHook()
-            
             // 使用单例获取导航实例
             aMapNavi = AMapNavi.getInstance(appCtx)
             aMapNavi?.addAMapNaviListener(naviListener)
@@ -333,65 +1293,8 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
             aMapNavi?.setUseInnerVoice(true, true) // 启用内置语音，并回调文字
            //设置是否为骑步行视图
             aMapNavi?.isNaviTravelView = isNaviTravelView
-            // 设置导航视图选项 - 根据 AMapNaviViewOptions API
-            val options = AMapNaviViewOptions()
-            
-            // === 基础界面控制 ===
-            // 注意：isLayoutVisible 控制整个导航UI布局的显示
-            // 设置为 true 将显示导航信息面板（包括距离、时间等）
-            options.isLayoutVisible = showUIElements
-            options.isSettingMenuEnabled = true // 显示设置菜单按钮
-            options.isCompassEnabled = isCompassEnabled // 显示指南针
-            options.isTrafficBarEnabled = androidTrafficBarEnabled // 显示路况条
-            options.isRouteListButtonShow = isRouteListButtonShow // 显示路线全览按钮
-
-            Log.d("ExpoGaodeMapNaviView", "导航UI配置: isLayoutVisible=true, 所有UI元素已启用")
-            
-            // === 地图图层 ===
-            options.isTrafficLayerEnabled = isTrafficLayerEnabled // 显示交通路况图层
-            options.isTrafficLine = isTrafficLine // 显示交通路况线
-            
-            // === 路口放大图和车道信息 ===
-            options.isRealCrossDisplayShow = isRealCrossDisplayShow // 显示实景路口放大图
-            options.setModeCrossDisplayShow(true) // 显示路口3D模型（使用方法而非属性）
-            options.isLaneInfoShow = true // 显示车道信息
-            options.isEyrieCrossDisplay = true // 显示鹰眼路口图
-            
-            // === 摄像头和电子眼 ===
-            options.isCameraBubbleShow = showCamera // 显示摄像头气泡（已废弃但仍可用）
-            options.isShowCameraDistance = true // 显示与摄像头的距离
-            options.isWidgetOverSpeedPulseEffective = true // 超速脉冲效果
-            
-            // === 路线和导航箭头 ===
-            options.isAutoDrawRoute = true // 自动绘制路线
-            options.isNaviArrowVisible = isNaviArrowVisible // 显示导航箭头
-            options.isSecondActionVisible = true // 显示辅助操作（如下个路口提示）
-            options.isDrawBackUpOverlay = true // 绘制备用路线覆盖物
-            if(isVectorLineShow)
-            options.isLeaderLineEnabled
-            
-            // === 地图锁车和视角控制 ===
-            options.isAutoLockCar = autoLockCar // 自动锁车
-            options.lockMapDelayed = 5000L // 5秒后自动锁车（毫秒）
-            options.isAutoDisplayOverview = false // 不自动显示全览
-            options.isAutoChangeZoom = autoChangeZoom // 根据导航自动调整缩放级别
-            options.zoom = 18 // 锁车时的缩放级别 (14-18)
-            options.tilt = 35 // 锁车时的倾斜角度 (0-60)
-            
-            // === 已走路线处理 ===
-            options.isAfterRouteAutoGray = isAfterRouteAutoGray // 走过的路线自动变灰
-            
-            // === 传感器和定位 ===
-            options.isSensorEnable = true // 使用设备传感器
-            
-            // === 夜间模式（已废弃但保留兼容） ===
-            // 建议使用 setMapStyle 方法设置地图样式
-            options.isAutoNaviViewNightMode = false // 不自动切换夜间模式
-            
-            // === 鹰眼地图 ===
-            options.isEagleMapVisible = false // 不显示鹰眼地图（小地图）
-            
-            naviView.viewOptions = options
+            Log.d("ExpoGaodeMapNaviView", "导航UI配置初始化完成")
+            registerActiveView()
 
             naviView.post { updateTopInsetPadding() }
             
@@ -413,7 +1316,10 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
                 override fun onNextRoadClick() {}
                 override fun onScanViewButtonClick() {}
                 override fun onLockMap(isLock: Boolean) {}
-                override fun onNaviViewLoaded() {}
+                override fun onNaviViewLoaded() {
+                    updateNativeTopInfoLayoutVisibility()
+                    refreshNaviUILayout("onNaviViewLoaded")
+                }
                 override fun onMapTypeChanged(mapType: Int) {}
             })
             
@@ -422,271 +1328,34 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
         }
     }
 
-    private fun getStatusBarHeightPx(): Int {
-        return try {
-            val resourceId = context.resources.getIdentifier("status_bar_height", "dimen", "android")
-            if (resourceId > 0) context.resources.getDimensionPixelSize(resourceId) else 0
-        } catch (_: Exception) {
-            0
-        }
-    }
-
     private fun dpToPx(dp: Double): Int {
         val density = context.resources.displayMetrics.density
         return (dp * density + 0.5).toInt()
     }
 
     private fun updateTopInsetPadding() {
-        val shouldApplyPadding =  androidStatusBarPaddingTopDp != null
-        val paddingTopPx = if (shouldApplyPadding) {
-            androidStatusBarPaddingTopDp?.let { dpToPx(it) } ?: getStatusBarHeightPx()
-        } else {
-           //默认返回状态栏高度
-            getStatusBarHeightPx()
-        }
+        val paddingTopPx = androidStatusBarPaddingTopDp?.let { dpToPx(it) } ?: 0
 
         if (lastAppliedTopPaddingPx == paddingTopPx) {
             return
         }
 
         lastAppliedTopPaddingPx = paddingTopPx
-
-        topInsetPx = paddingTopPx
-
-        naviView.setPadding(0, 0, 0, 0)
-
-        applyTopInsetToOverlays(paddingTopPx)
-    }
-
-    private fun ensureOverlayInsetHook() {
-        if (overlayHooked) {
-            return
-        }
-
-        overlayHooked = true
-        naviView.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
-            applyTopInsetToOverlays(topInsetPx)
-        }
-    }
-
-    private fun applyTopInsetToOverlays(paddingTopPx: Int) {
-        if (paddingTopPx <= 0) {
-            if (overlayStates.isNotEmpty()) {
-                val iterator = overlayStates.entries.iterator()
-                while (iterator.hasNext()) {
-                    val entry = iterator.next()
-                    val view = entry.key
-                    val state = entry.value
-                    view.translationY = state.translationY
-                    view.setPadding(view.paddingLeft, state.paddingTop, view.paddingRight, view.paddingBottom)
-                    iterator.remove()
-                }
-            }
-            return
-        }
-
-        val rawTargets = findTopOverlayTargets(naviView)
-        val targets = filterTopLevelTargets(naviView, rawTargets)
-        if (targets.isEmpty()) {
-            val applied = applyTopPaddingToNaviUiLayer(paddingTopPx)
-            if (!applied) {
-                naviView.post { applyTopPaddingToNaviUiLayer(paddingTopPx) }
-            }
-            return
-        }
-
-        val targetSet = targets.toHashSet()
-
-        val iterator = overlayStates.entries.iterator()
-        while (iterator.hasNext()) {
-            val entry = iterator.next()
-            val view = entry.key
-            if (!targetSet.contains(view)) {
-                val state = entry.value
-                view.translationY = state.translationY
-                view.setPadding(view.paddingLeft, state.paddingTop, view.paddingRight, view.paddingBottom)
-                iterator.remove()
-            }
-        }
-
-        for (target in targets) {
-            if (!overlayStates.containsKey(target)) {
-                overlayStates[target] = OverlayState(
-                    translationY = target.translationY,
-                    paddingTop = target.paddingTop
-                )
-            }
-            ensureNoClipChain(target)
-            target.translationY = paddingTopPx.toFloat()
-        }
-    }
-
-    private fun ensureNoClipChain(view: View) {
-        var currentParent = view.parent
-        while (currentParent is ViewGroup) {
-            currentParent.clipChildren = false
-            currentParent.clipToPadding = false
-            if (currentParent === naviView) {
-                break
-            }
-            currentParent = currentParent.parent
-        }
-    }
-
-    private fun filterTopLevelTargets(root: ViewGroup, targets: List<View>): List<View> {
-        if (targets.size <= 1) {
-            return targets
-        }
-
-        val set = targets.toHashSet()
-        val result = ArrayList<View>(targets.size)
-        for (view in targets) {
-            var parent = view.parent
-            var hasAncestorInTargets = false
-            while (parent is View) {
-                if (parent === root) {
-                    break
-                }
-                if (set.contains(parent)) {
-                    hasAncestorInTargets = true
-                    break
-                }
-                parent = parent.parent
-            }
-            if (!hasAncestorInTargets) {
-                result.add(view)
-            }
-        }
-
-        return result
-    }
-
-    private fun findTopOverlayTargets(root: ViewGroup): List<View> {
-        val result = ArrayList<View>()
-        val parentHeight = root.height
-        val parentWidth = root.width
-        if (parentHeight <= 0 || parentWidth <= 0) {
-            return result
-        }
-
-        val queue = ArrayDeque<View>()
-        for (i in 0 until root.childCount) {
-            queue.add(root.getChildAt(i))
-        }
-
-        while (queue.isNotEmpty()) {
-            val view = queue.removeFirst()
-            val group = view as? ViewGroup
-            if (group != null) {
-                for (i in 0 until group.childCount) {
-                    queue.add(group.getChildAt(i))
-                }
-            }
-
-            if (!view.isShown) {
-                continue
-            }
-
-            val name = view.javaClass.name
-            if (name.contains("MapView", ignoreCase = true) ||
-                name.contains("Texture", ignoreCase = true) ||
-                name.contains("Surface", ignoreCase = true) ||
-                name.contains("GLSurface", ignoreCase = true)
-            ) {
-                continue
-            }
-
-            if (view.height <= 0 || view.width <= 0) {
-                continue
-            }
-
-            if (view.top > 1) {
-                continue
-            }
-
-            if (view.height >= (parentHeight * 0.6f).toInt()) {
-                continue
-            }
-
-            val wideEnough = view.width >= (parentWidth * 0.5f).toInt()
-            val likelyUi = wideEnough && (view.isClickable || (view as? ViewGroup)?.childCount ?: 0 > 0)
-            if (!likelyUi) {
-                continue
-            }
-
-            result.add(view)
-        }
-
-        return result
-    }
-
-    private fun applyTopPaddingToNaviUiLayer(paddingTopPx: Int): Boolean {
-        val uiRoot = findNaviUiRoot(naviView) ?: return false
-
-        uiRoot.setPadding(uiRoot.paddingLeft, paddingTopPx, uiRoot.paddingRight, uiRoot.paddingBottom)
-        uiRoot.clipToPadding = false
-        return true
-    }
-
-    private fun findNaviUiRoot(root: ViewGroup): ViewGroup? {
-        var best: ViewGroup? = null
-        var bestScore = Int.MIN_VALUE
-
-        val queue = ArrayDeque<View>()
-        for (i in 0 until root.childCount) {
-            queue.add(root.getChildAt(i))
-        }
-
-        while (queue.isNotEmpty()) {
-            val view = queue.removeFirst()
-            val group = view as? ViewGroup
-            if (group != null) {
-                val score = scoreAsUiRootCandidate(group)
-                if (score > bestScore) {
-                    bestScore = score
-                    best = group
-                }
-                for (i in 0 until group.childCount) {
-                    queue.add(group.getChildAt(i))
-                }
-            }
+        if (paddingTopPx > 0) {
+            naviView.setPadding(0, paddingTopPx, 0, 0)
+        } else {
+            naviView.setPadding(0, 0, 0, 0)
         }
-
-        return if (bestScore > 0) best else null
+        naviView.requestLayout()
     }
 
-    private fun scoreAsUiRootCandidate(group: ViewGroup): Int {
-        val name = group.javaClass.name
-        if (name.contains("MapView", ignoreCase = true) ||
-            name.contains("Texture", ignoreCase = true) ||
-            name.contains("Surface", ignoreCase = true) ||
-            name.contains("GLSurface", ignoreCase = true)
-        ) {
-            return Int.MIN_VALUE
-        }
-
-        var score = 0
-
-        val lp = group.layoutParams
-        if (lp != null) {
-            if (lp.width == ViewGroup.LayoutParams.MATCH_PARENT && lp.height == ViewGroup.LayoutParams.MATCH_PARENT) {
-                score += 4
-            } else if (lp.width == ViewGroup.LayoutParams.MATCH_PARENT) {
-                score += 2
-            }
-        }
-
-        if (group.childCount >= 3) {
-            score += 2
-        } else if (group.childCount >= 1) {
-            score += 1
-        }
-
-        if (name.contains("RelativeLayout", ignoreCase = true) || name.contains("FrameLayout", ignoreCase = true)) {
-            score += 1
+    private fun applyLeaderLineSetting(options: AMapNaviViewOptions, enabled: Boolean) {
+        val color = if (enabled) {
+            Color.argb(160, 48, 122, 246)
+        } else {
+            -1
         }
-
-        return score
+        options.setLeaderLineEnabled(color)
     }
 
 
@@ -698,50 +1367,50 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
 
     fun applyShowUIElements(visible: Boolean) {
         showUIElements = visible
-        val options = naviView.viewOptions
-        options.isLayoutVisible = visible
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            options.isLayoutVisible = visible
+        }
     }
 
     fun applyAndroidTrafficBarEnabled(enabled: Boolean) {
         androidTrafficBarEnabled = enabled
-        val options = naviView.viewOptions
-        options.isTrafficBarEnabled = enabled
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            options.isTrafficBarEnabled = enabled
+        }
     }
 
     fun applyShowTrafficButton(enabled: Boolean) {
-        isTrafficLayerEnabled = enabled
-        val options = naviView.viewOptions
-        options.isTrafficLayerEnabled = enabled
-        naviView.viewOptions = options
+        isTrafficButtonVisible = enabled
+        commitViewOptions { options ->
+            options.isTrafficLayerEnabled = enabled
+        }
     }
 
     fun applyShowBrowseRouteButton(enabled: Boolean) {
         isRouteListButtonShow = enabled
-        val options = naviView.viewOptions
-        options.isRouteListButtonShow = enabled
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            options.isRouteListButtonShow = enabled
+        }
     }
 
     fun applyShowGreyAfterPass(enabled: Boolean){
         isAfterRouteAutoGray = enabled
-        val options = naviView.viewOptions
-        options.isAfterRouteAutoGray = enabled
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            options.isAfterRouteAutoGray = enabled
+        }
     }
 
     fun applyShowVectorline(enabled: Boolean){
         isVectorLineShow = enabled
-        val options = naviView.viewOptions
-        if(enabled)
-        options.isLeaderLineEnabled
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            applyLeaderLineSetting(options, enabled)
+        }
     }
 
     fun startNavigation(startLat: Double, startLng: Double, endLat: Double, endLng: Double, promise: expo.modules.kotlin.Promise) {
         Log.d("ExpoGaodeMapNaviView", "startNavigation: $startLat, $startLng, $endLat, $endLng, naviType: $naviType")
         try {
+            resetCustomWaypointMarkerArrivalState()
             startCoordinate = NaviLatLng(startLat, startLng)
             endCoordinate = NaviLatLng(endLat, endLng)
             
@@ -778,9 +1447,47 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
         }
     }
 
+    fun startNavigationWithIndependentPath(
+        token: Int,
+        routeId: Int?,
+        routeIndex: Int?,
+        requestedNaviType: Int?,
+        promise: expo.modules.kotlin.Promise
+    ) {
+        try {
+            resetCustomWaypointMarkerArrivalState()
+            val finalNaviType = requestedNaviType ?: naviType
+            val result = independentRouteManager.start(context, token, finalNaviType, routeId, routeIndex)
+            if (result.success) {
+                activeIndependentRouteId = result.resolvedRouteId
+                promise.resolve(
+                    mapOf(
+                        "success" to true,
+                        "message" to result.message,
+                        "token" to token,
+                        "naviType" to finalNaviType,
+                        "sdkNaviType" to result.sdkNaviType,
+                        "routeId" to result.resolvedRouteId,
+                        "pathCount" to result.pathCount,
+                        "mainPathIndex" to result.mainPathIndex
+                    )
+                )
+            } else {
+                activeIndependentRouteId = null
+                promise.reject("START_INDEPENDENT_NAVI_FAILED", result.message, null)
+            }
+        } catch (e: Exception) {
+            activeIndependentRouteId = null
+            promise.reject("START_INDEPENDENT_NAVI_ERROR", e.message, e)
+        }
+    }
+
     fun stopNavigation(promise: expo.modules.kotlin.Promise) {
         try {
             aMapNavi?.stopNavi()
+            isNavigationRunning = false
+            syncNavigationForegroundService("stop_navigation")
+            resetCustomWaypointMarkerArrivalState()
             promise.resolve(mapOf(
                 "success" to true,
                 "message" to "导航已停止"
@@ -793,10 +1500,15 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
     // Prop setters - 使用不同的方法名避免与 var 属性的自动 setter 冲突
     fun applyShowCamera(show: Boolean) {
         showCamera = show
-        // 摄像头显示设置
-        val options = naviView.viewOptions
-        options.isCameraBubbleShow = show
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            options.isCameraBubbleShow = show
+        }
+    }
+
+    fun applyAndroidBackgroundNavigationNotificationEnabled(enabled: Boolean) {
+        androidBackgroundNavigationNotificationEnabled = enabled
+        Log.d("ExpoGaodeMapNaviView", "applyAndroidBackgroundNavigationNotificationEnabled=$enabled")
+        syncNavigationForegroundService("prop_update")
     }
 
     fun applyNaviType(type: Int) {
@@ -830,42 +1542,125 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
     
     fun applyAutoLockCar(enabled: Boolean) {
         autoLockCar = enabled
-        val options = naviView.viewOptions
-        options.isAutoLockCar = enabled
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            options.isAutoLockCar = enabled
+        }
     }
     
     fun applyAutoChangeZoom(enabled: Boolean) {
         autoChangeZoom = enabled
-        val options = naviView.viewOptions
-        options.isAutoChangeZoom = enabled
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            options.isAutoChangeZoom = enabled
+        }
     }
     
     fun applyTrafficLayerEnabled(enabled: Boolean) {
-        isTrafficLine = enabled
-        val options = naviView.viewOptions
-        options.isTrafficLine = enabled
-        naviView.viewOptions = options
+        isTrafficLineEnabled = enabled
+        commitViewOptions { options ->
+            options.isTrafficLine = enabled
+        }
     }
     
     fun applyRealCrossDisplay(enabled: Boolean) {
         isRealCrossDisplayShow = enabled
-        val options = naviView.viewOptions
-        options.isRealCrossDisplayShow = enabled
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            options.isRealCrossDisplayShow = enabled
+        }
+    }
+
+    fun applyLaneInfoVisible(enabled: Boolean) {
+        isLaneInfoVisible = enabled
+        commitViewOptions { options ->
+            options.isLaneInfoShow = enabled
+        }
+    }
+
+    fun applyModeCrossDisplay(enabled: Boolean) {
+        isModeCrossDisplayVisible = enabled
+        commitViewOptions { options ->
+            options.setModeCrossDisplayShow(enabled)
+        }
+    }
+
+    fun applyEyrieCrossDisplay(enabled: Boolean) {
+        isEyrieCrossDisplayVisible = enabled
+        commitViewOptions { options ->
+            options.isEyrieCrossDisplay = enabled
+        }
+    }
+
+    fun applySecondActionVisible(enabled: Boolean) {
+        isSecondActionVisible = enabled
+        commitViewOptions { options ->
+            options.isSecondActionVisible = enabled
+        }
+    }
+
+    fun applyBackupOverlayVisible(enabled: Boolean) {
+        isBackupOverlayVisible = enabled
+        commitViewOptions { options ->
+            options.isDrawBackUpOverlay = enabled
+        }
     }
 
     fun applyShowCompassEnabled(enabled: Boolean){
         isCompassEnabled = enabled
-        val options = naviView.viewOptions
-        options.isCompassEnabled = enabled
-        naviView.viewOptions = options
+        commitViewOptions { options ->
+            options.isCompassEnabled = enabled
+        }
+    }
+
+    fun applyNaviStatusBarEnabled(enabled: Boolean) {
+        isNaviStatusBarEnabled = enabled
+        commitViewOptions { options ->
+            applyNaviStatusBarEnabledCompat(options, enabled)
+        }
+    }
+
+    fun applyLockZoom(level: Int) {
+        lockZoomLevel = level.coerceIn(14, 18)
+        commitViewOptions { options ->
+            options.zoom = lockZoomLevel
+        }
+    }
+
+    fun applyLockTilt(tilt: Int) {
+        lockTilt = tilt.coerceIn(0, 60)
+        commitViewOptions { options ->
+            options.tilt = lockTilt
+        }
+    }
+
+    fun applyEagleMapVisible(enabled: Boolean) {
+        isEagleMapVisible = enabled
+        commitViewOptions { options ->
+            options.isEagleMapVisible = enabled
+        }
+    }
+
+    fun applyPointToCenter(x: Double, y: Double) {
+        pointToCenterX = x
+        pointToCenterY = y
+        commitViewOptions { options ->
+            if (x > 0.0 && y > 0.0) {
+                options.setPointToCenter(x, y)
+            }
+        }
+    }
+
+    fun applyHideNativeTopInfoLayout(hidden: Boolean) {
+        hideNativeTopInfoLayout = hidden
+        updateNativeTopInfoLayoutVisibility()
+        refreshNaviUILayout("applyHideNativeTopInfoLayout")
     }
 
 
     fun applyNaviMode(mode: Int) {
-        // 0: 车头朝上 1: 正北朝上
+        naviModeValue = mode
+        commitViewOptions { options ->
+            applyNaviModeCompat(options, mode)
+        }
+        // 兼容旧版接口，保持与 options 一致
         naviView.naviMode = mode
     }
     
@@ -875,21 +1670,26 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
     }
     
     fun applyNightMode(enabled: Boolean) {
-        // 夜间模式设置 - isNightMode 属性可能不存在
+        mapViewModeTypeValue = if (enabled) 1 else 0
         try {
-            val options = naviView.viewOptions
-            if(enabled){
-                options.setMapStyle(MapStyle.NIGHT, null)
-            }else{
-                options.setMapStyle(MapStyle.DAY, null)
+            commitViewOptions { options ->
+                applyMapViewModeTypeCompat(options, mapViewModeTypeValue)
             }
-            // options.isNightMode = enabled // 该属性可能不存在
-            // 可以通过其他方式设置夜间模式
-            naviView.viewOptions = options
         } catch (e: Exception) {
             Log.e("ExpoGaodeMapNaviView", "Failed to set night mode", e)
         }
     }
+
+    fun applyMapViewModeType(mode: Int) {
+        mapViewModeTypeValue = mode
+        try {
+            commitViewOptions { options ->
+                applyMapViewModeTypeCompat(options, mode)
+            }
+        } catch (e: Exception) {
+            Log.e("ExpoGaodeMapNaviView", "Failed to apply mapViewModeType=$mode", e)
+        }
+    }
     
     /**
      * 设置是否显示自车和罗盘
@@ -905,6 +1705,200 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
         }
     }
 
+    fun applyCarImage(uri: String?) {
+        updateCustomAnnotationBitmap(
+            uri = uri,
+            getCurrentUri = { carImageUri },
+            setCurrentUri = { carImageUri = it },
+            setBitmap = {
+                sourceCarBitmap = it
+                customCarBitmap = resizeCarBitmapIfNeeded(it)
+            },
+            reason = "carBitmap"
+        )
+    }
+
+    fun applyCarImageSize(widthDp: Double?, heightDp: Double?) {
+        carImageWidthDp = widthDp
+        carImageHeightDp = heightDp
+        customCarBitmap = resizeCarBitmapIfNeeded(sourceCarBitmap)
+        refreshViewOptionsFromState("apply-carBitmap-size")
+    }
+
+    fun applyFourCornersImage(uri: String?) {
+        updateCustomAnnotationBitmap(
+            uri = uri,
+            getCurrentUri = { fourCornersImageUri },
+            setCurrentUri = { fourCornersImageUri = it },
+            setBitmap = { customFourCornersBitmap = it },
+            reason = "fourCornersBitmap"
+        )
+    }
+
+    fun applyStartPointImage(uri: String?) {
+        updateCustomAnnotationBitmap(
+            uri = uri,
+            getCurrentUri = { startPointImageUri },
+            setCurrentUri = { startPointImageUri = it },
+            setBitmap = { customStartPointBitmap = it },
+            reason = "startPointBitmap"
+        )
+    }
+
+    fun applyWayPointImage(uri: String?) {
+        updateCustomAnnotationBitmap(
+            uri = uri,
+            getCurrentUri = { wayPointImageUri },
+            setCurrentUri = { wayPointImageUri = it },
+            setBitmap = { customWayPointBitmap = it },
+            reason = "wayPointBitmap"
+        )
+    }
+
+    fun applyEndPointImage(uri: String?) {
+        updateCustomAnnotationBitmap(
+            uri = uri,
+            getCurrentUri = { endPointImageUri },
+            setCurrentUri = { endPointImageUri = it },
+            setBitmap = { customEndPointBitmap = it },
+            reason = "endPointBitmap"
+        )
+    }
+
+    fun applyCustomWaypointMarkers(markers: List<Map<String, Any?>>?) {
+        customWaypointMarkers = markers?.mapNotNull { item ->
+            val latitude = (item["latitude"] as? Number)?.toDouble() ?: return@mapNotNull null
+            val longitude = (item["longitude"] as? Number)?.toDouble() ?: return@mapNotNull null
+            val rawTitle = (item["title"] as? String)?.trim()
+            NaviCustomWaypointMarkerModel(
+                latitude = latitude,
+                longitude = longitude,
+                title = rawTitle?.takeIf { it.isNotEmpty() } ?: "途经"
+            )
+        } ?: emptyList()
+        refreshCustomWaypointMarkers("apply-custom-waypoint-markers")
+    }
+
+    private fun clearRenderedCustomWaypointMarkers() {
+        renderedCustomWaypointMarkers.forEach { marker ->
+            try {
+                marker.remove()
+            } catch (_: Throwable) {
+            }
+        }
+        renderedCustomWaypointMarkers.clear()
+    }
+
+    private fun refreshCustomWaypointMarkers(reason: String) {
+        Handler(Looper.getMainLooper()).post {
+            clearRenderedCustomWaypointMarkers()
+            if (isDestroyed || customWaypointMarkers.isEmpty()) {
+                return@post
+            }
+
+            val map = try {
+                naviView.map
+            } catch (error: Throwable) {
+                Log.w("ExpoGaodeMapNaviView", "Failed to access AMap for custom waypoint markers: $reason", error)
+                null
+            } ?: return@post
+
+            customWaypointMarkers.forEach { marker ->
+                if (marker.arrived) {
+                    return@forEach
+                }
+
+                val bitmap = createCustomWaypointBubbleBitmap(marker.title)
+                val options = MarkerOptions()
+                    .position(LatLng(marker.latitude, marker.longitude))
+                    .anchor(0.5f, 1f)
+                    .zIndex(130f)
+                    .icon(BitmapDescriptorFactory.fromBitmap(bitmap))
+                val renderedMarker = map.addMarker(options)
+                if (renderedMarker != null) {
+                    renderedCustomWaypointMarkers.add(renderedMarker)
+                }
+            }
+        }
+    }
+
+    private fun resetCustomWaypointMarkerArrivalState() {
+        customWaypointMarkers = customWaypointMarkers.map { marker ->
+            marker.copy(arrived = false)
+        }
+        refreshCustomWaypointMarkers("reset-custom-waypoint-arrival-state")
+    }
+
+    private fun markCustomWaypointArrived(rawIndex: Int) {
+        if (customWaypointMarkers.isEmpty()) {
+            return
+        }
+
+        val resolvedIndex = when {
+            rawIndex in customWaypointMarkers.indices -> rawIndex
+            (rawIndex - 1) in customWaypointMarkers.indices -> rawIndex - 1
+            else -> null
+        } ?: return
+
+        customWaypointMarkers = customWaypointMarkers.mapIndexed { index, marker ->
+            if (index == resolvedIndex) marker.copy(arrived = true) else marker
+        }
+        refreshCustomWaypointMarkers("arrived-waypoint-$rawIndex")
+    }
+
+    private fun createCustomWaypointBubbleBitmap(title: String): Bitmap {
+        val density = context.resources.displayMetrics.density
+        val fontSize = 16f * density
+        val horizontalPadding = 14f * density
+        val bodyHeight = 34f * density
+        val strokeWidth = 2.5f * density
+
+        val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            color = Color.WHITE
+            textSize = fontSize
+            typeface = Typeface.create(Typeface.DEFAULT, Typeface.BOLD)
+            textAlign = Paint.Align.CENTER
+        }
+        val bodyWidth = maxOf(
+            62f * density,
+            textPaint.measureText(title) + horizontalPadding * 2
+        )
+        val width = bodyWidth.roundToInt()
+        val height = (bodyHeight + 2f * density).roundToInt()
+        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bitmap)
+
+        val fillPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            color = Color.parseColor("#2F67FF")
+            style = Paint.Style.FILL
+        }
+        val strokePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            color = Color.WHITE
+            style = Paint.Style.STROKE
+            this.strokeWidth = strokeWidth
+        }
+        val shadowPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            color = Color.parseColor("#2D15357F")
+            style = Paint.Style.FILL
+            setShadowLayer(6f * density, 0f, 3f * density, Color.parseColor("#2D15357F"))
+        }
+
+        val bodyRect = RectF(
+            strokeWidth,
+            strokeWidth,
+            width - strokeWidth,
+            bodyHeight
+        )
+        val cornerRadius = 17f * density
+        canvas.drawRoundRect(bodyRect, cornerRadius, cornerRadius, shadowPaint)
+        canvas.drawRoundRect(bodyRect, cornerRadius, cornerRadius, fillPaint)
+        canvas.drawRoundRect(bodyRect, cornerRadius, cornerRadius, strokePaint)
+
+        val textY = bodyRect.centerY() - (textPaint.descent() + textPaint.ascent()) / 2f
+        canvas.drawText(title, bodyRect.centerX(), textY, textPaint)
+        return bitmap
+    }
+
 
     /**
      * 设置是否显示交通信号灯
@@ -936,8 +1930,13 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
         showRouteStartIcon: Boolean,
         showRouteEndIcon: Boolean
     ) {
+        routeMarkerShowStartEndVia = showStartEndVia
+        routeMarkerShowFootFerry = showFootFerry
+        routeMarkerShowForbidden = showForbidden
+        routeMarkerShowRouteStartIcon = showRouteStartIcon
+        routeMarkerShowRouteEndIcon = showRouteEndIcon
         try {
-            naviView.setRouteMarkerVisible(showStartEndVia, showFootFerry, showForbidden, showRouteStartIcon, showRouteEndIcon)
+            applyRouteMarkerVisibleFromState()
             Log.d("ExpoGaodeMapNaviView", "Route marker visibility set - startEnd:$showStartEndVia, ferry:$showFootFerry, forbidden:$showForbidden, routeStart:$showRouteStartIcon, routeEnd:$showRouteEndIcon")
         } catch (e: Exception) {
             Log.e("ExpoGaodeMapNaviView", "Failed to set route marker visibility", e)
@@ -985,9 +1984,9 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
     fun applyNaviArrowVisible(visible: Boolean) {
         try {
             isNaviArrowVisible = visible
-            val options = naviView.viewOptions
-            options.isNaviArrowVisible = visible
-            naviView.viewOptions = options
+            commitViewOptions { options ->
+                options.isNaviArrowVisible = visible
+            }
             Log.d("ExpoGaodeMapNaviView", "Navi arrow visibility set to: $visible")
         } catch (e: Exception) {
             Log.e("ExpoGaodeMapNaviView", "Failed to set navi arrow visibility", e)
@@ -996,9 +1995,9 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
+        registerActiveView()
         try {
-            naviView.onResume()
-            Log.d("ExpoGaodeMapNaviView", "NaviView resumed")
+            onResume()
         } catch (e: Exception) {
             Log.e("ExpoGaodeMapNaviView", "Error resuming navi view", e)
         }
@@ -1007,42 +2006,57 @@ class ExpoGaodeMapNaviView(context: Context, appContext: AppContext) : ExpoView(
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
         try {
-            naviView.onPause()
-            naviView.onDestroy()
-            
-            // 停止语音播报
-            aMapNavi?.stopSpeak()
-            
-            // 移除监听器但保留 AMapNavi 实例（因为是单例）
-            aMapNavi?.removeAMapNaviListener(naviListener)
-            
-            Log.d("ExpoGaodeMapNaviView", "NaviView paused and destroyed")
+            onPause()
         } catch (e: Exception) {
-            Log.e("ExpoGaodeMapNaviView", "Error destroying navi view", e)
+            Log.e("ExpoGaodeMapNaviView", "Error pausing navi view", e)
         }
     }
     
     // 生命周期方法（供外部调用）
     fun onResume() {
+        if (isDestroyed) {
+            return
+        }
         try {
             naviView.onResume()
+            refreshNaviUILayout("onResume")
+            Log.d("ExpoGaodeMapNaviView", "NaviView resumed")
         } catch (e: Exception) {
             Log.e("ExpoGaodeMapNaviView", "Error resuming navi view", e)
         }
     }
     
     fun onPause() {
+        if (isDestroyed) {
+            return
+        }
         try {
             naviView.onPause()
+            Log.d("ExpoGaodeMapNaviView", "NaviView paused")
         } catch (e: Exception) {
             Log.e("ExpoGaodeMapNaviView", "Error pausing navi view", e)
         }
     }
     
     fun onDestroy() {
+        if (isDestroyed) {
+            return
+        }
+        isDestroyed = true
+        isNavigationRunning = false
+        isHostActivityInBackground = false
+        latestNavigationNotificationSnapshot = null
+        NavigationForegroundService.stop(context)
+        unregisterActiveView()
+        clearRenderedCustomWaypointMarkers()
         try {
+            naviView.onPause()
             naviView.onDestroy()
+            aMapNavi?.stopSpeak()
             aMapNavi?.removeAMapNaviListener(naviListener)
+            deleteCachedIconFile(cachedTurnIconImageUri)
+            cachedTurnIconImageUri = null
+            cachedTurnIconContentHash = null
             // AMapNavi 是单例，不需要手动 destroy
         } catch (e: Exception) {
             Log.e("ExpoGaodeMapNaviView", "Error destroying navi view", e)