@jacques_gordon/expo-mapbox-navigation 2.1.0 → 2.1.1

package/android/src/main/java/expo/modules/mapboxnavigation/ExpoMapboxNavigationView.kt

@@ -58,6 +58,7 @@ import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.viewevent.EventDispatcher
 import expo.modules.kotlin.views.ExpoView
 import java.util.Calendar
+import java.util.Date
 import java.util.Locale
 
 private const val TAG = "ExpoMapboxNavigation"
@@ -65,7 +66,7 @@ private const val TAG = "ExpoMapboxNavigation"
 class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     ExpoView(context, appContext) {
 
-    // ── EventDispatchers (correct Expo Modules API for View events) ───────────
+    // ── EventDispatchers ──────────────────────────────────────────────────────
     private val onRouteProgressChanged by EventDispatcher()
     private val onRoutesReady by EventDispatcher()
     private val onNavigationFinished by EventDispatcher()
@@ -83,7 +84,7 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     private var tvDistance: TextView? = null
     private var etaBar: LinearLayout? = null
 
-    // ── Navigation APIs (from official TurnByTurnExperienceActivity) ──────────
+    // ── Navigation APIs ───────────────────────────────────────────────────────
     private lateinit var navigationCamera: NavigationCamera
     private lateinit var viewportDataSource: MapboxNavigationViewportDataSource
     private lateinit var routeLineApi: MapboxRouteLineApi
@@ -95,8 +96,6 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     private lateinit var routeArrowView: MapboxRouteArrowView
     private val navigationLocationProvider = NavigationLocationProvider()
     private var mapboxNavigation: MapboxNavigation? = null
-
-    // ── Night mode ────────────────────────────────────────────────────────────
     private var isNightMode = false
 
     // ── Props ─────────────────────────────────────────────────────────────────
@@ -121,7 +120,7 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // 1. Build programmatic UI
+    // Build UI
     // ─────────────────────────────────────────────────────────────────────────
     private fun buildUI() {
         val dp = context.resources.displayMetrics.density
@@ -129,41 +128,37 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
         }
 
-        // Full-screen MapView
         root.addView(mapView, FrameLayout.LayoutParams(
             FrameLayout.LayoutParams.MATCH_PARENT,
             FrameLayout.LayoutParams.MATCH_PARENT
         ))
 
-        // ManeuverView — top banner
-        // NOTE: MapboxManeuverView extends ConstraintLayout, cast to View for addView()
+        // ManeuverView — top (cast to View: extends ConstraintLayout)
         val mv = MapboxManeuverView(context)
-        val mvParams = FrameLayout.LayoutParams(
+        root.addView(mv as View, FrameLayout.LayoutParams(
             FrameLayout.LayoutParams.MATCH_PARENT,
             FrameLayout.LayoutParams.WRAP_CONTENT
-        )
-        mvParams.gravity = Gravity.TOP
-        mv.visibility = View.INVISIBLE  // matches official example (INVISIBLE not GONE)
-        root.addView(mv as View, mvParams)
+        ).also { it.gravity = Gravity.TOP })
+        mv.visibility = View.INVISIBLE
         maneuverView = mv
 
-        // SpeedInfoView — bottom-left
+        // SpeedInfoView — bottom-left (cast to View)
         val siv = MapboxSpeedInfoView(context)
-        val sivParams = FrameLayout.LayoutParams(
+        root.addView(siv as View, FrameLayout.LayoutParams(
             FrameLayout.LayoutParams.WRAP_CONTENT,
             FrameLayout.LayoutParams.WRAP_CONTENT
-        )
-        sivParams.gravity = Gravity.BOTTOM or Gravity.START
-        sivParams.setMargins((16 * dp).toInt(), 0, 0, (100 * dp).toInt())
+        ).also {
+            it.gravity = Gravity.BOTTOM or Gravity.START
+            it.setMargins((16 * dp).toInt(), 0, 0, (100 * dp).toInt())
+        })
         siv.visibility = View.GONE
-        root.addView(siv as View, sivParams)
         speedInfoView = siv
 
-        // TripProgressView — embedded in bottom bar
+        // TripProgressView (used by the official Mapbox render method)
         val tpv = MapboxTripProgressView(context)
         tripProgressView = tpv
 
-        // ETA bottom bar
+        // Bottom ETA bar
         val bar = LinearLayout(context).apply {
             orientation = LinearLayout.HORIZONTAL
             setBackgroundColor(Color.WHITE)
@@ -175,11 +170,9 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
                 (16 * dp).toInt(), (8 * dp).toInt()
             )
         }
