mapbox · korshaknn · Feb 19, 2020 · Feb 13, 2020
diff --git a/gradle/dependencies.gradle b/gradle/dependencies.gradle
@@ -9,8 +9,8 @@ ext {
 
   version = [
       mapboxMapSdk              : '9.1.0-SNAPSHOT',
-      mapboxSdkServices         : '5.1.0-beta.1',
-      mapboxSdkDirectionsModels : '5.1.0-beta.1',
+      mapboxSdkServices         : '5.1.0-SNAPSHOT',
+      mapboxSdkDirectionsModels : '5.1.0-SNAPSHOT',
       mapboxEvents              : '4.5.1',
       mapboxCore                : '1.3.0',
       mapboxNavigator           : 'ms-bearing-from-shape-on-interpolation-SNAPSHOT-2',

diff --git a/...ion/src/main/java/com/mapbox/services/android/navigation/v5/navigation/NavigationRoute.kt b/...ion/src/main/java/com/mapbox/services/android/navigation/v5/navigation/NavigationRoute.kt
@@ -13,6 +13,7 @@ import com.mapbox.geojson.Point
 import com.mapbox.services.android.navigation.v5.utils.extensions.getUnitTypeForLocale
 import com.mapbox.services.android.navigation.v5.utils.extensions.inferDeviceLocale
 import java.util.Locale
+import kotlin.collections.ArrayList
 import okhttp3.EventListener
 import okhttp3.Interceptor
 import retrofit2.Call
@@ -341,7 +342,7 @@ internal constructor(
          * @since 0.5.0
          */
         fun annotations(@DirectionsCriteria.AnnotationCriteria vararg annotations: String?): Builder {
-            directionsBuilder.annotations(*annotations)
+            directionsBuilder.annotations(listOf(*annotations))
             return this
         }
 
@@ -407,7 +408,12 @@ internal constructor(
          * @since 0.5.0
          */
         fun radiuses(@FloatRange(from = 0.0) vararg radiuses: Double): Builder {
-            directionsBuilder.radiuses(*radiuses)
+            val result = Array(radiuses.size) { 0.0 }
+            var index = 0
+            for (i in radiuses) {
+                result[index++] = i
+            }
+            directionsBuilder.radiuses(listOf(*result))
             return this
         }
 
@@ -496,7 +502,7 @@ internal constructor(
          * @since 0.15.0
          */
         fun addApproaches(vararg approaches: String?): Builder {
-            directionsBuilder.addApproaches(*approaches)
+            directionsBuilder.approaches(listOf(*approaches))
             return this
         }
 
@@ -518,7 +524,7 @@ internal constructor(
             for (i in indices) {
                 result[index++] = i
             }
-            directionsBuilder.addWaypointIndices(*result)
+            directionsBuilder.waypointIndices(listOf(*result))
             return this
         }
 
@@ -533,7 +539,7 @@ internal constructor(
          * @since 0.15.0
          */
         fun addWaypointNames(vararg waypointNames: String): Builder {
-            directionsBuilder.addWaypointNames(*waypointNames)
+            directionsBuilder.waypointNames(listOf(*waypointNames))
             return this
         }
 
@@ -553,7 +559,7 @@ internal constructor(
          * @since 0.26.0
          */
         fun addWaypointTargets(vararg waypointTargets: Point?): Builder {
-            directionsBuilder.addWaypointTargets(*waypointTargets)
+            directionsBuilder.waypointTargets(listOf(*waypointTargets))
             return this
         }
 
@@ -675,40 +681,24 @@ internal constructor(
                 directionsBuilder.accessToken(options.accessToken())
             }
 
-            if (!TextUtils.isEmpty(options.annotations())) {
-                directionsBuilder.annotations(options.annotations())
+            options.annotationsList()?.let {
+                directionsBuilder.annotations(it)
             }
 
-            options.approaches()?.let { approaches ->
-                if (approaches.isNotEmpty()) {
-                    val result =
-                        approaches.split(SEMICOLON.toRegex()).dropLastWhile { it.isEmpty() }
-                            .toTypedArray()
-                    directionsBuilder.addApproaches(*result)
-                }
+            options.approachesList()?.let {
+                directionsBuilder.approaches(it)
             }
 
-            options.waypointIndices()?.let { waypointIndices ->
-                if (waypointIndices.isNotEmpty()) {
-                    val splitWaypointIndices = parseWaypointIndices(waypointIndices)
-                    directionsBuilder.addWaypointIndices(*splitWaypointIndices)
-                }
+            options.waypointIndicesList()?.let {
+                directionsBuilder.waypointIndices(it)
             }
 
-            options.waypointNames()?.let { waypointNames ->
-                if (waypointNames.isNotEmpty()) {
-                    val names =
-                        waypointNames.split(SEMICOLON.toRegex()).dropLastWhile { it.isEmpty() }
-                            .toTypedArray()
-                    directionsBuilder.addWaypointNames(*names)
-                }
+            options.waypointNamesList()?.let {
+                directionsBuilder.waypointNames(it)
             }
 
-            options.waypointTargets()?.let { waypointTargets ->
-                if (waypointTargets.isNotEmpty()) {
-                    val splitWaypointTargets = parseWaypointTargets(waypointTargets)
-                    directionsBuilder.addWaypointTargets(*splitWaypointTargets)
-                }
+            options.waypointTargetsList()?.let {
+                directionsBuilder.waypointTargets(it)
             }
 
             val walkingOptions = options.walkingOptions()

diff --git a/...tions-offboard/src/main/java/com/mapbox/navigation/route/offboard/RouteBuilderProvider.kt b/...tions-offboard/src/main/java/com/mapbox/navigation/route/offboard/RouteBuilderProvider.kt
@@ -22,10 +22,8 @@ internal object RouteBuilderProvider {
             .geometries(DirectionsCriteria.GEOMETRY_POLYLINE6)
             .overview(DirectionsCriteria.OVERVIEW_FULL)
             .steps(true)
-            .annotations(
-                DirectionsCriteria.ANNOTATION_CONGESTION,
-                DirectionsCriteria.ANNOTATION_DISTANCE
-            )
+            .annotations(listOf(DirectionsCriteria.ANNOTATION_CONGESTION,
+                DirectionsCriteria.ANNOTATION_DISTANCE))
             .accessToken(accessToken)
             .voiceInstructions(true)
             .bannerInstructions(true)

diff --git a/...fboard/src/main/java/com/mapbox/navigation/route/offboard/router/MapboxDirectionsUtils.kt b/...fboard/src/main/java/com/mapbox/navigation/route/offboard/router/MapboxDirectionsUtils.kt
@@ -4,18 +4,12 @@ package com.mapbox.navigation.route.offboard.router
 
 import com.mapbox.api.directions.v5.MapboxDirections
 import com.mapbox.api.directions.v5.models.RouteOptions
-import com.mapbox.navigation.base.extensions.SEMICOLON
-import com.mapbox.navigation.base.extensions.checkFields
-import com.mapbox.navigation.base.extensions.convertToListOfDoubles
-import com.mapbox.navigation.base.extensions.convertToListOfPairsOfDoubles
-import com.mapbox.navigation.base.extensions.parseWaypointIndices
-import com.mapbox.navigation.base.extensions.parseWaypointTargets
 import java.util.Locale
 
 private val EVENT_LISTENER = NavigationRouteEventListener()
 
 fun MapboxDirections.Builder.routeOptions(options: RouteOptions): MapboxDirections.Builder {
-    options.checkFields()
+    check(options.coordinates().size >= 2) { "At least 2 coordinates should be provided." }
 
     baseUrl(options.baseUrl())
     user(options.user())
@@ -34,25 +28,12 @@ fun MapboxDirections.Builder.routeOptions(options: RouteOptions): MapboxDirectio
     options.language()?.let {
         language(Locale(it))
     }
-    options.radiuses()?.let { radiuses ->
-        if (radiuses.isNotEmpty()) {
-            radiuses.convertToListOfDoubles(SEMICOLON[0])?.toDoubleArray()?.let { result ->
-                radiuses(*result)
-            }
-        }
+    options.radiusesList()?.let {
+        radiuses(it)
     }
 
-    options.bearings()?.let { bearings ->
-        if (bearings.isNotEmpty()) {
-            bearings.convertToListOfPairsOfDoubles()
-                ?.forEach { pair ->
-                    if (pair != null) {
-                        addBearing(pair.first, pair.second)
-                    } else {
-                        addBearing(null, null)
-                    }
-                }
-        }
+    options.bearingsList()?.let { it ->
+        bearings(it)
     }
 
     continueStraight(options.continueStraight() ?: false)
@@ -68,7 +49,7 @@ fun MapboxDirections.Builder.routeOptions(options: RouteOptions): MapboxDirectio
 
     steps(options.steps() ?: true)
 
-    options.annotations()?.let {
+    options.annotationsList()?.let {
         annotations(it)
     }
 
@@ -89,36 +70,20 @@ fun MapboxDirections.Builder.routeOptions(options: RouteOptions): MapboxDirectio
         exclude(it)
     }
 
-    options.approaches()?.let { approaches ->
-        if (approaches.isNotEmpty()) {
-            val result =
-                approaches.split(SEMICOLON.toRegex()).dropLastWhile { it.isEmpty() }
-                    .toTypedArray()
-            addApproaches(*result)
-        }
+    options.approachesList()?.let { it ->
+        approaches(it)
     }
 
-    options.waypointIndices()?.let { waypointIndices ->
-        if (waypointIndices.isNotEmpty()) {
-            val splitWaypointIndices = parseWaypointIndices(waypointIndices)
-            addWaypointIndices(*splitWaypointIndices)
-        }
+    options.waypointIndicesList()?.let { it ->
+        waypointIndices(it)
     }
 
-    options.waypointNames()?.let { waypointNames ->
-        if (waypointNames.isNotEmpty()) {
-            val names =
-                waypointNames.split(SEMICOLON.toRegex()).dropLastWhile { it.isEmpty() }
-                    .toTypedArray()
-            addWaypointNames(*names)
-        }
+    options.waypointNamesList()?.let { it ->
+        waypointNames(it)
     }
 
-    options.waypointTargets()?.let { waypointTargets ->
-        if (waypointTargets.isNotEmpty()) {
-            val splitWaypointTargets = parseWaypointTargets(waypointTargets)
-            addWaypointTargets(*splitWaypointTargets)
-        }
+    options.waypointTargetsList()?.let { it ->
+        waypointTargets(it)
     }
 
     options.walkingOptions()?.let {

diff --git a/...offboard/src/test/java/com/mapbox/navigation/route/offboard/router/NavigationRouteTest.kt b/...offboard/src/test/java/com/mapbox/navigation/route/offboard/router/NavigationRouteTest.kt
@@ -6,7 +6,6 @@ import com.mapbox.api.directions.v5.WalkingOptions
 import com.mapbox.api.directions.v5.models.RouteOptions
 import com.mapbox.geojson.Point
 import com.mapbox.navigation.base.accounts.SkuTokenProvider
-import com.mapbox.navigation.base.extensions.bearings
 import com.mapbox.navigation.base.extensions.coordinates
 import com.mapbox.navigation.base.route.internal.RouteUrl
 import com.mapbox.navigation.route.offboard.RouteBuilderProvider
@@ -174,7 +173,7 @@ class NavigationRouteTest {
                         origin = Point.fromLngLat(1.0, 2.0),
                         destination = Point.fromLngLat(1.0, 5.0)
                     )
-                    .bearings(Pair(90.0, 90.0), null)
+                    .bearingsList(listOf(listOf(90.0, 90.0), listOf(null, null)))
                     .build()
             )
             .build()
@@ -195,7 +194,7 @@ class NavigationRouteTest {
                         listOf(Point.fromLngLat(3.0, 4.0), Point.fromLngLat(5.0, 6.0)),
                         Point.fromLngLat(7.0, 8.0)
                     )
-                    .bearings(Pair(10.0, 10.0), Pair(20.0, 20.0), Pair(30.0, 30.0), Pair(40.0, 40.0))
+                    .bearingsList(listOf(listOf(10.0, 10.0), listOf(20.0, 20.0), listOf(30.0, 30.0), listOf(40.0, 40.0)))
                     .build()
             )
             .build()

diff --git a/libnavigation-base/src/main/java/com/mapbox/navigation/base/extensions/RouteOptionsUtils.kt b/libnavigation-base/src/main/java/com/mapbox/navigation/base/extensions/RouteOptionsUtils.kt
@@ -6,74 +6,6 @@ import com.mapbox.api.directions.v5.models.RouteOptions
 import com.mapbox.geojson.Point
 import com.mapbox.navigation.base.route.internal.RouteUrl
 
-const val SEMICOLON = ";"
-const val COMMA = ","
-
-fun RouteOptions.checkFields() {
-    check(this.coordinates().size >= 2) { "At least 2 coordinates should be provided." }
-}
-
-fun String.convertToListOfDoubles(separator: Char = ';'): List<Double>? =
-    try {
-        this.split(separator).map { token ->
-            token.toDouble()
-        }
-    } catch (e: Exception) {
-        null
-    }
-
-fun String.convertToListOfPairsOfDoubles(
-    firstSeparator: Char = ';',
-    secondSeparator: Char = ','
-): List<Pair<Double, Double>?>? =
-    try {
-        val pairs = split(firstSeparator)
-        val result = mutableListOf<Pair<Double, Double>?>()
-        pairs.forEach { pair ->
-            val parts = pair.split(secondSeparator)
-            if (parts.size == 1) {
-                result.add(null)
-            } else {
-                result.add(Pair(parts[0].toDouble(), parts[1].toDouble()))
-            }
-        }
-        result.toList()
-    } catch (e: Exception) {
-        null
-    }
-
-fun parseWaypointIndices(waypointIndices: String): Array<Int> {
-    val splitWaypointIndices =
-        waypointIndices.split(SEMICOLON.toRegex()).dropLastWhile { it.isEmpty() }
-            .toTypedArray()
-    val indices = Array(splitWaypointIndices.size) { 0 }
-    for ((index, waypointIndex) in splitWaypointIndices.withIndex()) {
-        val parsedIndex = Integer.valueOf(waypointIndex)
-        indices[index] = parsedIndex
-    }
-    return indices
-}
-
-fun parseWaypointTargets(waypointTargets: String): Array<Point?> {
-    val splitWaypointTargets =
-        waypointTargets.split(SEMICOLON.toRegex()).dropLastWhile { it.isEmpty() }
-            .toTypedArray()
-    val waypoints = arrayOfNulls<Point>(splitWaypointTargets.size)
-    var index = 0
-    for (waypointTarget in splitWaypointTargets) {
-        val point = waypointTarget.split(COMMA.toRegex()).dropLastWhile { it.isEmpty() }
-            .toTypedArray()
-        if (waypointTarget.isEmpty()) {
-            waypoints[index++] = null
-        } else {
-            val longitude = point[0].toDouble()
-            val latitude = point[1].toDouble()
-            waypoints[index++] = Point.fromLngLat(longitude, latitude)
-        }
-    }
-    return waypoints
-}
-
 fun RouteOptions.Builder.applyDefaultParams(): RouteOptions.Builder = also {
     baseUrl(RouteUrl.BASE_URL)
     user(RouteUrl.PROFILE_DEFAULT_USER)
@@ -98,20 +30,3 @@ fun RouteOptions.Builder.coordinates(
 
     return this
 }
-
-fun RouteOptions.Builder.bearings(vararg pairs: Pair<Double, Double>?): RouteOptions.Builder {
-    val builder = StringBuilder()
-    pairs.forEachIndexed { index, pair ->
-        if (pair != null) {
-            builder.append("${pair.first},${pair.second}")
-        }
-
-        if (index != pairs.size - 1) {
-            builder.append(";")
-        }
-    }
-
-    bearings(builder.toString())
-
-    return this
-}