NAVAND-979: represent imperial distances in miles down to 0.1 miles in miles

Author: dzinad

CHANGELOG.md

@@ -29,6 +29,7 @@ Mapbox welcomes participation and contributions from everyone.
 - Introduced `NavigationViewListener.onSpeedInfoClicked` that would be triggered when `MapboxSpeedInfoView` is clicked upon. [#6770](https://github.com/mapbox/mapbox-navigation-android/pull/6770)
 - Each newly instantiated MapboxRouteArrowView class will initialize the layers with the provided options on the first render call. Previously this would only be done if the layers hadn't already been initialized.  [#6466](https://github.com/mapbox/mapbox-navigation-android/pull/6466)
 - Fixed an issue where the first voice instruction might have been played twice. [#6766](https://github.com/mapbox/mapbox-navigation-android/pull/6766)
+- Changed distance formatting: now all the imperial distances down to 0.1 miles will be represented in miles, while the smaller ones - in feet. [#6775](https://github.com/mapbox/mapbox-navigation-android/pull/6775)
 
 ## Mapbox Navigation SDK 2.10.0-rc.1 - 16 December, 2022
 ### Changelog

libnavigation-core/src/main/java/com/mapbox/navigation/core/formatter/MapboxDistanceUtil.kt

@@ -16,8 +16,10 @@ import kotlin.math.roundToInt
  */
 object MapboxDistanceUtil {
 
-    private const val smallDistanceUpperThresholdInMeters = 400.0
-    private const val mediumDistanceUpperThresholdInMeters = 10000.0
+    private const val SMALL_DISTANCE_LOWER_BOUND_IN_MILES = 0.1
+    private const val MEDIUM_DISTANCE_LOWER_BOUND_IN_MILES = 10.0
+    private const val SMALL_DISTANCE_UPPER_THRESHOLD_IN_METERS = 400.0
+    private const val MEDIUM_DISTANCE_UPPER_THRESHOLD_IN_METERS = 10000.0
 
     /**
      * This will recalculate and format a distance based on the parameters inputted. The value
@@ -37,31 +39,35 @@ object MapboxDistanceUtil {
         context: Context,
         locale: Locale
     ): FormattedDistanceData {
-        return when (distanceInMeters) {
-            !in 0.0..Double.MAX_VALUE -> {
-                formatDistanceAndSuffixForSmallUnit(
-                    0.0,
-                    roundingIncrement,
-                    unitType,
-                    context,
-                    locale
-                )
-            }
-            in 0.0..smallDistanceUpperThresholdInMeters -> {
-                formatDistanceAndSuffixForSmallUnit(
-                    distanceInMeters,
-                    roundingIncrement,
-                    unitType,
-                    context,
-                    locale
-                )
-            }
-            in smallDistanceUpperThresholdInMeters..mediumDistanceUpperThresholdInMeters -> {
-                formatDistanceAndSuffixForLargeUnit(distanceInMeters, 1, unitType, context, locale)
-            }
-            else -> {
-                formatDistanceAndSuffixForLargeUnit(distanceInMeters, 0, unitType, context, locale)
-            }
+        return when (getFormattingRange(distanceInMeters, unitType)) {
+            FormattingRange.INVALID -> formatDistanceAndSuffixForSmallUnit(
+                0.0,
+                roundingIncrement,
+                unitType,
+                context,
+                locale
+            )
+            FormattingRange.SMALL -> formatDistanceAndSuffixForSmallUnit(
+                distanceInMeters,
+                roundingIncrement,
+                unitType,
+                context,
+                locale
+            )
+            FormattingRange.MEDIUM -> formatDistanceAndSuffixForLargeUnit(
+                distanceInMeters,
+                1,
+                unitType,
+                context,
+                locale
+            )
+            FormattingRange.LARGE -> formatDistanceAndSuffixForLargeUnit(
+                distanceInMeters,
+                0,
+                unitType,
+                context,
+                locale
+            )
         }
     }
 
@@ -104,17 +110,17 @@ object MapboxDistanceUtil {
         roundingIncrement: Int,
         unitType: UnitType
     ): Double {
-        return when (distanceInMeters) {
-            !in 0.0..Double.MAX_VALUE -> {
+        return when (getFormattingRange(distanceInMeters, unitType)) {
+            FormattingRange.INVALID -> {
                 roundSmallDistance(distanceInMeters, roundingIncrement, unitType).toDouble()
             }
-            in 0.0..smallDistanceUpperThresholdInMeters -> {
+            FormattingRange.SMALL -> {
                 roundSmallDistance(distanceInMeters, roundingIncrement, unitType).toDouble()
             }
-            in smallDistanceUpperThresholdInMeters..mediumDistanceUpperThresholdInMeters -> {
+            FormattingRange.MEDIUM -> {
                 roundLargeDistance(distanceInMeters, unitType)
             }
-            else -> {
+            FormattingRange.LARGE -> {
                 roundLargeDistance(distanceInMeters, unitType)
             }
         }
@@ -234,4 +240,42 @@ object MapboxDistanceUtil {
         }
         return this.createConfigurationContext(config).resources
     }
+
+    private enum class FormattingRange { INVALID, SMALL, MEDIUM, LARGE }
+
+    private fun getFormattingRange(
+        distanceInMeters: Double,
+        unitType: UnitType
+    ): FormattingRange {
+        if (distanceInMeters !in 0.0..Double.MAX_VALUE) {
+            return FormattingRange.INVALID
+        }
+        return when (unitType) {
+            UnitType.METRIC -> metricRange(distanceInMeters)
+            UnitType.IMPERIAL -> {
+                val distanceInMiles = TurfConversion.convertLength(
+                    distanceInMeters,
+                    TurfConstants.UNIT_METERS,
+                    getLargeTurfUnitType(unitType)
+                )
+                imperialRange(distanceInMiles)
+            }
+        }
+    }
+
+    private fun metricRange(distance: Double): FormattingRange = when (distance) {
+        in 0.0..SMALL_DISTANCE_UPPER_THRESHOLD_IN_METERS -> FormattingRange.SMALL
+        in SMALL_DISTANCE_UPPER_THRESHOLD_IN_METERS..MEDIUM_DISTANCE_UPPER_THRESHOLD_IN_METERS ->
+            FormattingRange.MEDIUM
+        else -> FormattingRange.LARGE
+    }
+
+    private fun imperialRange(distance: Double): FormattingRange {
+        return when (distance) {
+            in 0.0..SMALL_DISTANCE_LOWER_BOUND_IN_MILES -> FormattingRange.SMALL
+            in SMALL_DISTANCE_LOWER_BOUND_IN_MILES..MEDIUM_DISTANCE_LOWER_BOUND_IN_MILES ->
+                FormattingRange.MEDIUM
+            else -> FormattingRange.LARGE
+        }
+    }
 }