NAVAND-6445: add LocationIndicator3DConfig#emissiveStrength

GitOrigin-RevId: 6ada7ed07808e811f18569625a16c643dd844a48

Author: dzinad

base/api/current.txt

@@ -1379,7 +1379,6 @@ package com.mapbox.navigation.base.route {
     field public static final String INPUT_ERROR = "INPUT_ERROR";
     field public static final String NETWORK_ERROR = "NETWORK_ERROR";
     field public static final String RESPONSE_PARSING_ERROR = "RESPONSE_PARSING_ERROR";
-    field public static final String ROUTER_RECREATION_ERROR = "ROUTER_RECREATION_ERROR";
     field public static final String ROUTE_CREATION_ERROR = "ROUTE_CREATION_ERROR";
     field public static final String THROTTLING_ERROR = "THROTTLING_ERROR";
     field public static final String UNKNOWN_ERROR = "UNKNOWN_ERROR";
@@ -1390,7 +1389,6 @@ package com.mapbox.navigation.base.route {
     field public static final String INPUT_ERROR = "INPUT_ERROR";
     field public static final String NETWORK_ERROR = "NETWORK_ERROR";
     field public static final String RESPONSE_PARSING_ERROR = "RESPONSE_PARSING_ERROR";
-    field public static final String ROUTER_RECREATION_ERROR = "ROUTER_RECREATION_ERROR";
     field public static final String ROUTE_CREATION_ERROR = "ROUTE_CREATION_ERROR";
     field public static final String THROTTLING_ERROR = "THROTTLING_ERROR";
     field public static final String UNKNOWN_ERROR = "UNKNOWN_ERROR";

base/src/main/java/com/mapbox/navigation/base/route/RouterFailureType.kt

@@ -54,11 +54,6 @@ annotation class RouterFailureType {
          */
         const val RESPONSE_PARSING_ERROR = "RESPONSE_PARSING_ERROR"
 
-        /**
-         * Indicates that router was recreated for some internal reason.
-         */
-        const val ROUTER_RECREATION_ERROR = "ROUTER_RECREATION_ERROR"
-
         /**
          * Error has an unknown type
          */

changelog/unreleased/bugfixes/11200.md

@@ -41,7 +41,6 @@ android {
 
 dependencies {
 
-    implementation dependenciesList.mapboxSdkTurf
     implementation project(':navigation')
     testImplementation dependenciesList.androidxTestJunit
     testImplementation dependenciesList.coroutinesTestAndroid

changelog/unreleased/bugfixes/11274.md

@@ -1,7 +1,6 @@
 package com.mapbox.navigation.driver.notification.internal
 
 import androidx.annotation.RestrictTo
-import com.mapbox.geojson.Point
 import kotlin.time.Duration
 
 /**
@@ -28,10 +27,4 @@ data class SlowTrafficSegment(
     val distanceMeters: Double,
     val freeFlowDuration: Duration,
     val duration: Duration,
-    // Note: it is mutable only as an optimization, in order not to create too many Lists
-    // during object's construction.
-    internal val _points: MutableList<Point> = mutableListOf(),
-) {
-
-    val points: List<Point> get() = _points
-}
+)

changelog/unreleased/bugfixes/11276.md

@@ -2,10 +2,7 @@ package com.mapbox.navigation.driver.notification.internal
 
 import androidx.annotation.RestrictTo
 import com.mapbox.api.directions.v5.models.RouteLeg
-import com.mapbox.core.constants.Constants
-import com.mapbox.geojson.Point
 import com.mapbox.navigation.base.trip.model.RouteProgress
-import com.mapbox.navigation.utils.internal.geometryPoints
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlin.time.Duration
@@ -16,15 +13,9 @@ import kotlin.time.Duration.Companion.seconds
  *
  * Note: The core logic is computationally intensive as it iterates through potentially thousands
  * of geometry points
- *
- * @param extractPoints for testing purposes only ([geometryPoints] is a static function)
  */
 @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
-class SlowTrafficSegmentsFinder(
-    private val extractPoints: (RouteLeg) -> List<Point> = {
-        it.geometryPoints(Constants.PRECISION_6)
-    },
-) {
+class SlowTrafficSegmentsFinder {
 
     /**
      * Scans the route, starting from the user's current progress, to find continuous
@@ -76,7 +67,7 @@ class SlowTrafficSegmentsFinder(
                 0
             }
 
-            val geometry = Geometry.of(leg, extractPoints(leg)) ?: Geometry.Companion.EMPTY
+            val geometry = Geometry.Companion.of(leg) ?: Geometry.Companion.EMPTY
             var currentSegment: SlowTrafficSegment? = null
 
             for (geometryIndex in firstGeometryIndex until geometry.size) {
@@ -126,35 +117,25 @@ class SlowTrafficSegmentsFinder(
                 // Applying conversion of the speed from km/h -> m/s
                 geometry.distance(geometryIndex) * KM_PER_H_TO_M_PER_SEC_RATE / legFreeFlowSpeed
             }
-
             0.0 < this.distanceMeters -> {
                 // Adding average duration based on the previous geometry
                 val avgTimePerMeter =
                     this.freeFlowDuration.inWholeSeconds.toDouble() / this.distanceMeters
                 geometry.distance(geometryIndex) * avgTimePerMeter
             }
-
             else -> 0.0
         }
-
         return this.copy(
             freeFlowDuration = this.freeFlowDuration + freeFlowDurationSec.seconds,
             duration = this.duration + geometry.duration(geometryIndex),
             distanceMeters = this.distanceMeters + geometry.distance(geometryIndex),
             geometryRange = geometryRange.first..geometryIndex,
-        ).apply {
-            // Each geometry consists of 2 points
-            if (_points.isEmpty()) {
-                _points.add(geometry.point(geometryIndex))
-            }
-            _points.add(geometry.point(geometryIndex + 1))
-        }
+        )
     }
 
     private fun List<IntRange>.rangeOf(congestion: Int?) = firstOrNull { it.contains(congestion) }
 
     private companion object {
-
         // Calc time with seconds:
         // dist_m / speed_km_h = dist_m / (speed_km_h * 1000 / 3600) = dist_m * 3.6 / speed_km_h = duration_sec
         private const val KM_PER_H_TO_M_PER_SEC_RATE = 3.6
@@ -169,29 +150,20 @@ private class Geometry(
     private val durations: List<Double>,
     private val freeFlowSpeeds: List<Int?>,
     private val congestions: List<Int?>,
-    private val points: List<Point>,
 ) {
-
     val size: Int = listOf(
         distances.size,
         durations.size,
         freeFlowSpeeds.size,
         congestions.size,
     ).min()
-
     fun distance(index: Int): Double = distances[index]
     fun duration(index: Int): Duration = durations[index].seconds
     fun freeFlowSpeed(index: Int): Int? = freeFlowSpeeds[index]
     fun congestion(index: Int): Int? = congestions[index]
 
-    /**
-     * Note: there will be `size + 1` number of points, because each geometry consists of 2 points.
-     */
-    fun point(index: Int): Point = points[index]
-
     companion object {
-
-        fun of(leg: RouteLeg, points: List<Point>): Geometry? {
+        fun of(leg: RouteLeg): Geometry? {
             val legDistances = leg.annotation()?.distance() ?: return null
             val legDurations = leg.annotation()?.duration() ?: return null
             val legFreeFlowSpeeds = leg.annotation()?.freeflowSpeed() ?: return null
@@ -202,10 +174,9 @@ private class Geometry(
                 legDurations,
                 legFreeFlowSpeeds,
                 legCongestions,
-                points,
             )
         }
 
-        val EMPTY = Geometry(emptyList(), emptyList(), emptyList(), emptyList(), emptyList())
+        val EMPTY = Geometry(emptyList(), emptyList(), emptyList(), emptyList())
     }
 }

changelog/unreleased/features/11151.md

@@ -3,7 +3,6 @@ package com.mapbox.navigation.driver.notification.internal
 import com.mapbox.api.directions.v5.models.DirectionsRoute
 import com.mapbox.api.directions.v5.models.LegAnnotation
 import com.mapbox.api.directions.v5.models.RouteLeg
-import com.mapbox.geojson.Point
 import com.mapbox.navigation.base.internal.utils.Constants
 import com.mapbox.navigation.base.internal.utils.Constants.CongestionRange.HEAVY_CONGESTION_RANGE
 import com.mapbox.navigation.base.internal.utils.Constants.CongestionRange.SEVERE_CONGESTION_RANGE
@@ -20,15 +19,7 @@ class SlowTrafficSegmentsFinderTest {
     private val lowCongestion = Constants.CongestionRange.LOW_CONGESTION_RANGE.middle
     private val heavyCongestion = HEAVY_CONGESTION_RANGE.middle
     private val severeCongestion = SEVERE_CONGESTION_RANGE.middle
-    private val finder = SlowTrafficSegmentsFinder(
-        extractPoints = {
-                // We don't really care about the specific points
-                leg ->
-            List(leg.annotation()!!.distance()!!.size + 1) {
-                Point.fromLngLat(10.0, 20.0)
-            }
-        },
-    )
+    private val finder = SlowTrafficSegmentsFinder()
 
     @Test
     fun `finds single slow segment in middle of leg`() = runBlocking {