@jacques_gordon/expo-mapbox-navigation 2.1.1 → 2.1.2

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

@@ -2,6 +2,7 @@ package expo.modules.mapboxnavigation
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.content.res.Resources
 import android.graphics.Color
 import android.util.Log
 import android.view.Gravity
@@ -12,6 +13,7 @@ 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.MapView
 import com.mapbox.maps.plugin.animation.camera
 import com.mapbox.maps.plugin.locationcomponent.location
@@ -35,7 +37,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 +59,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"
@@ -98,6 +98,29 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     private var mapboxNavigation: MapboxNavigation? = null
     private var isNightMode = false
 
+    // ── FIX: Track whether first location has been received ───────────────────
+    // Without this, camera never enters following mode on first GPS fix
+    private var firstLocationReceived = false
+
+    // ── Viewport padding (from official TurnByTurnExperienceActivity) ─────────
+    private val pixelDensity = Resources.getSystem().displayMetrics.density
+    private val followingPadding by lazy {
+        EdgeInsets(
+            180.0 * pixelDensity,  // top — room for maneuver banner
+            40.0 * pixelDensity,
+            150.0 * pixelDensity,  // bottom — room for ETA bar
+            40.0 * pixelDensity
+        )
+    }
+    private val overviewPadding by lazy {
+        EdgeInsets(
+            140.0 * pixelDensity,
+            40.0 * pixelDensity,
+            120.0 * pixelDensity,
+            40.0 * pixelDensity
+        )
+    }
+
     // ── Props ─────────────────────────────────────────────────────────────────
     private var coordinates: List<Map<String, Double>> = emptyList()
     private var waypointIndices: List<Int>? = null
@@ -128,12 +151,14 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             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 ──────────────────────────────────────────
+        // extends ConstraintLayout → must cast to View for addView()
         val mv = MapboxManeuverView(context)
         root.addView(mv as View, FrameLayout.LayoutParams(
             FrameLayout.LayoutParams.MATCH_PARENT,
@@ -142,83 +167,103 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         mv.visibility = View.INVISIBLE
         maneuverView = mv
 
-        // SpeedInfoView — bottom-left (cast to View)
+        // ── SpeedInfoView — bottom-left ────────────────────────────────────────
+        // Shows posted speed limit + current vehicle speed
         val siv = MapboxSpeedInfoView(context)
         root.addView(siv as View, FrameLayout.LayoutParams(
             FrameLayout.LayoutParams.WRAP_CONTENT,
             FrameLayout.LayoutParams.WRAP_CONTENT
         ).also {
             it.gravity = Gravity.BOTTOM or Gravity.START
-            it.setMargins((16 * dp).toInt(), 0, 0, (100 * dp).toInt())
+            // Position above the ETA bar (80dp) + margin
+            it.setMargins((16 * dp).toInt(), 0, 0, (96 * dp).toInt())
         })
         siv.visibility = View.GONE
         speedInfoView = siv
 
-        // TripProgressView (used by the official Mapbox render method)
-        val tpv = MapboxTripProgressView(context)
-        tripProgressView = tpv
-
-        // Bottom ETA bar
+        // ── ETA bottom bar ─────────────────────────────────────────────────────
         val bar = LinearLayout(context).apply {
             orientation = LinearLayout.HORIZONTAL
-            setBackgroundColor(Color.WHITE)
+            setBackgroundColor(Color.parseColor("#1E2433"))  // dark nav style
             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))
+        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)
-        bar.addView(center, LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 2f))
+        bar.addView(center, LinearLayout.LayoutParams(
+            0, LinearLayout.LayoutParams.WRAP_CONTENT, 2f
+        ))
         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))
+        bar.addView(cancelBtn, LinearLayout.LayoutParams(
+            0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f
+        ))
         etaBar = bar
 
+        // ── TripProgressView — hidden native view (used for render() API) ──────
+        // FIX: was created but never added to root — now added but invisible
+        val tpv = MapboxTripProgressView(context)
+        root.addView(tpv as View, FrameLayout.LayoutParams(1, 1))  // 1x1 hidden
+        tpv.visibility = View.GONE
+        tripProgressView = tpv
+
         addView(root)
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // 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,13 +297,21 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         mapView.mapboxMap.loadStyle(mapStyle ?: getAutoStyle()) { style ->
             routeLineView.initializeLayers(style)
 
+            // Camera viewport data source
             viewportDataSource = MapboxNavigationViewportDataSource(mapView.mapboxMap)
+
+            // FIX: Set padding BEFORE creating NavigationCamera
+            // Without this, the camera doesn't account for the maneuver banner and ETA bar
+            viewportDataSource.followingPadding = followingPadding
+            viewportDataSource.overviewPadding = overviewPadding
+
             navigationCamera = NavigationCamera(
                 mapView.mapboxMap,
                 mapView.camera,
                 viewportDataSource
             )
 
