Fixed crash caused by ConstantVelocityInterpolator creating PathInterpolator with an invalid path. (#6367)

* Fixed crash caused by ConstantVelocityInterpolator creating PathInterpolator with an invalid path.

* CHANGELOG

Author: tomaszrybakiewicz

CHANGELOG.md

@@ -16,6 +16,7 @@ Mapbox welcomes participation and contributions from everyone.
 - Replaced `ViewStyleCustomization.defaultMarkerAnnotationOptions` with `ViewStyleCustomization.defaultDestinationMarkerAnnotationOptions`. [#6365](https://github.com/mapbox/mapbox-navigation-android/pull/6365)
 - Fixed the issue with incorrect geometry indices for `RouteLeg#incidents` and `RouteLeg#closures` after refresh. [#6364](https://github.com/mapbox/mapbox-navigation-android/pull/6364)
 - Introduced `NavigationViewListener#onMapClicked` to inform when a map was clicked, but the event was not processed by `NavigationView`. [#6360](https://github.com/mapbox/mapbox-navigation-android/pull/6360)
+- Fixed crash caused by `ConstantVelocityInterpolator` creating `PathInterpolator` with an invalid path. [#6367](https://github.com/mapbox/mapbox-navigation-android/pull/6367)
 
 ## Mapbox Navigation SDK 2.9.0-alpha.2 - 16 September, 2022
 ### Changelog

libnavui-maps/src/main/java/com/mapbox/navigation/ui/maps/internal/location/ConstantVelocityInterpolator.kt

@@ -20,22 +20,16 @@ class ConstantVelocityInterpolator(
         val distances = mutableListOf<Double>()
         var total = 0.0
         keyPoints.fold(startPoint) { prevPoint, point ->
-            val d = distanceTo(prevPoint, point)
-            distances.add(d)
-            total += d
+            val d = distance(prevPoint, point)
+            if (0.0 < d) {
+                distances.add(d)
+                total += d
+            }
             point
         }
 
         innerInterpolator = if (0 < total) {
-            val path = Path()
-            val step = 1.0f / keyPoints.size
-            var pathTime = 0.0
-            keyPoints.forEachIndexed { index, _ ->
-                // simplified from (distances[index] / velocity) where (velocity = total / duration) and duration = 1.0
-                val deltaTime = distances[index] / total
-                pathTime += deltaTime
-                path.lineTo(pathTime.toFloat(), step * (index + 1))
-            }
+            val path = timingPath(distances, total)
             PathInterpolator(path)
         } else {
             TimeInterpolator { it }
@@ -45,7 +39,23 @@ class ConstantVelocityInterpolator(
     override fun getInterpolation(input: Float): Float =
         innerInterpolator.getInterpolation(input)
 
-    private fun distanceTo(p1: Point, p2: Point): Double {
+    private fun distance(p1: Point, p2: Point): Double {
         return hypot(p2.latitude() - p1.latitude(), p2.longitude() - p1.longitude())
     }
+
+    private fun timingPath(distances: List<Double>, total: Double): Path {
+        val path = Path()
+        val step = 1.0f / distances.size
+        var pathTime = 0.0f
+        // NOTE: The Path must start at (0,0) and end at (1,1)
+        // To avoid PathInterpolator IllegalArgException, we ignore last keypoint distance value
+        // and manually add line to (1,1).
+        for (i in 0..distances.size - 2) {
+            val deltaTime = distances[i] / total
+            pathTime += deltaTime.toFloat()
+            path.lineTo(pathTime, (step * (i + 1)))
+        }
+        path.lineTo(1f, 1f)
+        return path
+    }
 }

libnavui-maps/src/test/java/com/mapbox/navigation/ui/maps/internal/location/ConstantVelocityInterpolatorTest.kt

@@ -29,6 +29,24 @@ class ConstantVelocityInterpolatorTest {
         }
     }
 
+    @Test
+    fun `should not use keypoints that are at ZERO distance from previous point`() {
+        val p0 = Point.fromLngLat(0.0, 0.0)
+        val keyPoints = arrayOf(
+            Point.fromLngLat(0.5, 0.5),
+            Point.fromLngLat(0.5, 0.5),
+            Point.fromLngLat(1.0, 1.0),
+        )
+
+        val sut = ConstantVelocityInterpolator(p0, keyPoints)
+
+        val path = calculatePathValues(p0, *keyPoints)
+        assertEquals(keyPoints.size - 1, path.size)
+        path.forEach { (outTime, inTime) ->
+            assertEquals(outTime, sut.getInterpolation(inTime))
+        }
+    }
+
     @Test
     fun `should use linear interpolation for key points at zero distance`() {
         val p0 = Point.fromLngLat(1.0, 1.0)
@@ -58,18 +76,18 @@ class ConstantVelocityInterpolatorTest {
         val distances = mutableListOf<Double>()
         var totalDistance = 0.0
         points.fold(p0) { a, b ->
-            val d = sqrt(
-                (b.latitude() - a.latitude()).pow(2.0) +
-                    (b.longitude() - a.longitude()).pow(2.0)
-            )
-            distances.add(d)
-            totalDistance += d
+            val d = distance(a, b)
+            if (0 < d) {
+                distances.add(d)
+                totalDistance += d
+            }
             b
         }
-        val timeStep = 1.0f / points.size
-        var pathTime = 0.0
+
+        val timeStep = 1.0f / distances.size
         val velocities = mutableListOf<Double>()
-        val path = mutableListOf<Pair<Float, Float>>()
+        val path = mutableListOf<Pair<Float, Float>>() // animationTime to scaledTime
+        var pathTime = 0.0
         distances.forEachIndexed { i, d ->
             val dt = d / totalDistance
             velocities.add(d / dt)
@@ -78,10 +96,16 @@ class ConstantVelocityInterpolatorTest {
         }
 
         // verify constant velocity
-        for (i in 1 until points.size) {
+        for (i in 1 until distances.size) {
             assertEquals(velocities[i - 1], velocities[i], 0.0001)
         }
 
         return path
     }
+
+    private fun distance(a: Point, b: Point) =
+        sqrt(
+            (b.latitude() - a.latitude()).pow(2.0) +
+                (b.longitude() - a.longitude()).pow(2.0)
+        )
 }