-        val barParams = FrameLayout.LayoutParams(
-            FrameLayout.LayoutParams.MATCH_PARENT,
-            (80 * dp).toInt()
-        )
-        barParams.gravity = Gravity.BOTTOM
+        root.addView(bar, FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT, (80 * dp).toInt()
+        ).also { it.gravity = Gravity.BOTTOM })
 
         val etaTime = TextView(context).apply {
             textSize = 22f
@@ -193,8 +186,12 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             orientation = LinearLayout.VERTICAL
             gravity = Gravity.CENTER
         }
-        val dur = TextView(context).apply { textSize = 16f; setTextColor(Color.DKGRAY); gravity = Gravity.CENTER }
-        val dist = TextView(context).apply { textSize = 13f; setTextColor(Color.GRAY); gravity = Gravity.CENTER }
+        val dur = TextView(context).apply {
+            textSize = 16f; setTextColor(Color.DKGRAY); gravity = Gravity.CENTER
+        }
+        val dist = TextView(context).apply {
+            textSize = 13f; setTextColor(Color.GRAY); gravity = Gravity.CENTER
+        }
         center.addView(dur)
         center.addView(dist)
         bar.addView(center, LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 2f))
@@ -202,35 +199,30 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         tvDistance = dist
 
         val cancelBtn = TextView(context).apply {
-            text = "✕"
-            textSize = 22f
-            setTextColor(Color.DKGRAY)
+            text = "✕"; textSize = 22f; setTextColor(Color.DKGRAY)
             gravity = Gravity.END or Gravity.CENTER_VERTICAL
             setOnClickListener { cancelNavigation() }
         }
         bar.addView(cancelBtn, LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f))
         etaBar = bar
