From 3c323da2b5ee45be63ece78d9dc32ba54d03ad59 Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 28 Jul 2022 16:17:37 +0200
Subject: [PATCH 01/12] prototyping

---
 .../examples/core/MapboxNavigationActivity.kt |  60 ++--
 .../res/layout/layout_activity_navigation.xml |  10 +
 .../core/PreviewRoutesTest.kt                 | 141 ++++++++++
 .../utils/coroutines/TestUtils.kt             |  14 +-
 .../navigation/core/MapboxNavigation.kt       |  34 +++
 .../directions/session/DirectionsSession.kt   |   2 +
 .../session/MapboxDirectionsSession.kt        |  16 +-
 .../core/directions/session/RoutesExtra.kt    |   4 +
 .../core/trip/session/NavigationSession.kt    |  87 +++++-
 .../NavigationSessionStateObserverV2.kt       |  15 +
 .../trip/session/NavigationSessionUtils.kt    |  19 ++
 .../session/MapboxDirectionsSessionTest.kt    |  66 +++++
 .../trip/session/NavigationSessionTest.kt     | 260 ++++++++++++++----
 13 files changed, 637 insertions(+), 91 deletions(-)
 create mode 100644 instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
 create mode 100644 libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionStateObserverV2.kt

diff --git a/examples/src/main/java/com/mapbox/navigation/examples/core/MapboxNavigationActivity.kt b/examples/src/main/java/com/mapbox/navigation/examples/core/MapboxNavigationActivity.kt
index 7f4b5aac9fc..2c3670bac45 100644
--- a/examples/src/main/java/com/mapbox/navigation/examples/core/MapboxNavigationActivity.kt
+++ b/examples/src/main/java/com/mapbox/navigation/examples/core/MapboxNavigationActivity.kt
@@ -10,6 +10,7 @@ import android.view.View.VISIBLE
 import android.widget.Toast
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.ContextCompat
+import androidx.lifecycle.lifecycleScope
 import com.mapbox.api.directions.v5.models.RouteOptions
 import com.mapbox.bindgen.Expected
 import com.mapbox.geojson.Point
@@ -52,6 +53,7 @@ import com.mapbox.navigation.ui.maps.location.NavigationLocationProvider
 import com.mapbox.navigation.ui.maps.route.arrow.api.MapboxRouteArrowApi
 import com.mapbox.navigation.ui.maps.route.arrow.api.MapboxRouteArrowView
 import com.mapbox.navigation.ui.maps.route.arrow.model.RouteArrowOptions
+import com.mapbox.navigation.ui.maps.route.line.MapboxRouteLineApiExtensions.setNavigationRoutes
 import com.mapbox.navigation.ui.maps.route.line.MapboxRouteLineApiExtensions.setRoutes
 import com.mapbox.navigation.ui.maps.route.line.api.MapboxRouteLineApi
 import com.mapbox.navigation.ui.maps.route.line.api.MapboxRouteLineView
