remove MapboxTripStarterState

Author: kmadsen

libnavigation-core/src/main/java/com/mapbox/navigation/core/trip/MapboxTripStarter.kt

@@ -20,9 +20,7 @@ import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.collect
-import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
@@ -40,7 +38,11 @@ import kotlinx.coroutines.launch
 @ExperimentalPreviewMapboxNavigationAPI
 class MapboxTripStarter internal constructor() : MapboxNavigationObserver {
 
-    private val stateFlow = MutableStateFlow(MapboxTripStarterState())
+    private val tripType = MutableStateFlow(MAPBOX_TRIP_STARTER_MAP_MATCHING)
+    private val replayRouteSessionOptions = MutableStateFlow(
+        ReplayRouteSessionOptions.Builder().build()
+    )
+    private val isLocationPermissionGranted = MutableStateFlow(false)
     private var replayRouteTripSession: ReplayRouteSession? = null
     private var mapboxNavigation: MapboxNavigation? = null
 
@@ -57,7 +59,7 @@ class MapboxTripStarter internal constructor() : MapboxNavigationObserver {
         // Initialize the options to be aware of the location permissions
         val context = mapboxNavigation.navigationOptions.applicationContext
         val granted = PermissionsManager.areLocationPermissionsGranted(context)
-        stateFlow.update { it.copy(isLocationPermissionGranted = granted) }
+        isLocationPermissionGranted.update { granted }
 
         // Observe changes to state
         coroutineScope.launch { observeStateFlow(mapboxNavigation).collect() }
@@ -81,7 +83,7 @@ class MapboxTripStarter internal constructor() : MapboxNavigationObserver {
     fun refreshLocationPermissions() = apply {
         mapboxNavigation?.navigationOptions?.applicationContext?.let { context ->
             val granted = PermissionsManager.areLocationPermissionsGranted(context)
-            stateFlow.value = stateFlow.value.copy(isLocationPermissionGranted = granted)
+            isLocationPermissionGranted.value = granted
         }
     }
 
@@ -91,18 +93,17 @@ class MapboxTripStarter internal constructor() : MapboxNavigationObserver {
      * effect on the experience.
      */
     fun enableMapMatching() = apply {
-        if (!stateFlow.value.isLocationPermissionGranted) {
+        if (!isLocationPermissionGranted.value) {
             refreshLocationPermissions()
         }
-        stateFlow.update { it.copy(tripType = MAPBOX_TRIP_STARTER_MAP_MATCHING) }
+        tripType.update { MAPBOX_TRIP_STARTER_MAP_MATCHING }
     }
 
     /**
      * Get the current [ReplayRouteSessionOptions]. This can be used with [enableReplayRoute] to
      * make minor adjustments to the current options.
      */
-    fun getReplayRouteSessionOptions(): ReplayRouteSessionOptions =
-        stateFlow.value.replayRouteSessionOptions
+    fun getReplayRouteSessionOptions(): ReplayRouteSessionOptions = replayRouteSessionOptions.value
 
     /**
      * Enables a mode where the primary route is simulated by an artificial driver. Set the route
@@ -114,26 +115,22 @@ class MapboxTripStarter internal constructor() : MapboxNavigationObserver {
     fun enableReplayRoute(
         options: ReplayRouteSessionOptions? = null
     ) = apply {
-        stateFlow.update {
-            it.copy(
-                tripType = MAPBOX_TRIP_STARTER_REPLAY_ROUTE,
-                replayRouteSessionOptions = options ?: it.replayRouteSessionOptions
-            )
-        }
+        options?.let { options -> replayRouteSessionOptions.update { options } }
+        tripType.update { MAPBOX_TRIP_STARTER_REPLAY_ROUTE }
     }
 
     @OptIn(ExperimentalCoroutinesApi::class)
     private fun observeStateFlow(mapboxNavigation: MapboxNavigation): Flow<*> {
-        return stateFlow.map { it.tripType }.distinctUntilChanged().flatMapLatest { tripType ->
+        return tripType.flatMapLatest { tripType ->
             when (tripType) {
                 MAPBOX_TRIP_STARTER_REPLAY_ROUTE ->
-                    stateFlow
-                        .map { it.replayRouteSessionOptions }.distinctUntilChanged()
-                        .onEach { options -> onReplayTripEnabled(mapboxNavigation, options) }
+                    replayRouteSessionOptions.onEach { options ->
+                        onReplayTripEnabled(mapboxNavigation, options)
+                    }
                 MAPBOX_TRIP_STARTER_MAP_MATCHING ->
-                    stateFlow
-                        .map { it.isLocationPermissionGranted }.distinctUntilChanged()
-                        .onEach { granted -> onMapMatchingEnabled(mapboxNavigation, granted) }
+                    isLocationPermissionGranted.onEach { granted ->
+                        onMapMatchingEnabled(mapboxNavigation, granted)
+                    }
                 else -> throw NotImplementedError("$LOG_CATEGORY type is not supported $tripType")
             }
         }