NAVAND-1073: fix geometry leg index calculation

Author: dzinad

instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/RouteRefreshTest.kt

@@ -9,6 +9,7 @@ import com.mapbox.api.directions.v5.models.DirectionsResponse
 import com.mapbox.api.directions.v5.models.Incident
 import com.mapbox.api.directions.v5.models.RouteOptions
 import com.mapbox.geojson.Point
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
 import com.mapbox.navigation.base.extensions.applyDefaultNavigationOptions
 import com.mapbox.navigation.base.options.NavigationOptions
 import com.mapbox.navigation.base.options.RoutingTilesOptions
@@ -59,6 +60,7 @@ import java.net.URI
 import java.util.concurrent.TimeUnit
 import kotlin.math.absoluteValue
 
+@OptIn(ExperimentalPreviewMapboxNavigationAPI::class)
 class RouteRefreshTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.java) {
 
     @get:Rule
@@ -528,6 +530,73 @@ class RouteRefreshTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.ja
             assertEquals(187.126, refreshedRoutes[1].getSumOfDurationAnnotationsFromLeg(0), 0.0001)
         }
 
+    @Test
+    fun route_refresh_updates_annotations_for_new_alternative_with_more_legs() =
+        sdkTest {
+            setupMockRequestHandlers(
+                multilegCoordinates,
+                R.raw.route_response_single_route_multileg,
+                R.raw.route_response_single_route_multileg_refreshed,
+                "route_response_single_route_multileg",
+                acceptedGeometryIndex = 70
+            )
+            mockWebServerRule.requestHandlers.add(
+                FailByRequestMockRequestHandler(
+                    MockDirectionsRefreshHandler(
+                        "route_response_single_route_multileg_alternative",
+                        readRawFileText(
+                            activity,
+                            R.raw.route_response_single_route_multileg_alternative_refreshed
+                        ),
+                        acceptedGeometryIndex = 11
+                    )
+                )
+            )
+            val routeOptions = generateRouteOptions(multilegCoordinates)
+            val alternativeRoutes = mapboxNavigation.requestRoutes(routeOptions)
+                .getSuccessfulResultOrThrowException()
+                .routes
+            // alternative which was requested on the second leg of the original route,
+            // so the alternative has only one leg while the original route has two
+            val primaryRoute = alternativeForMultileg(activity).toNavigationRoutes().first()
+
+            // corresponds to currentRouteGeometryIndex = 70 for alternative route and 11 for the primary route
+            mockLocationUpdatesRule.pushLocationUpdate(
+                mockLocationUpdatesRule.generateLocationUpdate {
+                latitude = 38.581798
+                longitude = -121.476146
+                }
+            )
+
+            mapboxNavigation.setNavigationRoutes(listOf(primaryRoute) + alternativeRoutes, initialLegIndex = 0)
+            mapboxNavigation.startTripSession()
+
+            mapboxNavigation.routeProgressUpdates()
+                .filter {
+                    it.currentRouteGeometryIndex == 11
+                }
+                .first()
+
+            val refreshedRoutes = mapboxNavigation.routesUpdates()
+                .filter {
+                    it.reason == ROUTES_UPDATE_REASON_REFRESH
+                }
+                .first()
+                .navigationRoutes
+
+            assertEquals(
+                alternativeRoutes[0].getSumOfDurationAnnotationsFromLeg(0),
+                refreshedRoutes[1].getSumOfDurationAnnotationsFromLeg(0),
+                0.0001
+            )
+
+            assertEquals(201.673, alternativeRoutes[0].getSumOfDurationAnnotationsFromLeg(1), 0.0001)
+            assertEquals(202.881, refreshedRoutes[1].getSumOfDurationAnnotationsFromLeg(1), 0.0001)
+
+            assertEquals(194.3, primaryRoute.getSumOfDurationAnnotationsFromLeg(0), 0.0001)
+            assertEquals(187.126, refreshedRoutes[0].getSumOfDurationAnnotationsFromLeg(0), 0.0001)
+        }
+
     @Test
     fun expect_route_refresh_to_update_annotations_incidents_and_closures_for_truncated_next_leg() =
         sdkTest {

libnavigation-core/src/main/java/com/mapbox/navigation/core/routealternatives/AlternativeRouteProgressDataProvider.kt

@@ -1,10 +1,15 @@
 package com.mapbox.navigation.core.routealternatives
 
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.base.utils.DecodeUtils.stepsGeometryToPoints
 import com.mapbox.navigation.core.RouteProgressData
+import com.mapbox.navigation.utils.internal.ThreadController
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 
 internal object AlternativeRouteProgressDataProvider {
 
-    fun getRouteProgressData(
+    suspend fun getRouteProgressData(
         primaryRouteProgressData: RouteProgressData,
         alternativeMetadata: AlternativeRouteMetadata
     ): RouteProgressData {
@@ -22,16 +27,30 @@ internal object AlternativeRouteProgressDataProvider {
                 primaryFork.geometryIndexInRoute - alternativeFork.geometryIndexInRoute
             routeGeometryIndex =
                 primaryRouteProgressData.routeGeometryIndex - routeGeometryIndexDiff
-            val legGeometryIndexDiff =
-                primaryFork.geometryIndexInLeg - alternativeFork.geometryIndexInLeg
-            legGeometryIndex = primaryRouteProgressData.legGeometryIndex?.let {
-                it - legGeometryIndexDiff
-            }
+            legGeometryIndex = routeGeometryIndex -
+                prevLegsGeometryIndicesCount(alternativeMetadata.navigationRoute, legIndex)
         } else {
             legIndex = alternativeFork.legIndex
             routeGeometryIndex = alternativeFork.geometryIndexInRoute
             legGeometryIndex = alternativeFork.geometryIndexInLeg
         }
         return RouteProgressData(legIndex, routeGeometryIndex, legGeometryIndex)
     }
+
+    private suspend fun prevLegsGeometryIndicesCount(route: NavigationRoute, currentLegIndex: Int): Int {
+        return withContext(ThreadController.DefaultDispatcher) {
+            var result = 0
+            val stepsGeometries by lazy { route.directionsRoute.stepsGeometryToPoints() }
+            for (legIndex in 0 until currentLegIndex) {
+                val legGeometries = stepsGeometries.getOrNull(legIndex)
+                if (legGeometries != null) {
+                    // remove step duplicates (the last point in prev step is the same as the first point in the current step)
+                    result += legGeometries.sumOf { it.size } - legGeometries.size + 1
+                }
+            }
+            // remove leg duplicates (the last point of the last step of prev leg is the same as the first point of the first step in the current leg)
+            result -= currentLegIndex
+            result
+        }
+    }
 }

libnavigation-core/src/test/java/com/mapbox/navigation/core/RoutesProgressDataProviderTest.kt

@@ -73,13 +73,13 @@ class RoutesProgressDataProviderTest {
         every {
             alternativeMetadataProvider.getMetadataFor(alternativeRoute2)
         } returns alternativeMetadata2
-        every {
+        coEvery {
             AlternativeRouteProgressDataProvider.getRouteProgressData(
                 primaryRouteProgressData,
                 alternativeMetadata1
             )
         } returns alternativeRoute1ProgressData
-        every {
+        coEvery {
             AlternativeRouteProgressDataProvider.getRouteProgressData(
                 primaryRouteProgressData,
                 alternativeMetadata2
@@ -116,7 +116,7 @@ class RoutesProgressDataProviderTest {
         every {
             alternativeMetadataProvider.getMetadataFor(alternativeRoute2)
         } returns alternativeMetadata2
-        every {
+        coEvery {
             AlternativeRouteProgressDataProvider.getRouteProgressData(
                 primaryRouteProgressData,
                 alternativeMetadata2