@@ -89,6 +91,8 @@ class MapboxNavigationActivity : AppCompatActivity() {
     // location puck integration
     private val navigationLocationProvider = NavigationLocationProvider()
 
+    private val waypoints = mutableListOf<Point>()
+
     // camera
     private lateinit var navigationCamera: NavigationCamera
     private lateinit var viewportDataSource: MapboxNavigationViewportDataSource
@@ -229,15 +233,19 @@ class MapboxNavigationActivity : AppCompatActivity() {
         }
 
     private val routesObserver = RoutesObserver { result ->
-        if (result.routes.isNotEmpty()) {
+        if (result.navigationRoutes.isNotEmpty()) {
             // generate route geometries asynchronously and render them
-            CoroutineScope(Dispatchers.Main).launch {
-                val result = routeLineAPI.setRoutes(
-                    listOf(RouteLine(result.routes.first(), null))
-                )
-                val style = mapboxMap.getStyle()
-                if (style != null) {
-                    routeLineView.renderRouteDrawData(style, result)
+            lifecycleScope.launch {
+                routeLineAPI.setNavigationRoutes(
+                    newRoutes = result.navigationRoutes,
+                    alternativeRoutesMetadata = mapboxNavigation.getAlternativeMetadataFor(
+                        result.navigationRoutes
+                    )
+                ).apply {
+                    routeLineView.renderRouteDrawData(
+                        binding.mapView.getMapboxMap().getStyle()!!,
+                        this
+                    )
                 }
             }
 
@@ -399,7 +407,7 @@ class MapboxNavigationActivity : AppCompatActivity() {
             routeLineView.initializeLayers(style)
             // add long click listener that search for a route to the clicked destination
             binding.mapView.gestures.addOnMapLongClickListener { point ->
-                findRoute(point)
+                addWaypoint(point)
                 true
             }
         }
@@ -460,24 +468,26 @@ class MapboxNavigationActivity : AppCompatActivity() {
         voiceInstructionsPlayer.shutdown()
     }
 
-    private fun findRoute(destination: Point) {
+    private fun addWaypoint(destination: Point) {
         val origin = navigationLocationProvider.lastLocation?.let {
             Point.fromLngLat(it.longitude, it.latitude)
         } ?: return
 
+        waypoints.add(destination)
+
         mapboxNavigation.requestRoutes(
             RouteOptions.builder()
                 .applyDefaultNavigationOptions()
                 .applyLanguageAndVoiceUnitOptions(this)
-                .coordinatesList(listOf(origin, destination))
-                .layersList(listOf(mapboxNavigation.getZLevel(), null))
+                .alternatives(true)
+                .coordinatesList(listOf(origin) + waypoints)
                 .build(),
             object : NavigationRouterCallback {
                 override fun onRoutesReady(
                     routes: List<NavigationRoute>,
                     routerOrigin: RouterOrigin
                 ) {
-                    setRouteAndStartNavigation(routes)
+                    setRoutePreview(routes)
                 }
 
                 override fun onFailure(
@@ -494,9 +504,25 @@ class MapboxNavigationActivity : AppCompatActivity() {
         )
     }
 
-    private fun setRouteAndStartNavigation(route: List<NavigationRoute>) {
+
+
+    private fun setRoutePreview(route: List<NavigationRoute>) {
         // set route
-        mapboxNavigation.setNavigationRoutes(route)
+        mapboxNavigation.previewNavigationRoutes(route)
+        binding.navigate.visibility = VISIBLE
+        binding.navigate.setOnClickListener {
+            setRoute()
+            binding.navigate.visibility = INVISIBLE
+        }
+
+        // move the camera to overview when new route is available
+        navigationCamera.requestNavigationCameraToOverview()
+    }
+
+    private fun setRoute() {
+        // set route
+        mapboxNavigation.setNavigationRoutes(mapboxNavigation.getPreviewedNavigationRoutes())
+        waypoints.clear()
 
         // show UI elements
         binding.soundButton.visibility = VISIBLE
@@ -506,12 +532,12 @@ class MapboxNavigationActivity : AppCompatActivity() {
         binding.soundButton.unmuteAndExtend(2000L)
 
         // move the camera to overview when new route is available
-        navigationCamera.requestNavigationCameraToOverview()
+        navigationCamera.requestNavigationCameraToFollowing()
     }
 
     private fun clearRouteAndStopNavigation() {
         // clear
-        mapboxNavigation.setRoutes(listOf())
+        mapboxNavigation.clearRoutes()
 
         // hide UI elements
         binding.soundButton.visibility = INVISIBLE
diff --git a/examples/src/main/res/layout/layout_activity_navigation.xml b/examples/src/main/res/layout/layout_activity_navigation.xml
index 1a6f38c5d9e..607cf58a5c4 100644
--- a/examples/src/main/res/layout/layout_activity_navigation.xml
+++ b/examples/src/main/res/layout/layout_activity_navigation.xml
@@ -13,6 +13,16 @@
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toTopOf="parent" />
 
+    <Button
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:id="@+id/navigate"
+        android:visibility="invisible"
+        android:text="Navigate"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"/>
+
     <androidx.cardview.widget.CardView
         android:id="@+id/tripProgressCard"
         android:layout_width="0dp"
diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
new file mode 100644
index 00000000000..4b58647971f
--- /dev/null
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -0,0 +1,141 @@
+package com.mapbox.navigation.instrumentation_tests.core
+
+import android.location.Location
+import com.mapbox.navigation.base.options.NavigationOptions
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.core.MapboxNavigation
+import com.mapbox.navigation.core.MapboxNavigationProvider
+import com.mapbox.navigation.core.directions.session.RoutesExtra
+import com.mapbox.navigation.core.trip.session.NavigationSessionState
+import com.mapbox.navigation.core.trip.session.NavigationSessionStateV2
+import com.mapbox.navigation.instrumentation_tests.activity.EmptyTestActivity
+import com.mapbox.navigation.instrumentation_tests.utils.MapboxNavigationRule
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.sdkTest
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.waitForNewRoute
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.waitForPreviewRoute
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.waitForRoutesCleanUp
+import com.mapbox.navigation.instrumentation_tests.utils.routes.RoutesProvider
+import com.mapbox.navigation.instrumentation_tests.utils.routes.RoutesProvider.toNavigationRoutes
+import com.mapbox.navigation.testing.ui.BaseTest
+import com.mapbox.navigation.testing.ui.utils.getMapboxAccessTokenFromResources
+import com.mapbox.navigation.testing.ui.utils.runOnMainSync
+import kotlinx.coroutines.async
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import java.util.Objects
+import kotlin.reflect.typeOf
+
+class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.java) {
+
+    override fun setupMockLocation(): Location = mockLocationUpdatesRule.generateLocationUpdate {
+        latitude = 38.894721
+        longitude = -77.031991
+    }
+
+    @get:Rule
+    val mapboxNavigationRule = MapboxNavigationRule()
+    private lateinit var mapboxNavigation: MapboxNavigation
+
+    @Before
+    fun setUp() {
+        runOnMainSync {
+            mapboxNavigation = MapboxNavigationProvider.create(
+                NavigationOptions.Builder(activity)
+                    .accessToken(getMapboxAccessTokenFromResources(activity))
+                    .build()
+            )
+        }
+    }
+
+    @Test
+    fun preview_route() = sdkTest {
+        val routes = RoutesProvider.dc_very_short(activity).toNavigationRoutes()
+        mapboxNavigation.startTripSession()
+        val previewedRouteDeffer = async {
+            mapboxNavigation.waitForPreviewRoute()
+        }
+
+        mapboxNavigation.previewNavigationRoutes(routes)
+
+        val previewRouteUpdate = previewedRouteDeffer.await()
+        assertEquals(routes, previewRouteUpdate.navigationRoutes)
+        assertEquals(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW, previewRouteUpdate.reason)
+        assertEquals(routes, mapboxNavigation.getPreviewedNavigationRoutes())
+        assertEquals(emptyList<NavigationRoute>(), mapboxNavigation.getNavigationRoutes())
+        assertIs<NavigationSessionState.FreeDrive>(mapboxNavigation.getNavigationSessionState())
+        assertIs<NavigationSessionStateV2.RoutePreview>(mapboxNavigation.getNavigationSessionStateV2())
+    }
+
+    @Test
+    fun preview_route_with_alternative() = sdkTest {
+        val routes = RoutesProvider.dc_short_with_alternative(activity).toNavigationRoutes()
+        mapboxNavigation.startTripSession()
+        val previewedRouteDeffer = async {
+            mapboxNavigation.waitForPreviewRoute()
+        }
+
+        mapboxNavigation.previewNavigationRoutes(routes)
+
+        val previewRouteUpdate = previewedRouteDeffer.await()
+        val previewedRouteMetadata = mapboxNavigation.getAlternativeMetadataFor(
+            previewRouteUpdate.navigationRoutes[1]
+        )
+        assertNotNull(previewedRouteMetadata)
+    }
+
+    @Test
+    fun start_active_guidance_after_preview() = sdkTest {
+        val routes = RoutesProvider.dc_short_with_alternative(activity).toNavigationRoutes()
+        mapboxNavigation.startTripSession()
+        val previewedRouteDeferred = async {
+            mapboxNavigation.waitForPreviewRoute()
+        }
+        mapboxNavigation.previewNavigationRoutes(routes)
+        previewedRouteDeferred.await()
+        val activeGuidanceRouteUpdateDefer = async {
+            mapboxNavigation.waitForNewRoute()
+        }
+
+        mapboxNavigation.setNavigationRoutes(mapboxNavigation.getPreviewedNavigationRoutes())
+
+        val activeGuidanceRouteUpdate = activeGuidanceRouteUpdateDefer.await()
+        assertEquals(RoutesExtra.ROUTES_UPDATE_REASON_NEW, activeGuidanceRouteUpdate.reason)
+        assertEquals(routes, activeGuidanceRouteUpdate.navigationRoutes)
+
+        assertIs<NavigationSessionState.ActiveGuidance>(mapboxNavigation.getNavigationSessionState())
+        assertIs<NavigationSessionStateV2.ActiveGuidance>(mapboxNavigation.getNavigationSessionStateV2())
+    }
+
+    @Test
+    fun switch_to_free_drive_after_preview() = sdkTest {
+        val routes = RoutesProvider.dc_very_short(activity).toNavigationRoutes()
+        mapboxNavigation.startTripSession()
+        val previewedRouteDeffer = async {
+            mapboxNavigation.waitForPreviewRoute()
+        }
+        mapboxNavigation.previewNavigationRoutes(routes)
+        previewedRouteDeffer.await()
+        val freeDriveRoutesUpdateDeferred = async {
+            mapboxNavigation.waitForRoutesCleanUp()
+        }
+
+        mapboxNavigation.clearRoutes()
+
+        val freeDriveRoutesUpdate = freeDriveRoutesUpdateDeferred.await()
+        assertEquals(emptyList<NavigationRoute>(), freeDriveRoutesUpdate.navigationRoutes)
+        assertEquals(emptyList<NavigationRoute>(), mapboxNavigation.getNavigationRoutes())
+        assertIs<NavigationSessionState.FreeDrive>(mapboxNavigation.getNavigationSessionState())
+        assertIs<NavigationSessionStateV2.FreeDrive>(mapboxNavigation.getNavigationSessionStateV2())
+    }
+}
+
+private inline fun <reified T> assertIs(obj: Any) {
+    assertTrue(
+        "expected an instance of ${T::class.java.name}, but it is $obj (${obj.javaClass.name})",
+        obj is T
+    )
+}
diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/utils/coroutines/TestUtils.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/utils/coroutines/TestUtils.kt
index 27a732478e8..acf13d3c87b 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/utils/coroutines/TestUtils.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/utils/coroutines/TestUtils.kt
@@ -100,18 +100,24 @@ suspend fun MapboxNavigation.setNavigationRoutesAndWaitForAlternativesUpdate(
         waitForAlternativeRoute()
     }
 
-suspend fun MapboxNavigation.waitForNewRoute() {
+suspend fun MapboxNavigation.waitForNewRoute(): RoutesUpdatedResult =
     waitForRoutesUpdate(RoutesExtra.ROUTES_UPDATE_REASON_NEW)
-}
+
+suspend fun MapboxNavigation.waitForRoutesCleanUp(): RoutesUpdatedResult =
+    waitForRoutesUpdate(RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP)
 
 suspend fun MapboxNavigation.waitForAlternativeRoute() {
     waitForRoutesUpdate(RoutesExtra.ROUTES_UPDATE_REASON_ALTERNATIVE)
 }
 
+suspend fun MapboxNavigation.waitForPreviewRoute(): RoutesUpdatedResult {
+    return waitForRoutesUpdate(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW)
+}
+
 private suspend fun MapboxNavigation.waitForRoutesUpdate(
     @RoutesExtra.RoutesUpdateReason reason: String
-) {
-    routesUpdates()
+): RoutesUpdatedResult {
+    return routesUpdates()
         .filter { it.reason == reason }
         .first()
 }
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
index 8155867b301..ce18253a449 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
@@ -22,6 +22,7 @@ import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
 import com.mapbox.navigation.base.extensions.applyDefaultNavigationOptions
 import com.mapbox.navigation.base.extensions.applyLanguageAndVoiceUnitOptions
 import com.mapbox.navigation.base.internal.NavigationRouterV2
+import com.mapbox.navigation.base.internal.route.nativeRoute
 import com.mapbox.navigation.base.internal.trip.notification.TripNotificationInterceptorOwner
 import com.mapbox.navigation.base.options.HistoryRecorderOptions
 import com.mapbox.navigation.base.options.NavigationOptions
@@ -101,6 +102,7 @@ import com.mapbox.navigation.core.trip.session.NavigationSessionState.ActiveGuid
 import com.mapbox.navigation.core.trip.session.NavigationSessionState.FreeDrive
 import com.mapbox.navigation.core.trip.session.NavigationSessionState.Idle
 import com.mapbox.navigation.core.trip.session.NavigationSessionStateObserver
+import com.mapbox.navigation.core.trip.session.NavigationSessionStateV2
 import com.mapbox.navigation.core.trip.session.OffRouteObserver
 import com.mapbox.navigation.core.trip.session.RoadObjectsOnRouteObserver
 import com.mapbox.navigation.core.trip.session.RouteProgressObserver
@@ -130,6 +132,7 @@ import com.mapbox.navigator.FallbackVersionsObserver
 import com.mapbox.navigator.IncidentsOptions
 import com.mapbox.navigator.NavigatorConfig
 import com.mapbox.navigator.PollingConfig
+import com.mapbox.navigator.RouteParser
 import com.mapbox.navigator.RouterInterface
 import com.mapbox.navigator.TileEndpointConfiguration
 import com.mapbox.navigator.TilesConfig
@@ -654,6 +657,7 @@ class MapboxNavigation @VisibleForTesting internal constructor(
      * @see [registerNavigationSessionStateObserver]
      */
     fun getNavigationSessionState(): NavigationSessionState = navigationSession.state
+    fun getNavigationSessionStateV2(): NavigationSessionStateV2 = navigationSession.stateV2
 
     /**
      * Provides the current Z-Level. Can be used to build a route from a proper level of a road.
@@ -828,6 +832,9 @@ class MapboxNavigation @VisibleForTesting internal constructor(
                 RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP,
                 initialLegIndex
             )
+            directionsSession.routes == routes -> {
+                BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_NEW, initialLegIndex)
+            }
             routes.first() == directionsSession.routes.firstOrNull() ->
                 SetAlternativeRoutesInfo(initialLegIndex)
             else -> BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_NEW, initialLegIndex)
@@ -839,6 +846,31 @@ class MapboxNavigation @VisibleForTesting internal constructor(
         )
     }
 
+    fun previewNavigationRoutes(
+        routes: List<NavigationRoute>,
+        initialLegIndex: Int = 0,
+    ) {
+        threadController.getMainScopeAndRootJob().scope.launch(Dispatchers.Main.immediate) {
+            routeUpdateMutex.withLock {
+                val alternatives = routes.drop(1)
+                val routesData = RouteParser.createRoutesData(
+                    routes.first().nativeRoute(),
+                    alternatives.map { it.nativeRoute() }
+                )
+                routeAlternativesController.processAlternativesMetadata(
+                    routes,
+                    routesData.alternativeRoutes()
+                )
+                directionsSession.setRoutes(routes, BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW, initialLegIndex))
+            }
+        }
+    }
+
+
+    fun clearRoutes() {
+        setNavigationRoutes(emptyList())
+    }
+
     /**
      * Requests road graph data update and invokes the callback on result.
      * Use this method if the frequency of application relaunch is too low
@@ -969,6 +1001,8 @@ class MapboxNavigation @VisibleForTesting internal constructor(
      */
     fun getNavigationRoutes(): List<NavigationRoute> = directionsSession.routes
 
+    fun getPreviewedNavigationRoutes(): List<NavigationRoute> = directionsSession.previewedRoutes
+
     /**
      * Requests an alternative route using the original [RouteOptions] associated with
      * [MapboxNavigation.setRoutes()] call and [Router] implementation.
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/DirectionsSession.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/DirectionsSession.kt
index abf74d2fbf2..f8bffa3087b 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/DirectionsSession.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/DirectionsSession.kt
@@ -16,6 +16,8 @@ internal interface DirectionsSession : RouteRefresh {
      */
     val routes: List<NavigationRoute>
 
+    val previewedRoutes: List<NavigationRoute>
+
     val initialLegIndex: Int
 
     fun setRoutes(
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSession.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSession.kt
index e1345486711..0f387bcb40f 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSession.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSession.kt
@@ -37,6 +37,8 @@ internal class MapboxDirectionsSession(
             routesInitialized = true
         }
 
+    override var previewedRoutes: List<NavigationRoute> = emptyList()
+
     private var routesInitialized = false
 
     @RoutesExtra.RoutesUpdateReason
@@ -50,11 +52,21 @@ internal class MapboxDirectionsSession(
         setRoutesInfo: SetRoutesInfo,
     ) {
         this.initialLegIndex = setRoutesInfo.legIndex
-        if (routesInitialized && this.routes.isEmpty() && routes.isEmpty()) {
+        if (
+            routesInitialized
+            && this.routes.isEmpty() && this.previewedRoutes.isEmpty()
+            && routes.isEmpty()
+        ) {
             return
         }
         RouteCompatibilityCache.setDirectionsSessionResult(routes)
-        this.routes = routes
+        if (setRoutesInfo.reason == RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW) {
+            this.previewedRoutes = routes
+            this.routes = emptyList()
+        } else {
+            this.routes = routes
+            this.previewedRoutes = emptyList()
+        }
         this.routesUpdateReason = setRoutesInfo.reason
         routesObservers.forEach {
             it.onRoutesChanged(
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/RoutesExtra.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/RoutesExtra.kt
index 7cc05779ead..7f3cd8a7e9d 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/RoutesExtra.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/RoutesExtra.kt
@@ -19,6 +19,9 @@ object RoutesExtra {
      */
     const val ROUTES_UPDATE_REASON_NEW = "ROUTES_UPDATE_REASON_NEW"
 
+
+    const val ROUTES_UPDATE_REASON_PREVIEW = "ROUTES_UPDATE_REASON_PREVIEW"
+
     /**
      * Routes update reason is **alternative routes**.
      * @see [RoutesObserver]
@@ -48,6 +51,7 @@ object RoutesExtra {
         ROUTES_UPDATE_REASON_ALTERNATIVE,
         ROUTES_UPDATE_REASON_REROUTE,
         ROUTES_UPDATE_REASON_REFRESH,
+        ROUTES_UPDATE_REASON_PREVIEW,
     )
     annotation class RoutesUpdateReason
 }
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSession.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSession.kt
index 96f2fe91aea..be27c90c0b0 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSession.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSession.kt
@@ -1,6 +1,7 @@
 package com.mapbox.navigation.core.trip.session
 
 import com.mapbox.navigation.core.MapboxNavigation
+import com.mapbox.navigation.core.directions.session.RoutesExtra
 import com.mapbox.navigation.core.directions.session.RoutesObserver
 import com.mapbox.navigation.core.directions.session.RoutesUpdatedResult
 import com.mapbox.navigation.core.history.MapboxHistoryRecorder
@@ -12,6 +13,7 @@ import java.util.concurrent.CopyOnWriteArraySet
 internal class NavigationSession : RoutesObserver, TripSessionStateObserver {
 
     private val stateObservers = CopyOnWriteArraySet<NavigationSessionStateObserver>()
+    private val stateObserversV2 = CopyOnWriteArraySet<NavigationSessionStateObserverV2>()
 
     internal var state: NavigationSessionState = Idle
         set(value) {
@@ -23,14 +25,18 @@ internal class NavigationSession : RoutesObserver, TripSessionStateObserver {
             stateObservers.forEach { it.onNavigationSessionStateChanged(value) }
         }
 
-    private var hasRoutes = false
+    internal var stateV2: NavigationSessionStateV2 = NavigationSessionStateV2.Idle
         set(value) {
-            if (field != value) {
-                field = value
-                updateState()
+            if (field == value) {
+                return
             }
+            field = value
+
+            stateObserversV2.forEach { it.onNavigationSessionStateChanged(value) }
         }
 
+    private var hasRoutes = false
+
     private var isDriving = false
         set(value) {
             if (field != value) {
@@ -39,11 +45,16 @@ internal class NavigationSession : RoutesObserver, TripSessionStateObserver {
             }
         }
 
+    private var isPreview = false
+
     private fun updateState() {
-        state = NavigationSessionUtils.getNewNavigationSessionState(
-            isDriving = isDriving,
-            hasRoutes = hasRoutes
-        )
+        stateV2 = NavigationSessionUtils.getNewStateV2(isDriving, hasRoutes, isPreview)
+        state = when (stateV2) {
+            is NavigationSessionStateV2.ActiveGuidance -> ActiveGuidance(stateV2.sessionId)
+            is NavigationSessionStateV2.FreeDrive -> FreeDrive(stateV2.sessionId)
+            NavigationSessionStateV2.Idle -> Idle
+            is NavigationSessionStateV2.RoutePreview -> FreeDrive(stateV2.sessionId)
+        }
     }
 
     internal fun registerNavigationSessionStateObserver(
@@ -59,12 +70,31 @@ internal class NavigationSession : RoutesObserver, TripSessionStateObserver {
         stateObservers.remove(navigationSessionStateObserver)
     }
 
+    internal fun registerNavigationSessionStateObserverV2(
+        navigationSessionStateObserver: NavigationSessionStateObserverV2
+    ) {
+        stateObserversV2.add(navigationSessionStateObserver)
+        navigationSessionStateObserver.onNavigationSessionStateChanged(stateV2)
+    }
+
+    internal fun unregisterNavigationSessionStateObserverV2(
+        navigationSessionStateObserver: NavigationSessionStateObserverV2
+    ) {
+        stateObserversV2.remove(navigationSessionStateObserver)
+    }
+
     internal fun unregisterAllNavigationSessionStateObservers() {
         stateObservers.clear()
     }
 
     override fun onRoutesChanged(result: RoutesUpdatedResult) {
-        hasRoutes = result.navigationRoutes.isNotEmpty()
+        val newIsPreview = result.reason == RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW
+        val newNasRoutes = result.navigationRoutes.isNotEmpty()
+        if (newIsPreview != isPreview || newNasRoutes != hasRoutes) {
+            isPreview = newIsPreview
+            hasRoutes = newNasRoutes
+            updateState()
+        }
     }
 
     override fun onSessionStateChanged(tripSessionState: TripSessionState) {
@@ -123,3 +153,42 @@ sealed class NavigationSessionState {
         override val sessionId: String
     ) : NavigationSessionState()
 }
+
+sealed class NavigationSessionStateV2 {
+
+    /**
+     * Random session UUID.
+     * This is generated internally based on the current state within a trip session.
+     * I.e. will change when transitioning across states of a trip session. Empty when [Idle].
+     *
+     * Useful to use it in combination with the [MapboxHistoryRecorder].
+     *
+     * @see [TripSessionState]
+     */
+    abstract val sessionId: String
+
+    /**
+     * Idle state
+     */
+    object Idle : NavigationSessionStateV2() {
+        override val sessionId = ""
+    }
+
+    /**
+     * Free Drive state
+     */
+    data class FreeDrive internal constructor(
+        override val sessionId: String
+    ) : NavigationSessionStateV2()
+
+    /**
+     * Active Guidance state
+     */
+    data class ActiveGuidance internal constructor(
+        override val sessionId: String
+    ) : NavigationSessionStateV2()
+
+    data class RoutePreview internal constructor(
+        override val sessionId: String
+    ) : NavigationSessionStateV2()
+}
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionStateObserverV2.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionStateObserverV2.kt
new file mode 100644
index 00000000000..3a1a562c5aa
--- /dev/null
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionStateObserverV2.kt
@@ -0,0 +1,15 @@
+package com.mapbox.navigation.core.trip.session
+
+/**
+ * Callback that provides the various session states that can happen within a navigation session
+ *
+ * @see NavigationSessionState
+ */
+fun interface NavigationSessionStateObserverV2 {
+    /**
+     * Called whenever the navigation session state has changed
+     *
+     * @param navigationSession [NavigationSessionStateV2]
+     */
+    fun onNavigationSessionStateChanged(navigationSession: NavigationSessionStateV2)
+}
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionUtils.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionUtils.kt
index ab63a9f6618..1a5cc61015f 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionUtils.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionUtils.kt
@@ -49,4 +49,23 @@ internal object NavigationSessionUtils {
             idleProvider()
         }
     }
+
+    fun getNewStateV2(
+        isDriving: Boolean,
+        hasRoutes: Boolean,
+        routePreview: Boolean
+    ): NavigationSessionStateV2 = when {
+        hasRoutes && routePreview -> {
+            NavigationSessionStateV2.RoutePreview(navObtainUniversalSessionId())
+        }
+        hasRoutes && isDriving -> {
+            NavigationSessionStateV2.ActiveGuidance(navObtainUniversalSessionId())
+        }
+        isDriving -> {
+            NavigationSessionStateV2.FreeDrive(navObtainUniversalSessionId())
+        }
+        else -> {
+            NavigationSessionStateV2.Idle
+        }
+    }
 }
diff --git a/libnavigation-core/src/test/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSessionTest.kt b/libnavigation-core/src/test/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSessionTest.kt
index 4988690a9bd..24e5b8f0ce6 100644
--- a/libnavigation-core/src/test/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSessionTest.kt
+++ b/libnavigation-core/src/test/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSessionTest.kt
@@ -13,6 +13,8 @@ import com.mapbox.navigation.base.route.RouterFailure
 import com.mapbox.navigation.base.route.RouterOrigin
 import com.mapbox.navigation.core.BasicSetRoutesInfo
 import com.mapbox.navigation.core.NavigationComponentProvider
+import com.mapbox.navigation.testing.factories.createDirectionsResponse
+import com.mapbox.navigation.testing.factories.createNavigationRoutes
 import io.mockk.clearMocks
 import io.mockk.every
 import io.mockk.just
@@ -386,4 +388,68 @@ class MapboxDirectionsSessionTest {
 
         verify(exactly = 0) { observer.onRoutesChanged(any()) }
     }
+
+    @Test
+    fun `set previewed route`() {
+        session.registerRoutesObserver(observer)
+        val testRoutes = createNavigationRoutes()
+
+        session.setRoutes(
+            testRoutes,
+            BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW, 0)
+        )
+
+        assertEquals(testRoutes, session.previewedRoutes)
+        verify {
+            observer.onRoutesChanged(
+                match {
+                    it.navigationRoutes == testRoutes
+                        && it.reason == RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW
+                }
+            )
+        }
+        assertEquals(emptyList<NavigationRoute>(), session.routes)
+    }
+
+    @Test
+    fun `clean set previewed route`() {
+        session.setRoutes(
+            createNavigationRoutes(),
+            BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW, 0)
+        )
+        session.registerRoutesObserver(observer)
+
+        session.setRoutes(
+            emptyList(),
+            BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP, 0)
+        )
+
+        assertEquals(emptyList<NavigationRoute>(), session.previewedRoutes)
+        assertEquals(emptyList<NavigationRoute>(), session.routes)
+        verify {
+            observer.onRoutesChanged(
+                match {
+                    it.navigationRoutes.isEmpty()
+                        && it.reason == RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP
+                }
+            )
+        }
+    }
+
+    @Test
+    fun `set route preview after active navigation`() {
+        session.setRoutes(
+            createNavigationRoutes(createDirectionsResponse(uuid = "test1")),
+            BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_NEW, 0)
+        )
+
+        val testPreviewRoutes = createNavigationRoutes(createDirectionsResponse(uuid = "test2"))
+        session.setRoutes(
+            testPreviewRoutes,
+            BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW, 0)
+        )
+
+        assertEquals(testPreviewRoutes, session.previewedRoutes)
+        assertEquals(emptyList<NavigationRoute>(), session.routes)
+    }
 }
diff --git a/libnavigation-core/src/test/java/com/mapbox/navigation/core/trip/session/NavigationSessionTest.kt b/libnavigation-core/src/test/java/com/mapbox/navigation/core/trip/session/NavigationSessionTest.kt
index 88613c331c2..5bb8e1bf7e8 100644
--- a/libnavigation-core/src/test/java/com/mapbox/navigation/core/trip/session/NavigationSessionTest.kt
+++ b/libnavigation-core/src/test/java/com/mapbox/navigation/core/trip/session/NavigationSessionTest.kt
@@ -3,9 +3,8 @@ package com.mapbox.navigation.core.trip.session
 import com.mapbox.navigation.base.route.NavigationRoute
 import com.mapbox.navigation.core.directions.session.RoutesExtra
 import com.mapbox.navigation.core.directions.session.RoutesUpdatedResult
-import com.mapbox.navigation.core.trip.session.NavigationSessionState.ActiveGuidance
-import com.mapbox.navigation.core.trip.session.NavigationSessionState.FreeDrive
-import com.mapbox.navigation.core.trip.session.NavigationSessionState.Idle
+import com.mapbox.navigation.core.trip.session.NavigationSessionState
+import com.mapbox.navigation.testing.factories.createNavigationRoutes
 import io.mockk.clearMocks
 import io.mockk.every
 import io.mockk.just
@@ -13,6 +12,7 @@ import io.mockk.mockk
 import io.mockk.runs
 import io.mockk.slot
 import io.mockk.verify
+import io.mockk.verifySequence
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Before
@@ -26,120 +26,204 @@ class NavigationSessionTest {
     }
     private val stateObserver: NavigationSessionStateObserver = mockk()
     private val navigationSessionStateSlot = slot<NavigationSessionState>()
+    private val stateObserverV2: NavigationSessionStateObserverV2 = mockk()
+    private val navigationSessionV2StateSlot = slot<NavigationSessionStateV2>()
 
     @Before
     fun setup() {
         every {
             stateObserver.onNavigationSessionStateChanged(capture(navigationSessionStateSlot))
         } just runs
+        every {
+            stateObserverV2.onNavigationSessionStateChanged(capture(navigationSessionV2StateSlot))
+        } just runs
     }
 
     @Test
     fun stateObserverImmediateIdle() {
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
 
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
 
         verify(exactly = 1) {
             stateObserver.onNavigationSessionStateChanged(
-                Idle
+                NavigationSessionState.Idle
             )
         }
+        verify(exactly = 1) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                NavigationSessionStateV2.Idle
+            )
+        }
+        assertEquals(
+            navigationSessionStateSlot.captured.sessionId,
+            navigationSessionV2StateSlot.captured.sessionId
+        )
     }
 
     @Test
     fun stateObserverImmediateActiveGuidance() {
-        val routes = mutableListOf<NavigationRoute>()
-        val navigationSession = NavigationSession()
-        routes.add(route)
+        val navigationSession = createNavigationSession()
         navigationSession.onRoutesChanged(
-            RoutesUpdatedResult(routes, RoutesExtra.ROUTES_UPDATE_REASON_NEW)
+            RoutesUpdatedResult(createNavigationRoutes(), RoutesExtra.ROUTES_UPDATE_REASON_NEW)
         )
         navigationSession.onSessionStateChanged(TripSessionState.STARTED)
 
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
 
         verify(exactly = 1) {
             stateObserver.onNavigationSessionStateChanged(
-                ActiveGuidance(navigationSessionStateSlot.captured.sessionId)
+                ofType<NavigationSessionState.ActiveGuidance>()
+            )
+        }
+        verify(exactly = 1) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                ofType<NavigationSessionStateV2.ActiveGuidance>()
             )
         }
+        assertEquals(
+            navigationSessionStateSlot.captured.sessionId,
+            navigationSessionV2StateSlot.captured.sessionId
+        )
     }
 
     @Test
     fun stateObserverImmediateActiveFreeDrive() {
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.onSessionStateChanged(TripSessionState.STARTED)
 
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
 
         verify(exactly = 1) {
             stateObserver.onNavigationSessionStateChanged(
-                FreeDrive(navigationSessionStateSlot.captured.sessionId)
+                ofType<NavigationSessionState.FreeDrive>()
             )
         }
+        verify(exactly = 1) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                ofType<NavigationSessionStateV2.FreeDrive>()
+            )
+        }
+        assertEquals(
+            navigationSessionStateSlot.captured.sessionId,
+            navigationSessionV2StateSlot.captured.sessionId
+        )
     }
 
     @Test
     fun stateObserverIdle() {
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
 
         navigationSession.onSessionStateChanged(TripSessionState.STARTED)
         navigationSession.onSessionStateChanged(TripSessionState.STOPPED)
 
         verify(exactly = 2) {
             stateObserver.onNavigationSessionStateChanged(
-                Idle
+                NavigationSessionState.Idle
+            )
+        }
+        verify(exactly = 2) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                NavigationSessionStateV2.Idle
             )
         }
+        assertEquals(
+            navigationSessionStateSlot.captured.sessionId,
+            navigationSessionV2StateSlot.captured.sessionId
+        )
     }
 
     @Test
     fun stateObserverActiveGuidance() {
-        val routes = mutableListOf<NavigationRoute>()
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
 
-        routes.add(route)
         navigationSession.onRoutesChanged(
-            RoutesUpdatedResult(routes, RoutesExtra.ROUTES_UPDATE_REASON_NEW)
+            RoutesUpdatedResult(createNavigationRoutes(), RoutesExtra.ROUTES_UPDATE_REASON_NEW)
         )
         navigationSession.onSessionStateChanged(TripSessionState.STARTED)
 
         verify(exactly = 1) {
             stateObserver.onNavigationSessionStateChanged(
-                ActiveGuidance(navigationSessionStateSlot.captured.sessionId)
+                ofType<NavigationSessionState.ActiveGuidance>()
+            )
+        }
+        verify(exactly = 1) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                ofType<NavigationSessionStateV2.ActiveGuidance>()
             )
         }
+        assertEquals(
+            navigationSessionStateSlot.captured.sessionId,
+            navigationSessionV2StateSlot.captured.sessionId
+        )
     }
 
     @Test
     fun stateObserverFreeDrive() {
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
 
         navigationSession.onSessionStateChanged(TripSessionState.STARTED)
 
         verify(exactly = 1) {
             stateObserver.onNavigationSessionStateChanged(
-                FreeDrive(navigationSessionStateSlot.captured.sessionId)
+                ofType<NavigationSessionState.FreeDrive>()
             )
         }
+        verify(exactly = 1) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                ofType<NavigationSessionStateV2.FreeDrive>()
+            )
+        }
+        assertEquals(
+            navigationSessionStateSlot.captured.sessionId,
+            navigationSessionV2StateSlot.captured.sessionId
+        )
     }
 
     @Test
     fun stateObserverUnregisterIdle() {
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
+        navigationSession.onSessionStateChanged(TripSessionState.STARTED)
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
-        clearMocks(stateObserver)
-        navigationSession.unregisterNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
 
+        navigationSession.unregisterNavigationSessionStateObserver(stateObserver)
+        navigationSession.unregisterNavigationSessionStateObserverV2(stateObserverV2)
         navigationSession.onSessionStateChanged(TripSessionState.STOPPED)
 
         verify(exactly = 0) {
             stateObserver.onNavigationSessionStateChanged(
-                Idle
+                NavigationSessionState.Idle
+            )
+        }
+        verify(exactly = 0) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                NavigationSessionStateV2.Idle
+            )
+        }
+    }
+
+    @Test
+    fun stateObserverV2UnregisterIdle() {
+        val navigationSession = createNavigationSession()
+        navigationSession.onSessionStateChanged(TripSessionState.STARTED)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
+
+        navigationSession.unregisterNavigationSessionStateObserverV2(stateObserverV2)
+        navigationSession.onSessionStateChanged(TripSessionState.STOPPED)
+
+        verify(exactly = 0) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                NavigationSessionStateV2.Idle
             )
         }
     }