-        root.addView(bar, barParams)
 
         addView(root)
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // 2. Init APIs (from official example — exact same pattern)
+    // Init APIs — confirmed from official Mapbox examples
     // ─────────────────────────────────────────────────────────────────────────
     private fun initAPIs() {
         val distanceFormatterOptions = DistanceFormatterOptions.Builder(context).build()
 
-        // EXACT same instantiation as TurnByTurnExperienceActivity
-        maneuverApi = MapboxManeuverApi(
-            MapboxDistanceFormatter(distanceFormatterOptions)
-        )
+        maneuverApi = MapboxManeuverApi(MapboxDistanceFormatter(distanceFormatterOptions))
 
+        // TripProgressApi — from ShowTripProgressActivity official example
+        // PercentDistanceTraveledFormatter is optional — omit if causing issues
         tripProgressApi = MapboxTripProgressApi(
             TripProgressUpdateFormatter.Builder(context)
                 .distanceRemainingFormatter(DistanceRemainingFormatter(distanceFormatterOptions))
                 .timeRemainingFormatter(TimeRemainingFormatter(context))
-                .percentRouteTraveledFormatter(PercentDistanceTraveledFormatter())
                 .estimatedTimeToArrivalFormatter(
                     EstimatedTimeToArrivalFormatter(context, TimeFormat.NONE_SPECIFIED)
                 )
@@ -239,31 +231,27 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
 
         speedInfoApi = MapboxSpeedInfoApi()
 
-        val routeLineViewOptions = MapboxRouteLineViewOptions.Builder(context)
-            .routeLineBelowLayerId("road-label-navigation")
-            .build()
         routeLineApi = MapboxRouteLineApi(MapboxRouteLineApiOptions.Builder().build())
-        routeLineView = MapboxRouteLineView(routeLineViewOptions)
+        routeLineView = MapboxRouteLineView(
+            MapboxRouteLineViewOptions.Builder(context)
+                .routeLineBelowLayerId("road-label-navigation")
+                .build()
+        )
 
-        val routeArrowOptions = RouteArrowOptions.Builder(context).build()
-        routeArrowView = MapboxRouteArrowView(routeArrowOptions)
+        routeArrowView = MapboxRouteArrowView(RouteArrowOptions.Builder(context).build())
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // 3. Setup Navigation
+    // Setup Navigation
     // ─────────────────────────────────────────────────────────────────────────
     private fun setupNavigation() {
         mapboxNavigation = MapboxNavigationProvider.create(
             NavigationOptions.Builder(context).build()
         )
 
-        val style = mapStyle ?: getAutoStyle()
-        mapView.mapboxMap.loadStyle(style) { mapStyle ->
-
-            // Route line layers must be initialized first
-            routeLineView.initializeLayers(mapStyle)
+        mapView.mapboxMap.loadStyle(mapStyle ?: getAutoStyle()) { style ->
+            routeLineView.initializeLayers(style)
 
-            // Camera setup — EXACT same as official example
             viewportDataSource = MapboxNavigationViewportDataSource(mapView.mapboxMap)
             navigationCamera = NavigationCamera(
                 mapView.mapboxMap,
@@ -271,7 +259,6 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
                 viewportDataSource
             )
 
-            // Location puck
             mapView.location.apply {
                 setLocationProvider(navigationLocationProvider)
                 enabled = true
@@ -282,38 +269,30 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // 4. Observers — based 100% on official TurnByTurnExperienceActivity
+    // Observers
     // ─────────────────────────────────────────────────────────────────────────
     private fun registerObservers() {
         val nav = mapboxNavigation ?: return
 
-        // ── Routes observer ───────────────────────────────────────────────────
+        // Routes observer
         nav.registerRoutesObserver(object : RoutesObserver {
             override fun onRoutesChanged(result: RoutesUpdatedResult) {
                 if (result.navigationRoutes.isNotEmpty()) {
-                    // Draw route line
                     routeLineApi.setNavigationRoutes(result.navigationRoutes) { value ->
                         mapView.mapboxMap.style?.apply {
                             routeLineView.renderRouteDrawData(this, value)
                         }
                     }
-                    // Update camera viewport
                     viewportDataSource.onRouteChanged(result.navigationRoutes.first())
                     viewportDataSource.evaluate()
-
-                    // Show navigation UI
-                    maneuverView?.visibility = View.VISIBLE
-                    etaBar?.visibility = View.VISIBLE
-
+                    showUI()
                     onRoutesReady(mapOf(
                         "routeCount" to result.navigationRoutes.size,
                         "distanceMeters" to (result.navigationRoutes.first().directionsRoute.distance() ?: 0.0),
                         "durationSeconds" to (result.navigationRoutes.first().directionsRoute.duration() ?: 0.0)
                     ))
                 } else {
-                    // Clear route line
-                    val style = mapView.mapboxMap.style
-                    if (style != null) {
+                    mapView.mapboxMap.style?.let { style ->
                         routeLineApi.clearRouteLine { value ->
                             routeLineView.renderClearRouteLineValue(style, value)
                         }
@@ -326,39 +305,48 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             }
         })
 
-        // ── Route progress observer ───────────────────────────────────────────
-        // EXACT same pattern as TurnByTurnExperienceActivity.routeProgressObserver
+        // Route progress observer
         nav.registerRouteProgressObserver(RouteProgressObserver { routeProgress ->
-            // Update camera
             viewportDataSource.onRouteProgressChanged(routeProgress)
             viewportDataSource.evaluate()
 
-            // Draw maneuver arrow
-            val style = mapView.mapboxMap.style
-            if (style != null) {
-                val maneuverArrowResult = routeArrowApi.addUpcomingManeuverArrow(routeProgress)
-                routeArrowView.renderManeuverUpdate(style, maneuverArrowResult)
+            // Route arrow
+            mapView.mapboxMap.style?.let { style ->
+                val arrowResult = routeArrowApi.addUpcomingManeuverArrow(routeProgress)
+                routeArrowView.renderManeuverUpdate(style, arrowResult)
             }
 
-            // Maneuver banner — EXACT same fold() pattern as official example
+            // ── Maneuver — fold() with explicit Unit returns on both branches ──
+            // Fix for error: "Argument type mismatch: Unit? but R & Any expected"
+            // Solution: use explicit return type annotation on the success lambda
             val maneuvers = maneuverApi.getManeuvers(routeProgress)
             maneuvers.fold(
-                { error -> Log.w(TAG, "Maneuver error: ${error.errorMessage}") },
-                {
+                { error ->
+                    Log.w(TAG, "Maneuver error: ${error.errorMessage}")
+                    Unit
+                },
+                { _ ->
                     maneuverView?.visibility = View.VISIBLE
                     maneuverView?.renderManeuvers(maneuvers)
+                    Unit
                 }
             )
 
-            // Trip progress — EXACT same as official example
-            // getTripProgress returns TripProgressUpdateValue directly (not nullable)
+            // ── Trip progress — use getTripProgress exactly as official example ──
+            // render() to the MapboxTripProgressView (official pattern)
+            // For our custom ETA bar, use the raw fields from TripProgressUpdateValue:
+            //   .estimatedTimeToArrival — Long (Unix timestamp ms of arrival)
+            //   .currentLegTimeRemaining — Double (seconds remaining for current leg)
+            //   .totalTimeRemaining — Double (seconds remaining total)
+            //   .distanceRemaining — Double (metres remaining)
             val tripProgress = tripProgressApi.getTripProgress(routeProgress)
             tripProgressView?.render(tripProgress)
+            updateEtaBar(
+                tripProgress.estimatedTimeToArrival,
+                tripProgress.totalTimeRemaining,
+                tripProgress.distanceRemaining
+            )
 
-            // Update our custom ETA bar from tripProgress fields
-            updateEtaBar(tripProgress)
-
-            // Emit event
             onRouteProgressChanged(mapOf(
                 "distanceRemaining" to routeProgress.distanceRemaining,
                 "durationRemaining" to routeProgress.durationRemaining,
@@ -370,30 +358,21 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             ))
         })
 
-        // ── Location observer ─────────────────────────────────────────────────
-        // EXACT same as official example
+        // Location observer
         nav.registerLocationObserver(object : LocationObserver {
             override fun onNewRawLocation(rawLocation: Location) {}
-
-            override fun onNewLocationMatcherResult(locationMatcherResult: LocationMatcherResult) {
-                val enhancedLocation = locationMatcherResult.enhancedLocation
-
-                // Update location puck
+            override fun onNewLocationMatcherResult(result: LocationMatcherResult) {
+                val loc = result.enhancedLocation
                 navigationLocationProvider.changePosition(
-                    location = enhancedLocation,
-                    keyPoints = locationMatcherResult.keyPoints,
+                    location = loc,
+                    keyPoints = result.keyPoints,
                 )
-
-                // Update camera
-                viewportDataSource.onLocationChanged(enhancedLocation)
+                viewportDataSource.onLocationChanged(loc)
                 viewportDataSource.evaluate()
 
-                // Speed limit display
-                val formatterOptions = DistanceFormatterOptions.Builder(context).build()
-                val speedInfo = speedInfoApi.updatePostedAndCurrentSpeed(
-                    locationMatcherResult,
-                    formatterOptions
-                )
+                // Speed limit
+                val fmtOptions = DistanceFormatterOptions.Builder(context).build()
+                val speedInfo = speedInfoApi.updatePostedAndCurrentSpeed(result, fmtOptions)
                 if (speedInfo != null) {
                     speedInfoView?.visibility = View.VISIBLE
                     speedInfoView?.render(speedInfo)
@@ -401,45 +380,48 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
                     speedInfoView?.visibility = View.GONE
                 }
 
-                // Auto day/night switch
                 checkAndSwitchDayNight()
             }
         })
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // 5. ETA bar update
-    // TripProgressUpdateValue fields confirmed from official tripdata API
+    // ETA bar — using confirmed TripProgressUpdateValue fields
+    // estimatedTimeToArrival: Long — Unix timestamp (ms) of expected arrival
+    // totalTimeRemaining: Double — seconds remaining
+    // distanceRemaining: Double — metres remaining
     // ─────────────────────────────────────────────────────────────────────────
-    private fun updateEtaBar(tripProgress: com.mapbox.navigation.tripdata.progress.model.TripProgressUpdateValue) {
-        // ETA arrival time
-        val etaSec = tripProgress.formatter.timeRemainingFormatter
-            .formatTime(tripProgress).toString()
-        // Calculate arrival clock time
-        val totalSec = tripProgress.totalTimeRemaining.toLong()
-        val cal = Calendar.getInstance().apply { add(Calendar.SECOND, totalSec.toInt()) }
-        tvEtaTime?.text = String.format("%02d:%02d",
-            cal.get(Calendar.HOUR_OF_DAY),
-            cal.get(Calendar.MINUTE)
+    private fun updateEtaBar(
+        estimatedTimeToArrivalMs: Long,
+        totalTimeRemainingSec: Double,
+        distanceRemainingMetres: Double
+    ) {
+        // Arrival clock time from Unix timestamp
+        val arrivalCal = Calendar.getInstance().apply {
+            timeInMillis = estimatedTimeToArrivalMs
+        }
+        tvEtaTime?.text = String.format(
+            "%02d:%02d",
+            arrivalCal.get(Calendar.HOUR_OF_DAY),
+            arrivalCal.get(Calendar.MINUTE)
         )
 
         // Duration remaining
-        val totalMin = (tripProgress.totalTimeRemaining / 60).toInt()
+        val totalMin = (totalTimeRemainingSec / 60).toInt()
         tvDuration?.text = if (totalMin >= 60)
             "${totalMin / 60}h ${totalMin % 60}min"
         else
             "${totalMin} min"
 
         // Distance remaining
-        val distM = tripProgress.distanceRemaining
-        tvDistance?.text = if (distM >= 1000)
-            String.format("%.1f km", distM / 1000.0)
+        tvDistance?.text = if (distanceRemainingMetres >= 1000)
+            String.format("%.1f km", distanceRemainingMetres / 1000.0)
         else
-            "${distM.toInt()} m"
+            "${distanceRemainingMetres.toInt()} m"
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // 6. Day / Night auto switch
+    // Day / Night
     // ─────────────────────────────────────────────────────────────────────────
     private fun getAutoStyle(): String {
         val hour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY)
@@ -452,10 +434,8 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         val shouldBeNight = hour !in 6..20
         if (shouldBeNight == isNightMode) return
         isNightMode = shouldBeNight
-
         val newStyle = if (shouldBeNight) NavigationStyles.NAVIGATION_NIGHT_STYLE
         else NavigationStyles.NAVIGATION_DAY_STYLE
-
         mapView.mapboxMap.loadStyle(newStyle) { style ->
             routeLineView.initializeLayers(style)
             mapboxNavigation?.getNavigationRoutes()?.takeIf { it.isNotEmpty() }?.let { routes ->
@@ -464,10 +444,7 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
                 }
             }
         }
-
-        etaBar?.setBackgroundColor(
-            if (shouldBeNight) Color.parseColor("#1E2433") else Color.WHITE
-        )
+        etaBar?.setBackgroundColor(if (shouldBeNight) Color.parseColor("#1E2433") else Color.WHITE)
         val tc = if (shouldBeNight) Color.WHITE else Color.BLACK
         tvEtaTime?.setTextColor(tc)
         tvDuration?.setTextColor(if (shouldBeNight) Color.LTGRAY else Color.DKGRAY)
@@ -475,7 +452,7 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // 7. Cancel navigation
+    // Cancel navigation
     // ─────────────────────────────────────────────────────────────────────────
     private fun cancelNavigation() {
         mapboxNavigation?.setNavigationRoutes(listOf())
@@ -484,30 +461,30 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         onNavigationCancelled(mapOf<String, Any>())
     }
 
+    private fun showUI() {
+        maneuverView?.visibility = View.VISIBLE
+        etaBar?.visibility = View.VISIBLE
+    }
+
     private fun hideUI() {
         maneuverView?.visibility = View.INVISIBLE
         speedInfoView?.visibility = View.GONE
         etaBar?.visibility = View.INVISIBLE
     }
 
-    // ─────────────────────────────────────────────────────────────────────────
-    // 8. Issue #43 — safe camera following
-    // ─────────────────────────────────────────────────────────────────────────
+    // Issue #43
     private fun safeCameraFollowing() {
         try {
             navigationCamera.requestNavigationCameraToFollowing(
                 stateTransitionOptions = NavigationCameraTransitionOptions.Builder()
-                    .maxDuration(0)
-                    .build()
+                    .maxDuration(0).build()
             )
         } catch (e: Exception) {
-            Log.e(TAG, "Camera transition error: ${e.message}")
+            Log.e(TAG, "Camera error: ${e.message}")
         }
     }
 
-    // ─────────────────────────────────────────────────────────────────────────
-    // 9. Issue #31 — Voice units
-    // ─────────────────────────────────────────────────────────────────────────
+    // Issue #31
     private fun resolveVoiceUnits(): String {
         return when (voiceUnits?.lowercase()) {
             "metric" -> "metric"
@@ -519,71 +496,44 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         }
     }
 
-    // ─────────────────────────────────────────────────────────────────────────
-    // 10. Route request
-    // ─────────────────────────────────────────────────────────────────────────
+    // Route request
     @SuppressLint("MissingPermission")
     private fun fetchRoutes() {
         val nav = mapboxNavigation ?: return
         if (coordinates.size < 2) return
-
-        val points = coordinates.map { coord ->
-            Point.fromLngLat(coord["longitude"] ?: 0.0, coord["latitude"] ?: 0.0)
-        }
+        val points = coordinates.map { Point.fromLngLat(it["longitude"] ?: 0.0, it["latitude"] ?: 0.0) }
         val locale = language?.let { Locale.forLanguageTag(it) } ?: Locale.getDefault()
-
         val builder = RouteOptions.builder()
             .applyDefaultNavigationOptions()
             .language(locale.toLanguageTag())
             .voiceUnits(resolveVoiceUnits())
             .coordinatesList(points)
             .annotations("maxspeed,congestion,duration")
-
         waypointIndices?.let { builder.waypointIndicesList(it) }
-        navigationProfile?.let {
-            builder.profile(if (it.startsWith("mapbox/")) it else "mapbox/$it")
-        }
+        navigationProfile?.let { builder.profile(if (it.startsWith("mapbox/")) it else "mapbox/$it") }
         excludeTypes?.takeIf { it.isNotEmpty() }?.let { builder.exclude(it.joinToString(",")) }
         maxHeight?.let { builder.maxHeight(it) }
         maxWidth?.let { builder.maxWidth(it) }
-
-        nav.requestRoutes(
-            builder.build(),
-            object : NavigationRouterCallback {
-                override fun onRoutesReady(
-                    routes: List<NavigationRoute>,
-                    @RouterOrigin routerOrigin: String
-                ) {
-                    if (routes.isEmpty()) {
-                        onRoutesFailed(mapOf("message" to "No routes returned"))
-                        return
-                    }
-                    nav.setNavigationRoutes(routes)
-                    nav.startTripSession()
-                    safeCameraFollowing()
-                }
-
-                override fun onFailure(reasons: List<RouterFailure>, routeOptions: RouteOptions) {
-                    val msg = reasons.firstOrNull()?.message ?: "Unknown error"
-                    Log.e(TAG, "Route request failed: $msg")
-                    onRoutesFailed(mapOf("message" to msg))
-                }
-
-                override fun onCanceled(
-                    routeOptions: RouteOptions,
-                    @RouterOrigin routerOrigin: String
-                ) {
-                    Log.d(TAG, "Route request cancelled")
-                }
+        nav.requestRoutes(builder.build(), object : NavigationRouterCallback {
+            override fun onRoutesReady(routes: List<NavigationRoute>, @RouterOrigin routerOrigin: String) {
+                if (routes.isEmpty()) { onRoutesFailed(mapOf("message" to "No routes returned")); return }
+                nav.setNavigationRoutes(routes)
+                nav.startTripSession()
+                safeCameraFollowing()
             }
-        )
+            override fun onFailure(reasons: List<RouterFailure>, routeOptions: RouteOptions) {
+                val msg = reasons.firstOrNull()?.message ?: "Unknown error"
+                Log.e(TAG, "Route failed: $msg")
+                onRoutesFailed(mapOf("message" to msg))
+            }
+            override fun onCanceled(routeOptions: RouteOptions, @RouterOrigin routerOrigin: String) {
+                Log.d(TAG, "Route cancelled")
+            }
+        })
     }
 
-    // ── Prop setters ──────────────────────────────────────────────────────────
-    fun setCoordinates(coords: List<Map<String, Double>>) {
-        coordinates = coords
-        if (coords.size >= 2) fetchRoutes()
-    }
+    // Prop setters
+    fun setCoordinates(coords: List<Map<String, Double>>) { coordinates = coords; if (coords.size >= 2) fetchRoutes() }
     fun setWaypointIndices(indices: List<Int>?) { waypointIndices = indices }
     fun setLanguage(lang: String?) { language = lang }
     fun setVoiceUnits(units: String?) { voiceUnits = units }
@@ -597,7 +547,6 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     fun setCustomRasterTileUrl(url: String?) { customRasterTileUrl = url }
     fun setCustomRasterAboveLayerId(layerId: String?) { customRasterAboveLayerId = layerId }
 
-    // ── Lifecycle ─────────────────────────────────────────────────────────────
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
         maneuverApi.cancel()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacques_gordon/expo-mapbox-navigation",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "Expo module for Mapbox Navigation SDK with 16KB page size support, NDK27, and Mapbox Maps v11.11.0+",
   "main": "build/index.js",
   "types": "build/index.d.ts",