NAVAND-6461 Fixing the issue causing using incorrect vanishing offset for new routes (#11471)

* NAVAND-6461 Fixing the issue causing using incorrect vanishing offset for new routes:
- That is accomplished by insuring that `MapboxRouteLineApi.getVanishPointOffset()` returns `0.0` in case if the point was in the `VanishingPointState.DISABLED` state
- Update our unit tests to validate for that scenario
* Rename changelog files

GitOrigin-RevId: d9f95f1cc7cba595226fc1101d7b42a1a0a1071e

Author: AhmedVargos

changelog/unreleased/bugfixes/11471.md

@@ -0,0 +1 @@
+- Fixed an issue when adding a stop point on top of an already traversed route, which could show a carried-over vanishing portion from the previous route. That is accomplished by ensuring that `MapboxRouteLineApi.getVanishPointOffset()` returns `0.0` in case the point was in the `VanishingPointState.DISABLED` state.

ui-maps/src/main/java/com/mapbox/navigation/ui/maps/route/line/api/MapboxRouteLineApi.kt

@@ -263,7 +263,8 @@ class MapboxRouteLineApi @VisibleForTesting internal constructor(
             Int, List<RouteLineExpressionData>, InactiveRouteColors,
             List<RouteLineExpressionData>,
             >,
-        List<RouteLineExpressionData>,> by lazy { LruCache(4) }
+        List<RouteLineExpressionData>,
+        > by lazy { LruCache(4) }
 
     private var lastLocationPoint: Point? = null
 
@@ -354,7 +355,7 @@ class MapboxRouteLineApi @VisibleForTesting internal constructor(
      * in the [MapboxRouteLineApiOptions]. If not 0.0 is returned.
      */
     fun getVanishPointOffset(): Double {
-        return vanishingRouteLine?.vanishPointOffset ?: 0.0
+        return getSafeVanishPointOffset()
     }
 
     /**
@@ -791,7 +792,7 @@ class MapboxRouteLineApi @VisibleForTesting internal constructor(
                         activeLegIndex = currentLegIndex
 
                         val (maskingLayerData, routeLineData) = if (legChange) {
-                            val vanishingOffset = vanishingRouteLine?.vanishPointOffset ?: 0.0
+                            val vanishingOffset = getSafeVanishPointOffset()
                             val maskingLayerData = getRouteLineDynamicDataForMaskingLayers(
                                 currentPrimaryRoute,
                                 vanishingOffset,
@@ -1230,7 +1231,7 @@ class MapboxRouteLineApi @VisibleForTesting internal constructor(
         val alternativeRoute1 = partitionedRoutes.second.firstOrNull()
         val alternativeRoute2 = partitionedRoutes.second.getOrNull(1)
 
-        val vanishingPointOffset = vanishingRouteLine?.vanishPointOffset ?: 0.0
+        val vanishingPointOffset = getSafeVanishPointOffset()
 
         val routeLineExpressionDataDef = calculationsScope.async {
             primaryRoute.route.run {
@@ -1513,7 +1514,8 @@ class MapboxRouteLineApi @VisibleForTesting internal constructor(
     ) -> List<RouteLineExpressionData> = {
             activeLegIndex: Int,
             segments: List<RouteLineExpressionData>,
-            colors: InactiveRouteColors, ->
+            colors: InactiveRouteColors,
+        ->
         segments.parallelMap(
             {
                 if (it.legIndex != activeLegIndex) {
@@ -1604,4 +1606,22 @@ class MapboxRouteLineApi @VisibleForTesting internal constructor(
     private fun NavigationRoute?.isMultiLeg(): Boolean {
         return (this?.directionsRoute?.legs()?.size ?: 0) >= 2
     }
+
+    /**
+     * Helper method to get vanishing point offset that respects the vanishing point state.
+     * Returns 0.0 if vanishing is disabled (e.g., during INITIALIZED state) to prevent rendering
+     * stale offset values.
+     *
+     * @return the vanishing point offset if enabled, otherwise 0.0
+     */
+    private fun getSafeVanishPointOffset(): Double {
+        val vanishing = vanishingRouteLine
+        return if (vanishing == null ||
+            vanishing.vanishingPointState == VanishingPointState.DISABLED
+        ) {
+            0.0
+        } else {
+            vanishing.vanishPointOffset
+        }
+    }
 }

ui-maps/src/test/java/com/mapbox/navigation/ui/maps/route/line/api/MapboxRouteLineApiTest.kt

@@ -51,6 +51,7 @@ import com.mapbox.navigation.ui.maps.route.line.model.RouteLineColorResources
 import com.mapbox.navigation.ui.maps.route.line.model.RouteLineError
 import com.mapbox.navigation.ui.maps.route.line.model.RouteLineUpdateValue
 import com.mapbox.navigation.ui.maps.route.line.model.RouteNotFound
+import com.mapbox.navigation.ui.maps.route.line.model.VanishingPointState
 import com.mapbox.navigation.ui.maps.testing.TestRoute
 import com.mapbox.navigation.ui.maps.testing.TestingUtil.loadNavigationRoute
 import com.mapbox.navigation.utils.internal.InternalJobControlFactory
@@ -198,6 +199,58 @@ class MapboxRouteLineApiTest {
         )
     }
 
+    @Test
+    fun `getVanishPointOffset returns 0 when vanishing point state is DISABLED`() {
+        val options = MapboxRouteLineApiOptions.Builder()
+            .vanishingRouteLineEnabled(true)
+            .build()
+        every { vanishingRouteLine.vanishPointOffset } returns 0.456
+        every { vanishingRouteLine.vanishingPointState } returns VanishingPointState.DISABLED
+
+        val result = createRouteLineApi(options).getVanishPointOffset()
+
+        assertEquals(
+            0.0,
+            result,
+            0.0,
+        )
+    }
+
+    @Test
+    fun `getVanishPointOffset returns actual offset when vanishing point state is ENABLED`() {
+        val options = MapboxRouteLineApiOptions.Builder()
+            .vanishingRouteLineEnabled(true)
+            .build()
+        every { vanishingRouteLine.vanishPointOffset } returns 0.456
+        every { vanishingRouteLine.vanishingPointState } returns VanishingPointState.ENABLED
+
+        val result = createRouteLineApi(options).getVanishPointOffset()
+
+        assertEquals(
+            0.456,
+            result,
+            0.0,
+        )
+    }
+
+    @Test
+    fun `getVanishPointOffset returns actual offset when vanishing point state is ONLY_INCREASE_PROGRESS`() {
+        val options = MapboxRouteLineApiOptions.Builder()
+            .vanishingRouteLineEnabled(true)
+            .build()
+        every { vanishingRouteLine.vanishPointOffset } returns 0.789
+        every { vanishingRouteLine.vanishingPointState } returns
+            VanishingPointState.ONLY_INCREASE_PROGRESS
+
+        val result = createRouteLineApi(options).getVanishPointOffset()
+
+        assertEquals(
+            0.789,
+            result,
+            0.0,
+        )
+    }
+
     @Test
     fun getRoutes() = coroutineRule.runBlockingTest {
         val options = MapboxRouteLineApiOptions.Builder().build()