+            // Location puck
             mapView.location.apply {
                 setLocationProvider(navigationLocationProvider)
                 enabled = true
@@ -274,7 +327,7 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     private fun registerObservers() {
         val nav = mapboxNavigation ?: return
 
-        // Routes observer
+        // ── Routes observer ───────────────────────────────────────────────────
         nav.registerRoutesObserver(object : RoutesObserver {
             override fun onRoutesChanged(result: RoutesUpdatedResult) {
                 if (result.navigationRoutes.isNotEmpty()) {
@@ -285,7 +338,12 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
                     }
                     viewportDataSource.onRouteChanged(result.navigationRoutes.first())
                     viewportDataSource.evaluate()
+
+                    // FIX: transition to following mode when route is set
+                    // This triggers the camera to zoom/pitch/center correctly
+                    safeCameraFollowing()
                     showUI()
+
                     onRoutesReady(mapOf(
                         "routeCount" to result.navigationRoutes.size,
                         "distanceMeters" to (result.navigationRoutes.first().directionsRoute.distance() ?: 0.0),
@@ -305,20 +363,19 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             }
         })
 
-        // Route progress observer
+        // ── Route progress observer ───────────────────────────────────────────
         nav.registerRouteProgressObserver(RouteProgressObserver { routeProgress ->
+            // Update viewport with progress (camera follows route progress)
             viewportDataSource.onRouteProgressChanged(routeProgress)
             viewportDataSource.evaluate()
 
-            // Route arrow
+            // Draw maneuver arrow
             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 ->
@@ -332,13 +389,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(
@@ -358,19 +409,32 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
             ))
         })
 
-        // Location observer
+        // ── Location observer ─────────────────────────────────────────────────
         nav.registerLocationObserver(object : LocationObserver {
             override fun onNewRawLocation(rawLocation: Location) {}
+
             override fun onNewLocationMatcherResult(result: LocationMatcherResult) {
                 val loc = result.enhancedLocation
+
+                // Update location puck position
                 navigationLocationProvider.changePosition(
                     location = loc,
                     keyPoints = result.keyPoints,
                 )
+
+                // FIX: Update viewport data source with location AND bearing
+                // This is what drives the camera to follow the vehicle's direction
                 viewportDataSource.onLocationChanged(loc)
                 viewportDataSource.evaluate()
 
-                // Speed limit
+                // FIX: On first location fix, immediately enter following mode
+                // This ensures the camera centers on the user as soon as GPS is available
+                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 +450,17 @@ 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
+    // ETA bar update
+    // Fields confirmed from TripProgressUpdateValue docs:
+    //   estimatedTimeToArrival: Long — Unix timestamp ms
+    //   totalTimeRemaining: Double — seconds
+    //   distanceRemaining: Double — metres
     // ─────────────────────────────────────────────────────────────────────────
     private fun updateEtaBar(
         estimatedTimeToArrivalMs: Long,
         totalTimeRemainingSec: Double,
         distanceRemainingMetres: Double
     ) {
-        // Arrival clock time from Unix timestamp
         val arrivalCal = Calendar.getInstance().apply {
             timeInMillis = estimatedTimeToArrivalMs
         }
@@ -406,14 +470,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
@@ -421,7 +483,7 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // Day / Night
+    // Day / Night auto switch
     // ─────────────────────────────────────────────────────────────────────────
     private fun getAutoStyle(): String {
         val hour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY)
@@ -444,19 +506,31 @@ 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)
     }
 
     // ─────────────────────────────────────────────────────────────────────────
-    // Cancel navigation
+    // Camera following — safe wrapper (issue #43)
+    // FIX: maxDuration(0) = instant transition, no animation delay
+    // ─────────────────────────────────────────────────────────────────────────
+    private fun safeCameraFollowing() {
+        try {
+            navigationCamera.requestNavigationCameraToFollowing(
+                stateTransitionOptions = NavigationCameraTransitionOptions.Builder()
+                    .maxDuration(0)
+                    .build()
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Camera following error: ${e.message}")
+        }
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Cancel navigation — also stops foreground service (fixes notification crash)
     // ─────────────────────────────────────────────────────────────────────────
     private fun cancelNavigation() {
         mapboxNavigation?.setNavigationRoutes(listOf())
         mapboxNavigation?.stopTripSession()
+        firstLocationReceived = false
         hideUI()
         onNavigationCancelled(mapOf<String, Any>())
     }
@@ -472,19 +546,9 @@ class ExpoMapboxNavigationView(context: Context, appContext: AppContext) :
         etaBar?.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 +560,86 @@ 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)
+            // maxspeed annotation required for speed limit display
             .annotations("maxspeed,congestion,duration")
+
         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()
+                // Camera will follow automatically via onNewLocationMatcherResult
+                // + onRoutesChanged observer
             }
+
             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 }
+    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.2",
   "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",