@jacques_gordon/expo-mapbox-navigation 2.1.1 → 2.1.3

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

@@ -2,19 +2,27 @@ package expo.modules.mapboxnavigation
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.content.res.Resources
 import android.graphics.Color
+import android.graphics.drawable.GradientDrawable
 import android.util.Log
 import android.view.Gravity
 import android.view.View
 import android.widget.FrameLayout
+import android.widget.ImageView
 import android.widget.LinearLayout
 import android.widget.TextView
 import com.mapbox.api.directions.v5.models.RouteOptions
 import com.mapbox.common.location.Location
 import com.mapbox.geojson.Point
+import com.mapbox.maps.EdgeInsets
+import com.mapbox.maps.ImageHolder
 import com.mapbox.maps.MapView
+import com.mapbox.maps.plugin.LocationPuck2D
 import com.mapbox.maps.plugin.animation.camera
 import com.mapbox.maps.plugin.locationcomponent.location
+import com.mapbox.maps.plugin.locationcomponent.OnIndicatorBearingChangedListener
+import com.mapbox.maps.plugin.locationcomponent.OnIndicatorPositionChangedListener
 import com.mapbox.navigation.base.TimeFormat
 import com.mapbox.navigation.base.extensions.applyDefaultNavigationOptions
 import com.mapbox.navigation.base.formatter.DistanceFormatterOptions
@@ -35,7 +43,6 @@ import com.mapbox.navigation.tripdata.maneuver.api.MapboxManeuverApi
 import com.mapbox.navigation.tripdata.progress.api.MapboxTripProgressApi
 import com.mapbox.navigation.tripdata.progress.model.DistanceRemainingFormatter
 import com.mapbox.navigation.tripdata.progress.model.EstimatedTimeToArrivalFormatter
-import com.mapbox.navigation.tripdata.progress.model.PercentDistanceTraveledFormatter
 import com.mapbox.navigation.tripdata.progress.model.TimeRemainingFormatter
 import com.mapbox.navigation.tripdata.progress.model.TripProgressUpdateFormatter
 import com.mapbox.navigation.tripdata.speedlimit.api.MapboxSpeedInfoApi
@@ -58,7 +65,6 @@ 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"
@@ -84,6 +90,12 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     private var tvDistance: TextView? = null
     private var etaBar: LinearLayout? = null
 
+    // ── Side action buttons (mute, overview, recenter) ────────────────────────
+    private var btnMute: TextView? = null
+    private var btnOverview: TextView? = null
+    private var btnRecenter: TextView? = null
+    private var sideButtons: LinearLayout? = null
+
     // ── Navigation APIs ───────────────────────────────────────────────────────
     private lateinit var navigationCamera: NavigationCamera
     private lateinit var viewportDataSource: MapboxNavigationViewportDataSource
@@ -96,7 +108,36 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     private lateinit var routeArrowView: MapboxRouteArrowView
     private val navigationLocationProvider = NavigationLocationProvider()
     private var mapboxNavigation: MapboxNavigation? = null
+
+    // ── State ─────────────────────────────────────────────────────────────────
     private var isNightMode = false
+    private var isMuted = false
+    private var isOverviewMode = false
+    private var firstLocationReceived = false
+
+    // ── Pixel density ─────────────────────────────────────────────────────────
+    private val dp = context.resources.displayMetrics.density
+
+    // ── Viewport padding (Waze-style: vehicle at ~30% from bottom) ────────────
+    // top=180dp → room for maneuver banner
+    // bottom=300dp → pushes vehicle UP toward 30% from bottom (Waze style)
+    // Without large bottom padding, vehicle sits at screen center
+    private val followingPadding by lazy {
+        EdgeInsets(
+            180.0 * dp,   // top (maneuver banner height)
+            40.0 * dp,    // left
+            300.0 * dp,   // bottom — large value pushes vehicle up like Waze
+            40.0 * dp     // right
+        )
+    }
+    private val overviewPadding by lazy {
+        EdgeInsets(
+            120.0 * dp,
+            40.0 * dp,
+            120.0 * dp,
+            40.0 * dp
+        )
+    }
 
     // ── Props ─────────────────────────────────────────────────────────────────
     private var coordinates: List<Map<String, Double>> = emptyList()
