bump mapbox-sdk to 8b7e0db

GitOrigin-RevId: ec7e5d4d733bf705a26a82ea5772d287f9b9dac7

Author: dzinad

gradle/dependencies.gradle

@@ -8,7 +8,7 @@ ext {
       carMinSdkVersion        : 23
   ]
 
-  def mapboxSdkVersionSuffix = '14.0-beta.1'
+  def mapboxSdkVersionSuffix = '15.0-SNAPSHOT-07-11--04-32.git-8b7e0db'
 
   def ndkVersionSuffix = ""
   if (project.hasProperty("ndkMajor")) {
@@ -34,7 +34,7 @@ ext {
       mapboxNavigator           : "${mapboxNavigatorVersion}",
       mapboxCommonNative        : "24.${mapboxSdkVersionSuffix}",
       mapboxNavSdkCpp           : "0.${mapboxSdkVersionSuffix}",
-      mapboxSearch              : '2.14.0-beta.1',
+      mapboxSearch              : '2.15.0-8b7e0db-SNAPSHOT',
       mapboxBaseAndroid         : '0.11.0',
       androidXActivity          : '1.7.1',
       androidXActivityCompose   : '1.9.2',

navigation/src/main/java/com/mapbox/navigation/core/adas/AdasEdgeAttributes.kt

@@ -1,5 +1,6 @@
 package com.mapbox.navigation.core.adas
 
+import androidx.annotation.IntDef
 import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
 
 /**
@@ -14,13 +15,18 @@ import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
  * Position is a shape index, where integer part in an index of geometry segment is
  * and fractional part is a position on the segment
  * @param isDividedRoad A flag indicating if the edge is a divided road
+ * @param formOfWay Form Of Way information from ADAS tiles, may differ from the Valhalla value, but should be used for ADAS purposes.
+ *  See [FormOfWay.Type]. If not set, then the value is not known
+ * @param etc2 Road class in ETC2.0 format (Japan specific), see [Etc2Road.Type]
  */
 @ExperimentalPreviewMapboxNavigationAPI
 class AdasEdgeAttributes private constructor(
     val speedLimit: List<AdasSpeedLimitInfo>,
     val slopes: List<AdasValueOnEdge>,
     val curvatures: List<AdasValueOnEdge>,
     val isDividedRoad: Boolean?,
+    @FormOfWay.Type val formOfWay: Int?,
+    @Etc2Road.Type val etc2: Int,
 ) {
 
     /**
@@ -35,7 +41,10 @@ class AdasEdgeAttributes private constructor(
         if (speedLimit != other.speedLimit) return false
         if (slopes != other.slopes) return false
         if (curvatures != other.curvatures) return false
-        return isDividedRoad == other.isDividedRoad
+        if (isDividedRoad != other.isDividedRoad) return false
+        if (formOfWay != other.formOfWay) return false
+        if (etc2 != other.etc2) return false
+        return true
     }
 
     /**
@@ -46,6 +55,8 @@ class AdasEdgeAttributes private constructor(
         result = 31 * result + slopes.hashCode()
         result = 31 * result + curvatures.hashCode()
         result = 31 * result + isDividedRoad.hashCode()
+        result = 31 * result + formOfWay.hashCode()
+        result = 31 * result + etc2.hashCode()
         return result
     }
 
@@ -57,10 +68,195 @@ class AdasEdgeAttributes private constructor(
             "speedLimit=$speedLimit, " +
             "slopes=$slopes, " +
             "curvatures=$curvatures, " +
-            "isDividedRoad=$isDividedRoad" +
+            "isDividedRoad=$isDividedRoad, " +
+            "formOfWay=$formOfWay, " +
+            "etc2=$etc2" +
             ")"
     }
 
+    /**
+     * Form of way type.
+     */
+    object FormOfWay {
+
+        /**
+         * Unknown form of way.
+         */
+        const val UNKNOWN = 0
+
+        /**
+         * Freeway form of way.
+         */
+        const val FREEWAY = 1
+
+        /**
+         * Multiple carriageway form of way.
+         */
+        const val MULTIPLE_CARRIAGEWAY = 2
+
+        /**
+         * Single carriageway form of way.
+         */
+        const val SINGLE_CARRIAGEWAY = 3
+
+        /**
+         * Roundabout circle form of way.
+         */
+        const val ROUNDABOUT_CIRCLE = 4
+
+        /**
+         * Traffic square form of way.
+         */
+        const val TRAFFIC_SQUARE = 5
+
+        /**
+         * Slip road form of way.
+         */
+        const val SLIP_ROAD = 6
+
+        /**
+         * Parallel road form of way.
+         */
+        const val PARALLEL_ROAD = 7
+
+        /**
+         * Ramp on freeway form of way.
+         */
+        const val RAMP_ON_FREEWAY = 8
+
+        /**
+         * Ramp form of way.
+         */
+        const val RAMP = 9
+
+        /**
+         * Service road form of way.
+         */
+        const val SERVICE_ROAD = 10
+
+        /**
+         * Car park entrance form of way.
+         */
+        const val CAR_PARK_ENTRANCE = 11
+
+        /**
+         * Service entrance form of way.
+         */
+        const val SERVICE_ENTRANCE = 12
+
+        /**
+         * Pedestrian zone form of way.
+         */
+        const val PEDESTRIAN_ZONE = 13
+
+        /**
+         * Form of way is not applicable.
+         */
+        const val NA = 14
+
+        /**
+         * Retention policy for [FormOfWay].
+         */
+        @Retention(AnnotationRetention.BINARY)
+        @IntDef(
+            UNKNOWN,
+            FREEWAY,
+            MULTIPLE_CARRIAGEWAY,
+            SINGLE_CARRIAGEWAY,
+            ROUNDABOUT_CIRCLE,
+            TRAFFIC_SQUARE,
+            SLIP_ROAD,
+            PARALLEL_ROAD,
+            RAMP_ON_FREEWAY,
+            RAMP,
+            SERVICE_ROAD,
+            CAR_PARK_ENTRANCE,
+            SERVICE_ENTRANCE,
+            PEDESTRIAN_ZONE,
+            NA,
+        )
+        annotation class Type
+
+        @Type
+        @JvmSynthetic
+        internal fun createFromNativeObject(nativeObj: com.mapbox.navigator.FormOfWay): Int =
+            when (nativeObj) {
+                com.mapbox.navigator.FormOfWay.FREEWAY -> FREEWAY
+                com.mapbox.navigator.FormOfWay.MULTIPLE_CARRIAGEWAY -> MULTIPLE_CARRIAGEWAY
+                com.mapbox.navigator.FormOfWay.SINGLE_CARRIAGEWAY -> SINGLE_CARRIAGEWAY
+                com.mapbox.navigator.FormOfWay.ROUNDABOUT_CIRCLE -> ROUNDABOUT_CIRCLE
+                com.mapbox.navigator.FormOfWay.TRAFFIC_SQUARE -> TRAFFIC_SQUARE
+                com.mapbox.navigator.FormOfWay.SLIP_ROAD -> SLIP_ROAD
+                com.mapbox.navigator.FormOfWay.PARALLEL_ROAD -> PARALLEL_ROAD
+                com.mapbox.navigator.FormOfWay.RAMP_ON_FREEWAY -> RAMP_ON_FREEWAY
+                com.mapbox.navigator.FormOfWay.RAMP -> RAMP
+                com.mapbox.navigator.FormOfWay.SERVICE_ROAD -> SERVICE_ROAD
+                com.mapbox.navigator.FormOfWay.CAR_PARK_ENTRANCE -> CAR_PARK_ENTRANCE
+                com.mapbox.navigator.FormOfWay.SERVICE_ENTRANCE -> SERVICE_ENTRANCE
+                com.mapbox.navigator.FormOfWay.PEDESTRIAN_ZONE -> PEDESTRIAN_ZONE
+                com.mapbox.navigator.FormOfWay.NA -> NA
+                com.mapbox.navigator.FormOfWay.UNKNOWN -> UNKNOWN
+            }
+    }
+
+    /**
+     * ETC2 road type.
+     */
+    object Etc2Road {
+
+        /**
+         * Unknown ETC2 road type.
+         */
+        const val UNKNOWN = 0
+
+        /**
+         * Highway ETC2 road type.
+         */
+        const val HIGHWAY = 1
+
+        /**
+         * City highway ETC2 road type.
+         */
+        const val CITY_HIGHWAY = 2
+
+        /**
+         * Normal road ETC2 road type.
+         */
+        const val NORMAL_ROAD = 3
+
+        /**
+         * Other ETC2 road type.
+         */
+        const val OTHER = 4
+
+        /**
+         * Retention policy for the [Etc2Road.Type].
+         */
+        @Retention(AnnotationRetention.BINARY)
+        @IntDef(
+            UNKNOWN,
+            HIGHWAY,
+            CITY_HIGHWAY,
+            NORMAL_ROAD,
+            OTHER,
+        )
+        annotation class Type
+
+        @Type
+        @JvmSynthetic
+        internal fun createFromNativeObject(
+            nativeObj: com.mapbox.navigator.ETC2RoadType,
+        ): Int {
+            return when (nativeObj) {
+                com.mapbox.navigator.ETC2RoadType.HIGHWAY -> HIGHWAY
+                com.mapbox.navigator.ETC2RoadType.CITY_HIGHWAY -> CITY_HIGHWAY
+                com.mapbox.navigator.ETC2RoadType.NORMAL_ROAD -> NORMAL_ROAD
+                com.mapbox.navigator.ETC2RoadType.OTHER -> OTHER
+                com.mapbox.navigator.ETC2RoadType.UNKNOWN -> UNKNOWN
+            }
+        }
+    }
+
     internal companion object {
 
         @JvmSynthetic
@@ -76,6 +272,8 @@ class AdasEdgeAttributes private constructor(
                     AdasValueOnEdge.createFromNativeObject(it)
                 },
                 isDividedRoad = nativeObj.isDividedRoad,
+                formOfWay = nativeObj.formOfWay?.let { FormOfWay.createFromNativeObject(it) },
+                etc2 = Etc2Road.createFromNativeObject(nativeObj.etc2),
             )
     }
 }

navigation/src/test/java/com/mapbox/navigation/core/adas/AdasEdgeAttributesTest.kt

@@ -25,6 +25,8 @@ class AdasEdgeAttributesTest {
             listOf(AdasTypeFactory.NATIVE_VALUE_ON_EDGE_1),
             listOf(AdasTypeFactory.NATIVE_VALUE_ON_EDGE_2),
             true,
+            com.mapbox.navigator.FormOfWay.CAR_PARK_ENTRANCE,
+            com.mapbox.navigator.ETC2RoadType.HIGHWAY,
         )
 
         val platform = AdasEdgeAttributes.createFromNativeObject(native)
@@ -33,5 +35,7 @@ class AdasEdgeAttributesTest {
         assertEquals(listOf(AdasTypeFactory.VALUE_ON_EDGE_1), platform.slopes)
         assertEquals(listOf(AdasTypeFactory.VALUE_ON_EDGE_2), platform.curvatures)
         assertEquals(true, platform.isDividedRoad)
+        assertEquals(AdasEdgeAttributes.FormOfWay.CAR_PARK_ENTRANCE, platform.formOfWay)
+        assertEquals(AdasEdgeAttributes.Etc2Road.HIGHWAY, platform.etc2)
     }
 }