@@ -147,7 +231,7 @@ class NavigationSessionTest {
     @Test
     fun stateObserverUnregisterActiveGuidance() {
         val routes = mutableListOf<NavigationRoute>()
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
         clearMocks(stateObserver)
         navigationSession.unregisterNavigationSessionStateObserver(stateObserver)
@@ -160,14 +244,16 @@ class NavigationSessionTest {
 
         verify(exactly = 0) {
             stateObserver.onNavigationSessionStateChanged(
-                ActiveGuidance(navigationSessionStateSlot.captured.sessionId)
+                NavigationSessionState.ActiveGuidance(
+                    navigationSessionStateSlot.captured.sessionId
+                )
             )
         }
     }
 
     @Test
     fun stateObserverUnregisterFreeDrive() {
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
         clearMocks(stateObserver)
         navigationSession.unregisterNavigationSessionStateObserver(stateObserver)
@@ -176,14 +262,16 @@ class NavigationSessionTest {
 
         verify(exactly = 0) {
             stateObserver.onNavigationSessionStateChanged(
-                FreeDrive(navigationSessionStateSlot.captured.sessionId)
+                NavigationSessionState.FreeDrive(
+                    navigationSessionStateSlot.captured.sessionId
+                )
             )
         }
     }
 
     @Test
     fun unregisterAllStateObservers() {
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.registerNavigationSessionStateObserver(stateObserver)
         clearMocks(stateObserver)
         navigationSession.unregisterNavigationSessionStateObserver(stateObserver)
@@ -204,7 +292,7 @@ class NavigationSessionTest {
                 )
             )
         } just runs
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.registerNavigationSessionStateObserver(mockedStateObserver)
 
         navigationSession.onSessionStateChanged(TripSessionState.STARTED)
@@ -224,7 +312,7 @@ class NavigationSessionTest {
                 )
             )
         } just runs
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.registerNavigationSessionStateObserver(mockedStateObserver)
 
         navigationSession.onSessionStateChanged(TripSessionState.STARTED)
