when rerouting add layers and avoid maneuvers parameters only for driving profiles

libnavigation-core/src/main/java/com/mapbox/navigation/core/reroute/MapboxRerouteController.kt

@@ -1,6 +1,7 @@
 package com.mapbox.navigation.core.reroute
 
 import androidx.annotation.MainThread
+import com.mapbox.api.directions.v5.DirectionsCriteria
 import com.mapbox.api.directions.v5.models.DirectionsRoute
 import com.mapbox.api.directions.v5.models.RouteOptions
 import com.mapbox.base.common.logger.Logger
@@ -75,13 +76,21 @@ internal class MapboxRerouteController(
                 return this
             }
 
-            val avoidManeuverRadius = rerouteOptions.avoidManeuverSeconds
-                .takeIf { it != 0 }
-                ?.let { speed / it }?.toInt()
-                ?.takeIf { it >= 1 }
-                ?.coerceAtMost(MAX_DANGEROUS_MANEUVERS_RADIUS)
+            val builder = toBuilder()
 
-            return toBuilder().avoidManeuverRadius(avoidManeuverRadius).build()
+            if (this.profile() == DirectionsCriteria.PROFILE_DRIVING ||
+                this.profile() == DirectionsCriteria.PROFILE_DRIVING_TRAFFIC
+            ) {
+                val avoidManeuverRadius = rerouteOptions.avoidManeuverSeconds
+                    .takeIf { it != 0 }
+                    ?.let { speed / it }?.toInt()
+                    ?.takeIf { it >= 1 }
+                    ?.coerceAtMost(MAX_DANGEROUS_MANEUVERS_RADIUS)
+
+                builder.avoidManeuverRadius(avoidManeuverRadius)
+            }
+
+            return builder.build()
         }
     }
 

libnavigation-core/src/main/java/com/mapbox/navigation/core/routeoptions/RouteOptionsUpdater.kt

@@ -1,5 +1,6 @@
 package com.mapbox.navigation.core.routeoptions
 
+import com.mapbox.api.directions.v5.DirectionsCriteria
 import com.mapbox.api.directions.v5.models.Bearing
 import com.mapbox.api.directions.v5.models.RouteOptions
 import com.mapbox.base.common.logger.model.Message
@@ -134,16 +135,22 @@ class RouteOptionsUpdater {
                             coordinatesList.size - remainingWaypoints - 1
                         )
                     )
-                    .layersList(
-                        mutableListOf(locationMatcherResult.zLevel).apply {
-                            val legacyLayerList = routeOptions.layersList()
-                            if (legacyLayerList != null) {
-                                addAll(legacyLayerList.takeLast(remainingWaypoints))
-                            } else {
-                                repeat(remainingWaypoints) { add(null) }
-                            }
+            }
+
+            if (
+                routeOptions.profile() == DirectionsCriteria.PROFILE_DRIVING ||
+                routeOptions.profile() == DirectionsCriteria.PROFILE_DRIVING_TRAFFIC
+            ) {
+                optionsBuilder.layersList(
+                    mutableListOf(locationMatcherResult.zLevel).apply {
+                        val legacyLayerList = routeOptions.layersList()
+                        if (legacyLayerList != null) {
+                            addAll(legacyLayerList.takeLast(remainingWaypoints))
+                        } else {
+                            repeat(remainingWaypoints) { add(null) }
                         }
-                    )
+                    }
+                )
             }
 
             optionsBuilder.arriveBy(null)

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

@@ -1,5 +1,6 @@
 package com.mapbox.navigation.core.reroute
 
+import com.mapbox.api.directions.v5.DirectionsCriteria
 import com.mapbox.api.directions.v5.models.DirectionsRoute
 import com.mapbox.api.directions.v5.models.RouteOptions
 import com.mapbox.base.common.logger.Logger