@@ -120,20 +161,20 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // Build UI
+    // Build Waze-style UI
     // ─────────────────────────────────────────────────────────────────────────
     private fun buildUI() {
-        val dp = context.resources.displayMetrics.density
         val root = FrameLayout(context).apply {
             layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
         }
 
+        // Full-screen map
         root.addView(mapView, FrameLayout.LayoutParams(
             FrameLayout.LayoutParams.MATCH_PARENT,
             FrameLayout.LayoutParams.MATCH_PARENT
         ))
 
-        // ManeuverView — top (cast to View: extends ConstraintLayout)
+        // ── ManeuverView — top banner ──────────────────────────────────────────
         val mv = MapboxManeuverView(context)
         root.addView(mv as View, FrameLayout.LayoutParams(
             FrameLayout.LayoutParams.MATCH_PARENT,
@@ -142,55 +183,97 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         mv.visibility = View.INVISIBLE
         maneuverView = mv
 
-        // SpeedInfoView — bottom-left (cast to View)
+        // ── SpeedInfoView — bottom-left, above ETA bar ────────────────────────
         val siv = MapboxSpeedInfoView(context)
         root.addView(siv as View, FrameLayout.LayoutParams(
-            FrameLayout.LayoutParams.WRAP_CONTENT,
-            FrameLayout.LayoutParams.WRAP_CONTENT
+            (72 * dp).toInt(),
+            (72 * dp).toInt()
         ).also {
             it.gravity = Gravity.BOTTOM or Gravity.START
-            it.setMargins((16 * dp).toInt(), 0, 0, (100 * dp).toInt())
+            it.setMargins((12 * dp).toInt(), 0, 0, (88 * dp).toInt())
         })
         siv.visibility = View.GONE
         speedInfoView = siv
 
-        // TripProgressView (used by the official Mapbox render method)
-        val tpv = MapboxTripProgressView(context)
-        tripProgressView = tpv
+        // ── Side action buttons (right side, Waze-style) ──────────────────────
+        val sideCol = LinearLayout(context).apply {
+            orientation = LinearLayout.VERTICAL
+            gravity = Gravity.CENTER_HORIZONTAL
+            visibility = View.INVISIBLE
+        }
+        root.addView(sideCol, FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.WRAP_CONTENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT
+        ).also {
+            it.gravity = Gravity.END or Gravity.BOTTOM
+            it.setMargins(0, 0, (12 * dp).toInt(), (96 * dp).toInt())
+        })
+        sideButtons = sideCol
+
+        // Mute button
+        val muteBtn = makeCircleButton("🔊")
+        muteBtn.setOnClickListener { toggleMute() }
+        sideCol.addView(muteBtn, circleButtonParams())
+        btnMute = muteBtn
 
-        // Bottom ETA bar
+        sideCol.addView(View(context), LinearLayout.LayoutParams(1, (10 * dp).toInt()))
+
+        // Overview button
+        val overviewBtn = makeCircleButton("⊕")
+        overviewBtn.setOnClickListener { toggleOverview() }
+        sideCol.addView(overviewBtn, circleButtonParams())
+        btnOverview = overviewBtn
+
+        sideCol.addView(View(context), LinearLayout.LayoutParams(1, (10 * dp).toInt()))
+
+        // Recenter button (shown only in overview mode)
+        val recenterBtn = makeCircleButton("◎")
+        recenterBtn.setOnClickListener { recenterCamera() }
+        recenterBtn.visibility = View.GONE
+        sideCol.addView(recenterBtn, circleButtonParams())
+        btnRecenter = recenterBtn
+
+        // ── ETA bottom bar ─────────────────────────────────────────────────────
         val bar = LinearLayout(context).apply {
             orientation = LinearLayout.HORIZONTAL
-            setBackgroundColor(Color.WHITE)
+            setBackgroundColor(Color.parseColor("#1E2433"))
             elevation = 8 * dp
             visibility = View.INVISIBLE
             gravity = Gravity.CENTER_VERTICAL
             setPadding(
-                (16 * dp).toInt(), (8 * dp).toInt(),
-                (16 * dp).toInt(), (8 * dp).toInt()
+                (16 * dp).toInt(), (12 * dp).toInt(),
+                (16 * dp).toInt(), (12 * dp).toInt()
             )
         }
         root.addView(bar, FrameLayout.LayoutParams(
-            FrameLayout.LayoutParams.MATCH_PARENT, (80 * dp).toInt()
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT
         ).also { it.gravity = Gravity.BOTTOM })
 
+        // ETA arrival time
         val etaTime = TextView(context).apply {
-            textSize = 22f
-            setTextColor(Color.BLACK)
+            textSize = 24f
+            setTextColor(Color.WHITE)
             typeface = android.graphics.Typeface.DEFAULT_BOLD
         }
         bar.addView(etaTime, LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f))
         tvEtaTime = etaTime
 
+        // Duration + distance (center)
         val center = LinearLayout(context).apply {
             orientation = LinearLayout.VERTICAL
             gravity = Gravity.CENTER
         }
         val dur = TextView(context).apply {
-            textSize = 16f; setTextColor(Color.DKGRAY); gravity = Gravity.CENTER
+            textSize = 18f
+            setTextColor(Color.WHITE)
+            typeface = android.graphics.Typeface.DEFAULT_BOLD
+            gravity = Gravity.CENTER
         }
         val dist = TextView(context).apply {
-            textSize = 13f; setTextColor(Color.GRAY); gravity = Gravity.CENTER
+            textSize = 13f
+            setTextColor(Color.parseColor("#AAAAAA"))
+            gravity = Gravity.CENTER
         }
         center.addView(dur)
         center.addView(dist)
@@ -198,27 +281,55 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         tvDuration = dur
         tvDistance = dist
 
+        // Cancel button
         val cancelBtn = TextView(context).apply {
-            text = "✕"; textSize = 22f; setTextColor(Color.DKGRAY)
+            text = "✕"
+            textSize = 22f
+            setTextColor(Color.parseColor("#AAAAAA"))
             gravity = Gravity.END or Gravity.CENTER_VERTICAL
             setOnClickListener { cancelNavigation() }
         }
         bar.addView(cancelBtn, LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f))
         etaBar = bar
 