@@ -244,7 +332,7 @@ class NavigationSessionTest {
             )
         } just runs
         val routes = mutableListOf<NavigationRoute>()
-        val navigationSession = NavigationSession()
+        val navigationSession = createNavigationSession()
         navigationSession.registerNavigationSessionStateObserver(mockedStateObserver)
 
         routes.add(route)
@@ -257,40 +345,94 @@ class NavigationSessionTest {
     }
 
     @Test
-    fun navigationSessionStateHoldsSessionId() {
-        val mockedStateObserver: NavigationSessionStateObserver = mockk()
-        val navigationSessionStateSlots = mutableListOf<NavigationSessionState>()
+    fun `start route preview`() {
+        val navigationSession = createNavigationSession()
+        navigationSession.registerNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
+        clearMocks(stateObserver, stateObserverV2, answers = false)
 
-        every {
-            mockedStateObserver.onNavigationSessionStateChanged(
-                capture(
-                    navigationSessionStateSlots
-                )
-            )
-        } just runs
-        val routes = mutableListOf<NavigationRoute>()
-        val navigationSession = NavigationSession()
-        navigationSession.registerNavigationSessionStateObserver(mockedStateObserver)
+        navigationSession.onRoutesChanged(
+            RoutesUpdatedResult(createNavigationRoutes(), RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW)
+        )
 
-        navigationSession.onSessionStateChanged(TripSessionState.STARTED)
-        val one = navigationSessionStateSlots[1].sessionId
-        navigationSession.onSessionStateChanged(TripSessionState.STOPPED)
-        routes.add(
-            mockk {
-                every { routeOptions } returns mockk()
-                every { directionsRoute } returns mockk()
-            }
+        verify(exactly = 1) {
+            stateObserver.onNavigationSessionStateChanged(
+                ofType<NavigationSessionState.FreeDrive>()
+            )
+        }
+        verify(exactly = 1) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                ofType<NavigationSessionStateV2.RoutePreview>()
+            )
+        }
+        assertEquals(
+            navigationSessionStateSlot.captured.sessionId,
+            navigationSessionV2StateSlot.captured.sessionId
         )
+    }
+
+    @Test
+    fun `register observers in route preview state`() {
+        val navigationSession = createNavigationSession()
         navigationSession.onRoutesChanged(
-            RoutesUpdatedResult(routes, RoutesExtra.ROUTES_UPDATE_REASON_NEW)
+            RoutesUpdatedResult(createNavigationRoutes(), RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW)
+        )
+
+        navigationSession.registerNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
+
+        verify(exactly = 1) {
+            stateObserver.onNavigationSessionStateChanged(
+                ofType<NavigationSessionState.FreeDrive>()
+            )
+        }
+        verify(exactly = 1) {
+            stateObserverV2.onNavigationSessionStateChanged(
+                ofType<NavigationSessionStateV2.RoutePreview>()
+            )
+        }
+        assertEquals(
+            navigationSessionStateSlot.captured.sessionId,
+            navigationSessionV2StateSlot.captured.sessionId
         )
+    }
+
+    @Test
+    fun `starting active guidance after route preview`() {
+        val navigationSession = createNavigationSession()
         navigationSession.onSessionStateChanged(TripSessionState.STARTED)
-        routes.clear()
+        val testNavigationRoutes = createNavigationRoutes()
+        navigationSession.onRoutesChanged(
+            RoutesUpdatedResult(testNavigationRoutes, RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW)
+        )
+        navigationSession.registerNavigationSessionStateObserver(stateObserver)
+        navigationSession.registerNavigationSessionStateObserverV2(stateObserverV2)
+
         navigationSession.onRoutesChanged(
-            RoutesUpdatedResult(emptyList(), RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP)
+            RoutesUpdatedResult(testNavigationRoutes, RoutesExtra.ROUTES_UPDATE_REASON_NEW)
         )
-        val two = navigationSessionStateSlots[1].sessionId
 
-        assertEquals(one, two)
+        verifySequence {
+            stateObserver.onNavigationSessionStateChanged(
+                ofType<NavigationSessionState.FreeDrive>()
+            )
+            stateObserver.onNavigationSessionStateChanged(
+                ofType<NavigationSessionState.ActiveGuidance>()
+            )
+        }
+        verifySequence {
+            stateObserverV2.onNavigationSessionStateChanged(
+                ofType<NavigationSessionStateV2.RoutePreview>()
+            )
+            stateObserverV2.onNavigationSessionStateChanged(
+                ofType<NavigationSessionStateV2.ActiveGuidance>()
+            )
+        }
+        assertEquals(
+            navigationSessionStateSlot.captured.sessionId,
+            navigationSessionV2StateSlot.captured.sessionId
+        )
     }