@@ -342,7 +343,9 @@ class MapboxRerouteControllerTest {
             Triple(5000f, 1, 1000),
             Triple(200f, 0, null),
         ).forEach { (speed, secondsRadius, expectedMetersRadius) ->
-            val mockRo = mockk<RouteOptions>()
+            val mockRo = mockk<RouteOptions> {
+                every { profile() } returns DirectionsCriteria.PROFILE_DRIVING_TRAFFIC
+            }
             val mockRoBuilder = mockk<RouteOptions.Builder>()
             every { directionsSession.getPrimaryRouteOptions() } returns mockRo
             every { mockRo.toBuilder() } returns mockRoBuilder
@@ -371,6 +374,59 @@ class MapboxRerouteControllerTest {
         routeRequestCallback.captured.onRoutesReady(mockk(), mockk())
     }
 
+    @Test
+    fun reroute_options_avoid_maneuvers_only_driving() {
+        val routeRequestCallback = slot<RouterCallback>()
+        every {
+            directionsSession.requestRoutes(
+                routeOptionsFromSuccessResult,
+                capture(routeRequestCallback)
+            )
+        } returns 1L
+
+        listOf(
+            Pair(DirectionsCriteria.PROFILE_CYCLING, false),
+            Pair(DirectionsCriteria.PROFILE_DRIVING, true),
+            Pair(DirectionsCriteria.PROFILE_DRIVING_TRAFFIC, true),
+            Pair(DirectionsCriteria.PROFILE_WALKING, false),
+        ).forEach { (profile, result) ->
+            val mockRo = mockk<RouteOptions> {
+                every { profile() } returns profile
+            }
+            val mockRoBuilder = mockk<RouteOptions.Builder>()
+            every { directionsSession.getPrimaryRouteOptions() } returns mockRo
+            every { mockRo.toBuilder() } returns mockRoBuilder
+            every { mockRoBuilder.avoidManeuverRadius(any()) } returns mockRoBuilder
+            every { mockRoBuilder.build() } returns mockRo
+            mockRouteOptionsResult(successFromResult)
+            addRerouteStateObserver()
+            every { rerouteOptions.avoidManeuverSeconds } returns 1
+            every {
+                tripSession.locationMatcherResult
+            } returns mockk {
+                every {
+                    enhancedLocation
+                } returns mockk {
+                    every { speed } returns 200f
+                }
+            }
+
+            rerouteController.reroute(routeCallback)
+
+            verify(
+                exactly = if (result) {
+                    1
+                } else {
+                    0
+                }
+            ) {
+                mockRoBuilder.avoidManeuverRadius(any())
+            }
+        }
+
+        routeRequestCallback.captured.onRoutesReady(mockk(), mockk())
+    }
+
     @Test
     fun add_the_same_observer_twice_and_remove_twice() {
         assertTrue(addRerouteStateObserver())

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

@@ -196,6 +196,42 @@ class RouteOptionsUpdaterTest {
         MapboxRouteOptionsUpdateCommonTest.checkImmutableFields(routeOptions, newRouteOptions)
     }
 
+    @Test
+    fun `new options return without layer for profiles other than driving`() {
+        listOf(
+            Pair(DirectionsCriteria.PROFILE_CYCLING, false),
+            Pair(DirectionsCriteria.PROFILE_DRIVING, true),
+            Pair(DirectionsCriteria.PROFILE_DRIVING_TRAFFIC, true),
+            Pair(DirectionsCriteria.PROFILE_WALKING, false),
+        ).forEach { (profile, result) ->
+            val routeOptions = provideRouteOptionsWithCoordinates()
+                .toBuilder()
+                .profile(profile)
+                .build()
+            val routeProgress: RouteProgress = mockk(relaxed = true) {
+                every { remainingWaypoints } returns 2
+            }
+
+            val newRouteOptions =
+                routeRefreshAdapter.update(routeOptions, routeProgress, locationMatcherResult)
+                    .let {
+                        assertTrue(it is RouteOptionsUpdater.RouteOptionsResult.Success)
+                        return@let it as RouteOptionsUpdater.RouteOptionsResult.Success
+                    }
+                    .routeOptions
+
+            val expectedLayers = if (result) {
+                listOf(DEFAULT_Z_LEVEL, null, null)
+            } else {
+                null
+            }
+            val actualLayers = newRouteOptions.layersList()
+
+            assertEquals("for $profile", expectedLayers, actualLayers)
+            MapboxRouteOptionsUpdateCommonTest.checkImmutableFields(routeOptions, newRouteOptions)
+        }
+    }
+
     @Test
     fun `new options return with current layer and previous layers`() {
         val routeOptions = provideRouteOptionsWithCoordinatesAndLayers()