+        // TripProgressView — 1×1 hidden (required for render() API)
+        val tpv = MapboxTripProgressView(context)
+        root.addView(tpv as View, FrameLayout.LayoutParams(1, 1))
+        tpv.visibility = View.GONE
+        tripProgressView = tpv
+
         addView(root)
     }
 
+    // Helper: creates a white circle button (Waze style)
+    private fun makeCircleButton(text: String): TextView {
+        return TextView(context).apply {
+            this.text = text
+            textSize = 20f
+            gravity = Gravity.CENTER
+            setTextColor(Color.BLACK)
+            background = GradientDrawable().apply {
+                shape = GradientDrawable.OVAL
+                setColor(Color.WHITE)
+                // Drop shadow via elevation
+            }
+            elevation = 6 * dp
+        }
+    }
+
+    private fun circleButtonParams(): LinearLayout.LayoutParams {
+        val size = (52 * dp).toInt()
+        return LinearLayout.LayoutParams(size, size)
+    }
+
     // ─────────────────────────────────────────────────────────────────────────
-    // Init APIs — confirmed from official Mapbox examples
+    // Init APIs
     // ─────────────────────────────────────────────────────────────────────────
     private fun initAPIs() {
         val distanceFormatterOptions = DistanceFormatterOptions.Builder(context).build()
 
         maneuverApi = MapboxManeuverApi(MapboxDistanceFormatter(distanceFormatterOptions))
 
-        // TripProgressApi — from ShowTripProgressActivity official example
-        // PercentDistanceTraveledFormatter is optional — omit if causing issues
         tripProgressApi = MapboxTripProgressApi(
             TripProgressUpdateFormatter.Builder(context)
                 .distanceRemainingFormatter(DistanceRemainingFormatter(distanceFormatterOptions))
@@ -252,16 +363,35 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         mapView.mapboxMap.loadStyle(mapStyle ?: getAutoStyle()) { style ->
             routeLineView.initializeLayers(style)
 
+            // Camera viewport
             viewportDataSource = MapboxNavigationViewportDataSource(mapView.mapboxMap)
+            viewportDataSource.followingPadding = followingPadding
+            viewportDataSource.overviewPadding = overviewPadding
+
             navigationCamera = NavigationCamera(
                 mapView.mapboxMap,
                 mapView.camera,
                 viewportDataSource
             )
 
+            // ── Location puck — Waze-style arrow ─────────────────────────────
+            // FIX: use mapbox_navigation_puck_icon (built-in arrow)
+            // + PuckBearing.COURSE to orient it in direction of travel
             mapView.location.apply {
                 setLocationProvider(navigationLocationProvider)
-                enabled = true
+                updateSettings {
+                    // Built-in navigation arrow (chevron) from Nav SDK
+                    locationPuck = LocationPuck2D(
+                        bearingImage = ImageHolder.from(
+                            com.mapbox.navigation.R.drawable.mapbox_navigation_puck_icon
+                        )
+                    )
+                    // COURSE = direction of movement (not compass heading)
+                    puckBearingEnabled = true
+                    enabled = true
+                }
+                // Must set puckBearing separately — confirmed from migration guide
+                puckBearing = com.mapbox.maps.plugin.PuckBearing.COURSE
             }
 
             registerObservers()
@@ -285,6 +415,8 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
                     }
                     viewportDataSource.onRouteChanged(result.navigationRoutes.first())
                     viewportDataSource.evaluate()
+                    isOverviewMode = false
+                    safeCameraFollowing()
                     showUI()
                     onRoutesReady(mapOf(
                         "routeCount" to result.navigationRoutes.size,
@@ -310,21 +442,16 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             viewportDataSource.onRouteProgressChanged(routeProgress)
             viewportDataSource.evaluate()
 
-            // Route arrow
+            // Maneuver arrow on map
             mapView.mapboxMap.style?.let { style ->
                 val arrowResult = routeArrowApi.addUpcomingManeuverArrow(routeProgress)
                 routeArrowView.renderManeuverUpdate(style, arrowResult)
             }
 
-            // ── 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
+            // Maneuver banner
             val maneuvers = maneuverApi.getManeuvers(routeProgress)
             maneuvers.fold(
-                { error ->
-                    Log.w(TAG, "Maneuver error: ${error.errorMessage}")
-                    Unit
-                },
+                { error -> Log.w(TAG, "Maneuver error: ${error.errorMessage}"); Unit },
                 { _ ->
                     maneuverView?.visibility = View.VISIBLE
                     maneuverView?.renderManeuvers(maneuvers)
@@ -332,13 +459,7 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
                 }
             )
 
-            // ── 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)
+            // Trip progress
             val tripProgress = tripProgressApi.getTripProgress(routeProgress)
             tripProgressView?.render(tripProgress)
             updateEtaBar(
@@ -363,14 +484,22 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             override fun onNewRawLocation(rawLocation: Location) {}
             override fun onNewLocationMatcherResult(result: LocationMatcherResult) {
                 val loc = result.enhancedLocation
+
                 navigationLocationProvider.changePosition(
                     location = loc,
                     keyPoints = result.keyPoints,
                 )
+
                 viewportDataSource.onLocationChanged(loc)
                 viewportDataSource.evaluate()
 
-                // Speed limit
+                // First GPS fix → enter following mode
+                if (!firstLocationReceived) {
+                    firstLocationReceived = true
+                    safeCameraFollowing()
+                }
+
+                // Speed limit display
                 val fmtOptions = DistanceFormatterOptions.Builder(context).build()
                 val speedInfo = speedInfoApi.updatePostedAndCurrentSpeed(result, fmtOptions)
                 if (speedInfo != null) {
@@ -386,17 +515,51 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // ETA bar — using confirmed TripProgressUpdateValue fields
-    // estimatedTimeToArrival: Long — Unix timestamp (ms) of expected arrival
-    // totalTimeRemaining: Double — seconds remaining
-    // distanceRemaining: Double — metres remaining
+    // Button actions
+    // ─────────────────────────────────────────────────────────────────────────
+
+    // Toggle mute voice guidance
+    private fun toggleMute() {
+        isMuted = !isMuted
+        btnMute?.text = if (isMuted) "🔇" else "🔊"
+        btnMute?.setTextColor(if (isMuted) Color.parseColor("#FF4444") else Color.BLACK)
+        // Actual audio muting handled by the voice instruction observer in the app
+        // We expose the state via event so the RN layer can mute TTS
+        onNavigationCancelled(mapOf("type" to "mute", "muted" to isMuted))
+    }
+
+    // Toggle overview / following mode
+    private fun toggleOverview() {
+        if (isOverviewMode) {
+            recenterCamera()
+        } else {
+            isOverviewMode = true
+            btnOverview?.text = "◉"
+            btnRecenter?.visibility = View.VISIBLE
+            try {
+                navigationCamera.requestNavigationCameraToOverview()
+            } catch (e: Exception) {
+                Log.e(TAG, "Camera overview error: ${e.message}")
+            }
+        }
+    }
+
+    // Recenter camera to vehicle (following mode)
+    private fun recenterCamera() {
+        isOverviewMode = false
+        btnOverview?.text = "⊕"
+        btnRecenter?.visibility = View.GONE
+        safeCameraFollowing()
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // ETA bar
     // ─────────────────────────────────────────────────────────────────────────
     private fun updateEtaBar(
         estimatedTimeToArrivalMs: Long,
         totalTimeRemainingSec: Double,
         distanceRemainingMetres: Double
     ) {
-        // Arrival clock time from Unix timestamp
         val arrivalCal = Calendar.getInstance().apply {
             timeInMillis = estimatedTimeToArrivalMs
         }
@@ -406,14 +569,12 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             arrivalCal.get(Calendar.MINUTE)
         )
 
-        // Duration remaining
         val totalMin = (totalTimeRemainingSec / 60).toInt()
         tvDuration?.text = if (totalMin >= 60)
             "${totalMin / 60}h ${totalMin % 60}min"
         else
             "${totalMin} min"
 
-        // Distance remaining
         tvDistance?.text = if (distanceRemainingMetres >= 1000)
             String.format("%.1f km", distanceRemainingMetres / 1000.0)
         else
@@ -444,11 +605,21 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
                 }
             }
         }
-        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)
-        tvDistance?.setTextColor(Color.GRAY)
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Camera following — issue #43 safe wrapper
+    // ─────────────────────────────────────────────────────────────────────────
+    private fun safeCameraFollowing() {
+        try {
+            navigationCamera.requestNavigationCameraToFollowing(
+                stateTransitionOptions = NavigationCameraTransitionOptions.Builder()
+                    .maxDuration(0)
+                    .build()
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Camera following error: ${e.message}")
+        }
     }
 
     // ─────────────────────────────────────────────────────────────────────────
@@ -457,6 +628,8 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     private fun cancelNavigation() {
         mapboxNavigation?.setNavigationRoutes(listOf())
         mapboxNavigation?.stopTripSession()
+        firstLocationReceived = false
+        isOverviewMode = false
         hideUI()
         onNavigationCancelled(mapOf<String, Any>())
     }
@@ -464,27 +637,19 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     private fun showUI() {
         maneuverView?.visibility = View.VISIBLE
         etaBar?.visibility = View.VISIBLE
+        sideButtons?.visibility = View.VISIBLE
     }
 
     private fun hideUI() {
         maneuverView?.visibility = View.INVISIBLE
         speedInfoView?.visibility = View.GONE
         etaBar?.visibility = View.INVISIBLE
+        sideButtons?.visibility = View.INVISIBLE
     }
 
-    // Issue #43
-    private fun safeCameraFollowing() {
-        try {
-            navigationCamera.requestNavigationCameraToFollowing(
-                stateTransitionOptions = NavigationCameraTransitionOptions.Builder()
-                    .maxDuration(0).build()
-            )
-        } catch (e: Exception) {
-            Log.e(TAG, "Camera error: ${e.message}")
-        }
-    }
-
-    // Issue #31
+    // ─────────────────────────────────────────────────────────────────────────
+    // Issue #31 — Voice units
+    // ─────────────────────────────────────────────────────────────────────────
     private fun resolveVoiceUnits(): String {
         return when (voiceUnits?.lowercase()) {
             "metric" -> "metric"
@@ -496,57 +661,83 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         }
     }
 
+    // ─────────────────────────────────────────────────────────────────────────
     // Route request
+    // ─────────────────────────────────────────────────────────────────────────
     @SuppressLint("MissingPermission")
     private fun fetchRoutes() {
         val nav = mapboxNavigation ?: return
         if (coordinates.size < 2) return
-        val points = coordinates.map { Point.fromLngLat(it["longitude"] ?: 0.0, it["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")
+            .annotations("maxspeed,congestion,duration,speed")
+
         waypointIndices?.let { builder.waypointIndicesList(it) }
-        navigationProfile?.let { builder.profile(if (it.startsWith("mapbox/")) it else "mapbox/$it") }
-        excludeTypes?.takeIf { it.isNotEmpty() }?.let { builder.exclude(it.joinToString(",")) }
+        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 }
+            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) {
+
+            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() }
-    fun setWaypointIndices(indices: List<Int>?) { waypointIndices = indices }
-    fun setLanguage(lang: String?) { language = lang }
-    fun setVoiceUnits(units: String?) { voiceUnits = units }
-    fun setNavigationProfile(profile: String?) { navigationProfile = profile }
-    fun setExcludeTypes(types: List<String>?) { excludeTypes = types }
-    fun setMapStyle(style: String?) { mapStyle = style }
-    fun setMute(shouldMute: Boolean) { mute = shouldMute }
-    fun setMaxHeight(height: Double?) { maxHeight = height }
-    fun setMaxWidth(width: Double?) { maxWidth = width }
-    fun setUseMapMatching(use: Boolean) { useMapMatching = use }
-    fun setCustomRasterTileUrl(url: String?) { customRasterTileUrl = url }
-    fun setCustomRasterAboveLayerId(layerId: String?) { customRasterAboveLayerId = layerId }
-
+    // ── Prop setters ──────────────────────────────────────────────────────────
+    fun setCoordinates(coords: List<Map<String, Double>>) {
+        coordinates = coords
+        if (coords.size >= 2) fetchRoutes()
+    }
+    fun setWaypointIndices(i: List<Int>?) { waypointIndices = i }
+    fun setLanguage(l: String?) { language = l }
+    fun setVoiceUnits(u: String?) { voiceUnits = u }
+    fun setNavigationProfile(p: String?) { navigationProfile = p }
+    fun setExcludeTypes(t: List<String>?) { excludeTypes = t }
+    fun setMapStyle(s: String?) { mapStyle = s }
+    fun setMute(m: Boolean) { mute = m; if (m != isMuted) toggleMute() }
+    fun setMaxHeight(h: Double?) { maxHeight = h }
+    fun setMaxWidth(w: Double?) { maxWidth = w }
+    fun setUseMapMatching(u: Boolean) { useMapMatching = u }
+    fun setCustomRasterTileUrl(u: String?) { customRasterTileUrl = u }
+    fun setCustomRasterAboveLayerId(l: String?) { customRasterAboveLayerId = l }
+
+    // ── Lifecycle ─────────────────────────────────────────────────────────────
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
         maneuverApi.cancel()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacques_gordon/expo-mapbox-navigation",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "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",