+
+    private fun createNavigationSession() = NavigationSession()
 }

From cf35d73c607f930a4ca50ba5e021a98b106eb728 Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 09:50:42 +0200
Subject: [PATCH 02/12] test switch from route preview to active guidance

---
 .../core/PreviewRoutesTest.kt                      | 14 ++++++++++++++
 .../core/trip/session/NavigationSessionTest.kt     |  1 -
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
index 4b58647971f..a0b6a068f78 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -131,6 +131,20 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
         assertIs<NavigationSessionState.FreeDrive>(mapboxNavigation.getNavigationSessionState())
         assertIs<NavigationSessionStateV2.FreeDrive>(mapboxNavigation.getNavigationSessionStateV2())
     }
+
+    @Test
+    fun start_preview_after_active_guidance() = sdkTest {
+        val routes = RoutesProvider.dc_short_with_alternative(activity).toNavigationRoutes()
+        mapboxNavigation.startTripSession()
+        mapboxNavigation.setNavigationRoutes(routes)
+        mapboxNavigation.waitForNewRoute()
+
+        mapboxNavigation.previewNavigationRoutes(mapboxNavigation.getNavigationRoutes())
+        mapboxNavigation.waitForPreviewRoute()
+
+        assertIs<NavigationSessionState.FreeDrive>(mapboxNavigation.getNavigationSessionState())
+        assertIs<NavigationSessionStateV2.RoutePreview>(mapboxNavigation.getNavigationSessionStateV2())
+    }
 }
 
 private inline fun <reified T> assertIs(obj: Any) {
diff --git a/libnavigation-core/src/test/java/com/mapbox/navigation/core/trip/session/NavigationSessionTest.kt b/libnavigation-core/src/test/java/com/mapbox/navigation/core/trip/session/NavigationSessionTest.kt
index 5bb8e1bf7e8..837e9469b79 100644
--- a/libnavigation-core/src/test/java/com/mapbox/navigation/core/trip/session/NavigationSessionTest.kt
+++ b/libnavigation-core/src/test/java/com/mapbox/navigation/core/trip/session/NavigationSessionTest.kt
@@ -3,7 +3,6 @@ package com.mapbox.navigation.core.trip.session
 import com.mapbox.navigation.base.route.NavigationRoute
 import com.mapbox.navigation.core.directions.session.RoutesExtra
 import com.mapbox.navigation.core.directions.session.RoutesUpdatedResult
-import com.mapbox.navigation.core.trip.session.NavigationSessionState
 import com.mapbox.navigation.testing.factories.createNavigationRoutes
 import io.mockk.clearMocks
 import io.mockk.every

From ea4008d7e3f49e544364d166f910ab6d4f57bd4d Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 10:49:11 +0200
Subject: [PATCH 03/12] fixed route progress in preview state

---
 .../core/PreviewRoutesTest.kt                 | 29 +++++++++++++++++--
 .../navigation/core/MapboxNavigation.kt       |  9 +++++-
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
index a0b6a068f78..f4556b1e138 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -10,6 +10,7 @@ import com.mapbox.navigation.core.trip.session.NavigationSessionState
 import com.mapbox.navigation.core.trip.session.NavigationSessionStateV2
 import com.mapbox.navigation.instrumentation_tests.activity.EmptyTestActivity
 import com.mapbox.navigation.instrumentation_tests.utils.MapboxNavigationRule
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.routeProgressUpdates
 import com.mapbox.navigation.instrumentation_tests.utils.coroutines.sdkTest
 import com.mapbox.navigation.instrumentation_tests.utils.coroutines.waitForNewRoute
 import com.mapbox.navigation.instrumentation_tests.utils.coroutines.waitForPreviewRoute
@@ -19,9 +20,15 @@ import com.mapbox.navigation.instrumentation_tests.utils.routes.RoutesProvider.t
 import com.mapbox.navigation.testing.ui.BaseTest
 import com.mapbox.navigation.testing.ui.utils.getMapboxAccessTokenFromResources
 import com.mapbox.navigation.testing.ui.utils.runOnMainSync
+import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.async
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.withTimeoutOrNull
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Rule
@@ -54,6 +61,7 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
     @Test
     fun preview_route() = sdkTest {
         val routes = RoutesProvider.dc_very_short(activity).toNavigationRoutes()
+        pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
         val previewedRouteDeffer = async {
             mapboxNavigation.waitForPreviewRoute()
@@ -73,6 +81,7 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
     @Test
     fun preview_route_with_alternative() = sdkTest {
         val routes = RoutesProvider.dc_short_with_alternative(activity).toNavigationRoutes()
+        pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
         val previewedRouteDeffer = async {
             mapboxNavigation.waitForPreviewRoute()
@@ -90,6 +99,7 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
     @Test
     fun start_active_guidance_after_preview() = sdkTest {
         val routes = RoutesProvider.dc_short_with_alternative(activity).toNavigationRoutes()
+        pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
         val previewedRouteDeferred = async {
             mapboxNavigation.waitForPreviewRoute()
@@ -101,11 +111,10 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
         }
 
         mapboxNavigation.setNavigationRoutes(mapboxNavigation.getPreviewedNavigationRoutes())
-
         val activeGuidanceRouteUpdate = activeGuidanceRouteUpdateDefer.await()
+
         assertEquals(RoutesExtra.ROUTES_UPDATE_REASON_NEW, activeGuidanceRouteUpdate.reason)
         assertEquals(routes, activeGuidanceRouteUpdate.navigationRoutes)
-
         assertIs<NavigationSessionState.ActiveGuidance>(mapboxNavigation.getNavigationSessionState())
         assertIs<NavigationSessionStateV2.ActiveGuidance>(mapboxNavigation.getNavigationSessionStateV2())
     }
@@ -113,6 +122,7 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
     @Test
     fun switch_to_free_drive_after_preview() = sdkTest {
         val routes = RoutesProvider.dc_very_short(activity).toNavigationRoutes()
+        pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
         val previewedRouteDeffer = async {
             mapboxNavigation.waitForPreviewRoute()
@@ -135,16 +145,31 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
     @Test
     fun start_preview_after_active_guidance() = sdkTest {
         val routes = RoutesProvider.dc_short_with_alternative(activity).toNavigationRoutes()
+        pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
         mapboxNavigation.setNavigationRoutes(routes)
         mapboxNavigation.waitForNewRoute()
+        val activeGuidanceRouteProgress = mapboxNavigation.routeProgressUpdates().first()
 
         mapboxNavigation.previewNavigationRoutes(mapboxNavigation.getNavigationRoutes())
         mapboxNavigation.waitForPreviewRoute()
+        val previewRouteProgress = withTimeoutOrNull(1) {
+            mapboxNavigation.routeProgressUpdates().first()
+        }
 
+        assertNotNull(activeGuidanceRouteProgress)
+        assertNull(previewRouteProgress)
         assertIs<NavigationSessionState.FreeDrive>(mapboxNavigation.getNavigationSessionState())
         assertIs<NavigationSessionStateV2.RoutePreview>(mapboxNavigation.getNavigationSessionStateV2())
     }
+
+    private fun pushPrimaryRouteOriginAsLocation(routes: List<NavigationRoute>) {
+        val origin = routes.first().routeOptions.coordinatesList().first()
+        mockLocationUpdatesRule.pushLocationUpdate {
+            latitude = origin.latitude()
+            longitude = origin.longitude()
+        }
+    }
 }
 
 private inline fun <reified T> assertIs(obj: Any) {
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
index ce18253a449..078e5614ccd 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
@@ -850,6 +850,10 @@ class MapboxNavigation @VisibleForTesting internal constructor(
         routes: List<NavigationRoute>,
         initialLegIndex: Int = 0,
     ) {
+        internalSetNavigationRoutes(
+            emptyList(),
+            BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP, 0)
+        )
         threadController.getMainScopeAndRootJob().scope.launch(Dispatchers.Main.immediate) {
             routeUpdateMutex.withLock {
                 val alternatives = routes.drop(1)
@@ -861,7 +865,10 @@ class MapboxNavigation @VisibleForTesting internal constructor(
                     routes,
                     routesData.alternativeRoutes()
                 )
-                directionsSession.setRoutes(routes, BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW, initialLegIndex))
+                directionsSession.setRoutes(
+                    routes,
+                    BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW, initialLegIndex)
+                )
             }
         }
     }

From 16af4e3e57dc0b936354db859e2b243b12c35d2e Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 11:11:43 +0200
Subject: [PATCH 04/12] fixed event during active guidance -> preview switch

---
 .../instrumentation_tests/core/PreviewRoutesTest.kt  | 12 ++++++++++++
 .../com/mapbox/navigation/core/MapboxNavigation.kt   |  8 ++++++--
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
index f4556b1e138..1933f05a098 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -6,11 +6,13 @@ import com.mapbox.navigation.base.route.NavigationRoute
 import com.mapbox.navigation.core.MapboxNavigation
 import com.mapbox.navigation.core.MapboxNavigationProvider
 import com.mapbox.navigation.core.directions.session.RoutesExtra
+import com.mapbox.navigation.core.directions.session.RoutesUpdatedResult
 import com.mapbox.navigation.core.trip.session.NavigationSessionState
 import com.mapbox.navigation.core.trip.session.NavigationSessionStateV2
 import com.mapbox.navigation.instrumentation_tests.activity.EmptyTestActivity
 import com.mapbox.navigation.instrumentation_tests.utils.MapboxNavigationRule
 import com.mapbox.navigation.instrumentation_tests.utils.coroutines.routeProgressUpdates
+import com.mapbox.navigation.instrumentation_tests.utils.coroutines.routesUpdates
 import com.mapbox.navigation.instrumentation_tests.utils.coroutines.sdkTest
 import com.mapbox.navigation.instrumentation_tests.utils.coroutines.waitForNewRoute
 import com.mapbox.navigation.instrumentation_tests.utils.coroutines.waitForPreviewRoute
@@ -24,6 +26,8 @@ import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.flow.takeWhile
+import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.withTimeoutOrNull
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
@@ -151,12 +155,20 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
         mapboxNavigation.waitForNewRoute()
         val activeGuidanceRouteProgress = mapboxNavigation.routeProgressUpdates().first()
 
+        val routeUpdates = mutableListOf<RoutesUpdatedResult>()
+        mapboxNavigation.registerRoutesObserver {
+            routeUpdates.add(it)
+        }
         mapboxNavigation.previewNavigationRoutes(mapboxNavigation.getNavigationRoutes())
         mapboxNavigation.waitForPreviewRoute()
         val previewRouteProgress = withTimeoutOrNull(1) {
             mapboxNavigation.routeProgressUpdates().first()
         }
 
+        assertEquals(
+            listOf(RoutesExtra.ROUTES_UPDATE_REASON_NEW, RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW),
+            routeUpdates.map { it.reason }
+        )
         assertNotNull(activeGuidanceRouteProgress)
         assertNull(previewRouteProgress)
         assertIs<NavigationSessionState.FreeDrive>(mapboxNavigation.getNavigationSessionState())
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
index 078e5614ccd..0d58a49f72d 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
@@ -852,7 +852,8 @@ class MapboxNavigation @VisibleForTesting internal constructor(
     ) {
         internalSetNavigationRoutes(
             emptyList(),
-            BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP, 0)
+            BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_CLEAN_UP, 0),
+            updateRoutesInDirectionSession = false
         )
         threadController.getMainScopeAndRootJob().scope.launch(Dispatchers.Main.immediate) {
             routeUpdateMutex.withLock {
@@ -909,6 +910,7 @@ class MapboxNavigation @VisibleForTesting internal constructor(
         routes: List<NavigationRoute>,
         setRoutesInfo: SetRoutesInfo,
         callback: RoutesSetCallback? = null,
+        updateRoutesInDirectionSession: Boolean = true
     ) {
         rerouteController?.interrupt()
         restartRouteScope()
@@ -925,7 +927,9 @@ class MapboxNavigation @VisibleForTesting internal constructor(
                                     processedRoute.route.routeId == passedRoute.id
                                 }
                             }
-                        directionsSession.setRoutes(processedRoutes.routes, setRoutesInfo)
+                        if (updateRoutesInDirectionSession) {
+                            directionsSession.setRoutes(processedRoutes.routes, setRoutesInfo)
+                        }
                         routesSetResult = ExpectedFactory.createValue(
                             RoutesSetSuccess(
                                 ignoredAlternatives.associate {

From c6bfad80f7c418735f3022a7da51f3388facb07b Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 11:48:07 +0200
Subject: [PATCH 05/12] fixed fixed route refresh

---
 .../navigation/core/MapboxNavigation.kt       |  4 +++-
 .../navigation/core/MapboxNavigationTest.kt   | 20 +++++++++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
index 0d58a49f72d..e7d66632a43 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
@@ -1726,7 +1726,9 @@ class MapboxNavigation @VisibleForTesting internal constructor(
     private fun createInternalRoutesObserver() = RoutesObserver { result ->
         latestLegIndex = null
         currentIndicesProvider.clear()
-        if (result.navigationRoutes.isNotEmpty()) {
+        if (result.navigationRoutes.isNotEmpty()
+            && result.reason != RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW
+        ) {
             routeScope.launch {
                 val refreshed = routeRefreshController.refresh(
                     result.navigationRoutes
diff --git a/libnavigation-core/src/test/java/com/mapbox/navigation/core/MapboxNavigationTest.kt b/libnavigation-core/src/test/java/com/mapbox/navigation/core/MapboxNavigationTest.kt
index 7222f8c35fa..b204bea92cb 100644
--- a/libnavigation-core/src/test/java/com/mapbox/navigation/core/MapboxNavigationTest.kt
+++ b/libnavigation-core/src/test/java/com/mapbox/navigation/core/MapboxNavigationTest.kt
@@ -40,6 +40,7 @@ import com.mapbox.navigation.core.trip.session.createSetRouteResult
 import com.mapbox.navigation.metrics.internal.TelemetryUtilsDelegate
 import com.mapbox.navigation.testing.factories.createDirectionsRoute
 import com.mapbox.navigation.testing.factories.createNavigationRoute
+import com.mapbox.navigation.testing.factories.createNavigationRoutes
 import com.mapbox.navigation.testing.factories.createRouteOptions
 import com.mapbox.navigator.FallbackVersionsObserver
 import com.mapbox.navigator.NavigatorConfig
@@ -670,6 +671,25 @@ internal class MapboxNavigationTest : MapboxNavigationBaseTest() {
         coVerify(exactly = 0) { routeRefreshController.refresh(any()) }
     }
 
+    @Test
+    fun internalRouteObserver_preview() {
+        createMapboxNavigation()
+        val routes = createNavigationRoutes()
+        val reason = RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW
+        val routeObserversSlot = mutableListOf<RoutesObserver>()
+        every { tripSession.getState() } returns TripSessionState.STARTED
+        verify { directionsSession.registerRoutesObserver(capture(routeObserversSlot)) }
+
+        routeObserversSlot.forEach {
+            it.onRoutesChanged(RoutesUpdatedResult(routes, reason))
+        }
+
+        coVerify(exactly = 1) {
+            currentIndicesProvider.clear()
+        }
+        coVerify(exactly = 0) { routeRefreshController.refresh(any()) }
+    }
+
     @Test
     fun `don't interrupt reroute requests on a standalone route request`() {
         createMapboxNavigation()

From e087d2f33a11b8f1d25711912cfd43f725d13daa Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 12:05:12 +0200
Subject: [PATCH 06/12] fixed subscription in direction session

---
 .../core/PreviewRoutesTest.kt                 |  6 +-----
 .../session/MapboxDirectionsSession.kt        |  3 +++
 .../session/MapboxDirectionsSessionTest.kt    | 20 +++++++++++++++++++
 3 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
index 1933f05a098..ef0871668b1 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -67,15 +67,11 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
         val routes = RoutesProvider.dc_very_short(activity).toNavigationRoutes()
         pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
-        val previewedRouteDeffer = async {
-            mapboxNavigation.waitForPreviewRoute()
-        }
 
         mapboxNavigation.previewNavigationRoutes(routes)
+        val previewRouteUpdate = mapboxNavigation.waitForPreviewRoute()
 
-        val previewRouteUpdate = previewedRouteDeffer.await()
         assertEquals(routes, previewRouteUpdate.navigationRoutes)
-        assertEquals(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW, previewRouteUpdate.reason)
         assertEquals(routes, mapboxNavigation.getPreviewedNavigationRoutes())
         assertEquals(emptyList<NavigationRoute>(), mapboxNavigation.getNavigationRoutes())
         assertIs<NavigationSessionState.FreeDrive>(mapboxNavigation.getNavigationSessionState())
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSession.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSession.kt
index 0f387bcb40f..73a7eaae059 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSession.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSession.kt
@@ -140,6 +140,9 @@ internal class MapboxDirectionsSession(
     override fun registerRoutesObserver(routesObserver: RoutesObserver) {
         routesObservers.add(routesObserver)
         if (routesInitialized) {
+            val routes = if (routesUpdateReason == RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW) {
+                previewedRoutes
+            } else routes
             routesObserver.onRoutesChanged(RoutesUpdatedResult(routes, routesUpdateReason))
         }
     }
diff --git a/libnavigation-core/src/test/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSessionTest.kt b/libnavigation-core/src/test/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSessionTest.kt
index 24e5b8f0ce6..b8099d34cb7 100644
--- a/libnavigation-core/src/test/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSessionTest.kt
+++ b/libnavigation-core/src/test/java/com/mapbox/navigation/core/directions/session/MapboxDirectionsSessionTest.kt
@@ -411,6 +411,26 @@ class MapboxDirectionsSessionTest {
         assertEquals(emptyList<NavigationRoute>(), session.routes)
     }
 
+    @Test
+    fun `register route observer during preview state`() {
+        val testRoutes = createNavigationRoutes()
+        session.setRoutes(
+            testRoutes,
+            BasicSetRoutesInfo(RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW, 0)
+        )
+
+        session.registerRoutesObserver(observer)
+
+        verify {
+            observer.onRoutesChanged(
+                match {
+                    it.navigationRoutes == testRoutes
+                        && it.reason == RoutesExtra.ROUTES_UPDATE_REASON_PREVIEW
+                }
+            )
+        }
+    }
+
     @Test
     fun `clean set previewed route`() {
         session.setRoutes(

From 1c8e8eb43eb5ebc7707892675727716ae8b6f9af Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 14:19:28 +0200
Subject: [PATCH 07/12] cleanup tests

---
 .../instrumentation_tests/core/PreviewRoutesTest.kt        | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
index ef0871668b1..0d80a97f2f9 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -83,16 +83,13 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
         val routes = RoutesProvider.dc_short_with_alternative(activity).toNavigationRoutes()
         pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
-        val previewedRouteDeffer = async {
-            mapboxNavigation.waitForPreviewRoute()
-        }
 
         mapboxNavigation.previewNavigationRoutes(routes)
-
-        val previewRouteUpdate = previewedRouteDeffer.await()
+        val previewRouteUpdate = mapboxNavigation.waitForPreviewRoute()
         val previewedRouteMetadata = mapboxNavigation.getAlternativeMetadataFor(
             previewRouteUpdate.navigationRoutes[1]
         )
+
         assertNotNull(previewedRouteMetadata)
     }
 

From 522537b24641dd4ef0f16930683b2d18d85c93dd Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 14:21:38 +0200
Subject: [PATCH 08/12] test cleanup

---
 .../instrumentation_tests/core/PreviewRoutesTest.kt    | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
index 0d80a97f2f9..cbbde029d5b 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -98,17 +98,11 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
         val routes = RoutesProvider.dc_short_with_alternative(activity).toNavigationRoutes()
         pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
-        val previewedRouteDeferred = async {
-            mapboxNavigation.waitForPreviewRoute()
-        }
         mapboxNavigation.previewNavigationRoutes(routes)
-        previewedRouteDeferred.await()
-        val activeGuidanceRouteUpdateDefer = async {
-            mapboxNavigation.waitForNewRoute()
-        }
+        mapboxNavigation.waitForPreviewRoute()
 
         mapboxNavigation.setNavigationRoutes(mapboxNavigation.getPreviewedNavigationRoutes())
-        val activeGuidanceRouteUpdate = activeGuidanceRouteUpdateDefer.await()
+        val activeGuidanceRouteUpdate = mapboxNavigation.waitForNewRoute()
 
         assertEquals(RoutesExtra.ROUTES_UPDATE_REASON_NEW, activeGuidanceRouteUpdate.reason)
         assertEquals(routes, activeGuidanceRouteUpdate.navigationRoutes)

From 55fc92314e5156edf0675ae7805d53ac5f2a7604 Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 14:25:03 +0200
Subject: [PATCH 09/12] tests cleanup

---
 .../instrumentation_tests/core/PreviewRoutesTest.kt    | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
index cbbde029d5b..fffbf2fd2cd 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -115,18 +115,12 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
         val routes = RoutesProvider.dc_very_short(activity).toNavigationRoutes()
         pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
-        val previewedRouteDeffer = async {
-            mapboxNavigation.waitForPreviewRoute()
-        }
         mapboxNavigation.previewNavigationRoutes(routes)
-        previewedRouteDeffer.await()
-        val freeDriveRoutesUpdateDeferred = async {
-            mapboxNavigation.waitForRoutesCleanUp()
-        }
+        mapboxNavigation.waitForPreviewRoute()
 
         mapboxNavigation.clearRoutes()
+        val freeDriveRoutesUpdate = mapboxNavigation.waitForRoutesCleanUp()
 
-        val freeDriveRoutesUpdate = freeDriveRoutesUpdateDeferred.await()
         assertEquals(emptyList<NavigationRoute>(), freeDriveRoutesUpdate.navigationRoutes)
         assertEquals(emptyList<NavigationRoute>(), mapboxNavigation.getNavigationRoutes())
         assertIs<NavigationSessionState.FreeDrive>(mapboxNavigation.getNavigationSessionState())

From db24a1c626396c630a9f7b4e4513e80066083981 Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 14:26:28 +0200
Subject: [PATCH 10/12] tests cleanup

---
 .../navigation/instrumentation_tests/core/PreviewRoutesTest.kt   | 1 -
 1 file changed, 1 deletion(-)

diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
index fffbf2fd2cd..6ffdc50ab82 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -104,7 +104,6 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
         mapboxNavigation.setNavigationRoutes(mapboxNavigation.getPreviewedNavigationRoutes())
         val activeGuidanceRouteUpdate = mapboxNavigation.waitForNewRoute()
 
-        assertEquals(RoutesExtra.ROUTES_UPDATE_REASON_NEW, activeGuidanceRouteUpdate.reason)
         assertEquals(routes, activeGuidanceRouteUpdate.navigationRoutes)
         assertIs<NavigationSessionState.ActiveGuidance>(mapboxNavigation.getNavigationSessionState())
         assertIs<NavigationSessionStateV2.ActiveGuidance>(mapboxNavigation.getNavigationSessionStateV2())

From 7b43599145a37f64e7a09b656d0c773207db6ca4 Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 14:31:04 +0200
Subject: [PATCH 11/12] test idle -> preview

---
 .../instrumentation_tests/core/PreviewRoutesTest.kt          | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
index 6ffdc50ab82..ba41252edaa 100644
--- a/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
+++ b/instrumentation-tests/src/androidTest/java/com/mapbox/navigation/instrumentation_tests/core/PreviewRoutesTest.kt
@@ -63,7 +63,7 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
     }
 
     @Test
-    fun preview_route() = sdkTest {
+    fun preview_route_from_free_drive() = sdkTest {
         val routes = RoutesProvider.dc_very_short(activity).toNavigationRoutes()
         pushPrimaryRouteOriginAsLocation(routes)
         mapboxNavigation.startTripSession()
@@ -79,10 +79,9 @@ class PreviewRoutesTest : BaseTest<EmptyTestActivity>(EmptyTestActivity::class.j
     }
 
     @Test
-    fun preview_route_with_alternative() = sdkTest {
+    fun preview_route_with_alternative_from_idle() = sdkTest {
         val routes = RoutesProvider.dc_short_with_alternative(activity).toNavigationRoutes()
         pushPrimaryRouteOriginAsLocation(routes)
-        mapboxNavigation.startTripSession()
 
         mapboxNavigation.previewNavigationRoutes(routes)
         val previewRouteUpdate = mapboxNavigation.waitForPreviewRoute()

From 25708e0ff4f9ca778a9705265d1075ade44d2798 Mon Sep 17 00:00:00 2001
From: VysotskiVadim <vadzim.vysotski@mapbox.com>
Date: Thu, 13 Oct 2022 17:07:34 +0200
Subject: [PATCH 12/12] added some documentation

---
 .../mapbox/navigation/core/MapboxNavigation.kt    | 15 +++++++++++++++
 .../core/trip/session/NavigationSession.kt        |  3 +++
 .../session/NavigationSessionStateObserverV2.kt   |  2 +-
 3 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
index e7d66632a43..7db1af5c1d3 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/MapboxNavigation.kt
@@ -657,6 +657,14 @@ class MapboxNavigation @VisibleForTesting internal constructor(
      * @see [registerNavigationSessionStateObserver]
      */
     fun getNavigationSessionState(): NavigationSessionState = navigationSession.state
+
+    /**
+     * Provides the current navigation session state.
+     * Replacement of [MapboxNavigation.getNavigationSessionState] which to be depricated.
+     *
+     * @return current [NavigationSessionStateV2]
+     */
+    @ExperimentalPreviewMapboxNavigationAPI
     fun getNavigationSessionStateV2(): NavigationSessionStateV2 = navigationSession.stateV2
 
     /**
@@ -1012,6 +1020,13 @@ class MapboxNavigation @VisibleForTesting internal constructor(
      */
     fun getNavigationRoutes(): List<NavigationRoute> = directionsSession.routes
 
+    /**
+     * Get a list of previewed routes.
+     *
+     * If the list is not empty, the route at index 0 is the one treated as the primary route.
+     *
+     * @return a list of [NavigationRoute]s
+     */
     fun getPreviewedNavigationRoutes(): List<NavigationRoute> = directionsSession.previewedRoutes
 
     /**
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSession.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSession.kt
index be27c90c0b0..935d65e1446 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSession.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSession.kt
@@ -188,6 +188,9 @@ sealed class NavigationSessionStateV2 {
         override val sessionId: String
     ) : NavigationSessionStateV2()
 
+    /**
+     * Route preview state
+     */
     data class RoutePreview internal constructor(
         override val sessionId: String
     ) : NavigationSessionStateV2()
diff --git a/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionStateObserverV2.kt b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionStateObserverV2.kt
index 3a1a562c5aa..27b7051dfbf 100644
--- a/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionStateObserverV2.kt
+++ b/libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/session/NavigationSessionStateObserverV2.kt
@@ -3,7 +3,7 @@ package com.mapbox.navigation.core.trip.session
 /**
  * Callback that provides the various session states that can happen within a navigation session
  *
- * @see NavigationSessionState
+ * @see NavigationSessionStateV2
  */
 fun interface NavigationSessionStateObserverV2 {
     /**