@castelio-it/capacitor-mapboxnav 1.0.3

package/android/src/androidTest/java/com/getcapacitor/android/ExampleInstrumentedTest.java

@@ -0,0 +1,26 @@
+package com.getcapacitor.android;
+
+import static org.junit.Assert.*;
+
+import android.content.Context;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+
+    @Test
+    public void useAppContext() throws Exception {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+        assertEquals("com.getcapacitor.android", appContext.getPackageName());
+    }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,24 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+    <application>
+        <activity
+            android:name=".NavigationActivity"
+            android:theme="@style/Theme.AppCompat.NoActionBar"
+            android:exported="false" />
+        <activity
+            android:name=".TurnByTurnExperienceActivity"
+            android:theme="@style/Theme.AppCompat.NoActionBar"
+            android:exported="false" />
+        <activity
+            android:name=".FreeDriveActivity"
+            android:theme="@style/Theme.AppCompat.NoActionBar"
+            android:exported="false" />
+    </application>
+</manifest>

package/android/src/main/java/com/castelioit/capacitormapboxnav/FreeDriveActivity.kt

@@ -0,0 +1,126 @@
+package com.castelioit.capacitormapboxnav
+
+import android.annotation.SuppressLint
+import android.os.Bundle
+import android.view.View
+import androidx.appcompat.app.AppCompatActivity
+import com.mapbox.common.location.Location
+import com.mapbox.geojson.Point
+import com.mapbox.maps.plugin.LocationPuck2D
+import com.mapbox.maps.plugin.animation.camera
+import com.mapbox.maps.plugin.locationcomponent.location
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.core.MapboxNavigation
+import com.mapbox.navigation.core.lifecycle.MapboxNavigationObserver
+import com.mapbox.navigation.core.lifecycle.requireMapboxNavigation
+import com.mapbox.navigation.core.trip.session.LocationMatcherResult
+import com.mapbox.navigation.core.trip.session.LocationObserver
+import com.castelioit.capacitormapboxnav.databinding.MapboxActivityFreeDriveBinding
+import com.mapbox.navigation.ui.maps.NavigationStyles
+import com.mapbox.navigation.ui.maps.camera.NavigationCamera
+import com.mapbox.navigation.ui.maps.camera.data.MapboxNavigationViewportDataSource
+import com.mapbox.navigation.ui.maps.camera.lifecycle.NavigationBasicGesturesHandler
+import com.mapbox.navigation.ui.maps.camera.state.NavigationCameraState
+import com.mapbox.navigation.ui.maps.location.NavigationLocationProvider
+
+/**
+ * This example demonstrates a basic free-drive experience by showing the user location puck on the map.
+ */
+@OptIn(ExperimentalPreviewMapboxNavigationAPI::class)
+class FreeDriveActivity : AppCompatActivity() {
+
+    private lateinit var binding: MapboxActivityFreeDriveBinding
+    private lateinit var navigationCamera: NavigationCamera
+    private lateinit var viewportDataSource: MapboxNavigationViewportDataSource
+    private val navigationLocationProvider = NavigationLocationProvider()
+
+    private val locationObserver = object : LocationObserver {
+        override fun onNewRawLocation(rawLocation: Location) {
+            // not handled
+        }
+
+        override fun onNewLocationMatcherResult(locationMatcherResult: LocationMatcherResult) {
+            val enhancedLocation = locationMatcherResult.enhancedLocation
+            navigationLocationProvider.changePosition(
+                location = enhancedLocation,
+                keyPoints = locationMatcherResult.keyPoints,
+            )
+
+            viewportDataSource.onLocationChanged(enhancedLocation)
+            viewportDataSource.evaluate()
+        }
+    }
+
+    private val mapboxNavigation: MapboxNavigation by requireMapboxNavigation(
+        onResumedObserver = object : MapboxNavigationObserver {
+            @SuppressLint("MissingPermission")
+            override fun onAttached(mapboxNavigation: MapboxNavigation) {
+                mapboxNavigation.registerLocationObserver(locationObserver)
+                mapboxNavigation.startTripSession()
+            }
+
+            override fun onDetached(mapboxNavigation: MapboxNavigation) {
+                mapboxNavigation.unregisterLocationObserver(locationObserver)
+                mapboxNavigation.stopTripSession()
+            }
+        }
+    )
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = MapboxActivityFreeDriveBinding.inflate(layoutInflater)
+        setContentView(binding.root)
+
+        viewportDataSource = MapboxNavigationViewportDataSource(binding.mapView.mapboxMap)
+        navigationCamera = NavigationCamera(
+            binding.mapView.mapboxMap,
+            binding.mapView.camera,
+            viewportDataSource
+        )
+        binding.mapView.camera.addCameraAnimationsLifecycleListener(
+            NavigationBasicGesturesHandler(navigationCamera)
+        )
+        navigationCamera.registerNavigationCameraStateChangeObserver { navigationCameraState ->
+            when (navigationCameraState) {
+                NavigationCameraState.TRANSITION_TO_FOLLOWING,
+                NavigationCameraState.FOLLOWING -> binding.recenter.visibility = View.INVISIBLE
+                NavigationCameraState.TRANSITION_TO_OVERVIEW,
+                NavigationCameraState.OVERVIEW,
+                NavigationCameraState.IDLE -> binding.recenter.visibility = View.VISIBLE
+            }
+        }
+
+        binding.recenter.setOnClickListener {
+            navigationCamera.requestNavigationCameraToFollowing()
+        }
+
+        binding.mapView.mapboxMap.loadStyle(NavigationStyles.NAVIGATION_DAY_STYLE) {
+            binding.mapView.location.apply {
+                setLocationProvider(navigationLocationProvider)
+                this.locationPuck = LocationPuck2D()
+                puckBearingEnabled = true
+                enabled = true
+            }
+        }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        binding.mapView.onStart()
+    }
+
+    override fun onStop() {
+        super.onStop()
+        binding.mapView.onStop()
+    }
+
+    override fun onLowMemory() {
+        super.onLowMemory()
+        binding.mapView.onLowMemory()
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        binding.mapView.onDestroy()
+    }
+}

package/android/src/main/java/com/castelioit/capacitormapboxnav/NavigationActivity.kt

@@ -0,0 +1,276 @@
+package com.castelioit.capacitormapboxnav
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Bundle
+import android.widget.Toast
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.app.ActivityCompat
+import com.mapbox.api.directions.v5.models.RouteOptions
+import com.mapbox.common.location.Location
+import com.mapbox.geojson.Point
+import com.mapbox.maps.CameraOptions
+import com.mapbox.maps.EdgeInsets
+import com.mapbox.maps.MapInitOptions
+import com.mapbox.maps.MapView
+import com.mapbox.maps.MapboxExperimental
+import com.mapbox.maps.plugin.LocationPuck2D
+import com.mapbox.maps.plugin.PuckBearing
+import com.mapbox.maps.plugin.locationcomponent.createDefault2DPuck
+import com.mapbox.maps.plugin.animation.camera
+import com.mapbox.maps.plugin.attribution.attribution
+import com.mapbox.maps.plugin.compass.compass
+import com.mapbox.maps.plugin.locationcomponent.location
+import com.mapbox.maps.plugin.logo.logo
+import com.mapbox.maps.plugin.scalebar.scalebar
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.base.extensions.applyDefaultNavigationOptions
+import com.mapbox.navigation.base.route.NavigationRoute
+import com.mapbox.navigation.base.route.NavigationRouterCallback
+import com.mapbox.navigation.base.route.RouterFailure
+import com.mapbox.navigation.core.MapboxNavigation
+import com.mapbox.navigation.core.directions.session.RoutesObserver
+import com.mapbox.navigation.core.lifecycle.MapboxNavigationObserver
+import com.mapbox.navigation.core.lifecycle.requireMapboxNavigation
+import com.mapbox.navigation.core.replay.route.ReplayProgressObserver
+import com.mapbox.navigation.core.replay.route.ReplayRouteMapper
+import com.mapbox.navigation.core.trip.session.LocationMatcherResult
+import com.mapbox.navigation.core.trip.session.LocationObserver
+import com.mapbox.navigation.ui.maps.camera.NavigationCamera
+import com.mapbox.navigation.ui.maps.camera.data.MapboxNavigationViewportDataSource
+import com.mapbox.navigation.ui.maps.location.NavigationLocationProvider
+import com.mapbox.navigation.ui.maps.route.line.api.MapboxRouteLineApi
+import com.mapbox.navigation.ui.maps.route.line.api.MapboxRouteLineView
+import com.mapbox.navigation.ui.maps.route.line.model.MapboxRouteLineApiOptions
+import com.mapbox.navigation.ui.maps.route.line.model.MapboxRouteLineViewOptions
+
+class NavigationActivity : AppCompatActivity() {
+    private lateinit var mapView: MapView
+    private lateinit var viewportDataSource: MapboxNavigationViewportDataSource
+    private lateinit var navigationCamera: NavigationCamera
+    private lateinit var routeLineApi: MapboxRouteLineApi
+    private lateinit var routeLineView: MapboxRouteLineView
+    private lateinit var replayProgressObserver: ReplayProgressObserver
+    private val navigationLocationProvider = NavigationLocationProvider()
+    private val replayRouteMapper = ReplayRouteMapper()
+
+    private var originLat: Double = 0.0
+    private var originLng: Double = 0.0
+    private var destLat: Double = 0.0
+    private var destLng: Double = 0.0
+    private var simulateRoute: Boolean = false
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        originLat = intent.getExtraDouble("originLat", 0.0)
+        originLng = intent.getExtraDouble("originLng", 0.0)
+        destLat = intent.getExtraDouble("destLat", 0.0)
+        destLng = intent.getExtraDouble("destLng", 0.0)
+        simulateRoute = intent.getBooleanExtra("simulateRoute", false)
+
+        val permissions = mutableListOf(Manifest.permission.ACCESS_FINE_LOCATION)
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+            permissions.add(Manifest.permission.POST_NOTIFICATIONS)
+        }
+
+        val missingPermissions = permissions.filter {
+            ActivityCompat.checkSelfPermission(this, it) != PackageManager.PERMISSION_GRANTED
+        }
+
+        if (missingPermissions.isNotEmpty()) {
+            ActivityCompat.requestPermissions(this, missingPermissions.toTypedArray(), 1)
+        } else {
+            initializeMapComponents()
+        }
+    }
+
+    private fun Intent.getExtraDouble(key: String, defaultValue: Double): Double {
+        return if (hasExtra(key)) getDoubleExtra(key, defaultValue) else defaultValue
+    }
+
+    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        if (requestCode == 1) {
+            val allGranted = grantResults.all { it == PackageManager.PERMISSION_GRANTED }
+            if (allGranted) {
+                initializeMapComponents()
+            } else {
+                Toast.makeText(this, "Permissions denied. Navigation cannot start.", Toast.LENGTH_SHORT).show()
+                finish()
+            }
+        }
+    }
+
+    @OptIn(MapboxExperimental::class)
+    private fun initializeMapComponents() {
+        mapView = MapView(this, MapInitOptions(
+            this,
+            cameraOptions = CameraOptions.Builder()
+                .center(Point.fromLngLat(originLng, originLat))
+                .zoom(14.0)
+                .build(),
+        ))
+
+        mapView.scalebar.marginTop = 200f
+        mapView.compass.marginTop = 200f
+        mapView.logo.marginBottom = 140f
+        mapView.attribution.marginBottom = 140f
+        
+        mapView.location.apply {
+            setLocationProvider(navigationLocationProvider)
+            locationPuck = createDefault2DPuck( true)
+            enabled = true
+        }
+
+        setContentView(mapView)
+
+        viewportDataSource = MapboxNavigationViewportDataSource(mapView.mapboxMap)
+        val pixelDensity = this.resources.displayMetrics.density
+        viewportDataSource.followingPadding = EdgeInsets(
+            180.0 * pixelDensity,
+            40.0 * pixelDensity,
+            150.0 * pixelDensity,
+            40.0 * pixelDensity
+        )
+        
+
+
+        navigationCamera = NavigationCamera(mapView.mapboxMap, mapView.camera, viewportDataSource)
+        routeLineApi = MapboxRouteLineApi(MapboxRouteLineApiOptions.Builder().build())
+        routeLineView = MapboxRouteLineView(MapboxRouteLineViewOptions.Builder(this).build())
+    }
+
+    override fun onStart() {
+        super.onStart()
+        if (::mapView.isInitialized) {
+            mapView.onStart()
+        }
+    }
+
+    override fun onStop() {
+        super.onStop()
+        if (::mapView.isInitialized) {
+            mapView.onStop()
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        if (::mapView.isInitialized) {
+            mapView.onDestroy()
+        }
+        if (::routeLineApi.isInitialized) {
+            routeLineApi.cancel()
+        }
+    }
+
+    override fun onLowMemory() {
+        super.onLowMemory()
+        if (::mapView.isInitialized) {
+            mapView.onLowMemory()
+        }
+    }
+
+    private val routesObserver = RoutesObserver { routeUpdateResult ->
+        if (routeUpdateResult.navigationRoutes.isNotEmpty()) {
+            routeLineApi.setNavigationRoutes(routeUpdateResult.navigationRoutes) { value ->
+                mapView.mapboxMap.style?.apply { routeLineView.renderRouteDrawData(this, value) }
+            }
+            viewportDataSource.onRouteChanged(routeUpdateResult.navigationRoutes.first())
+            viewportDataSource.evaluate()
+            navigationCamera.requestNavigationCameraToOverview()
+        }
+    }
+
+    private val locationObserver = object : LocationObserver {
+        override fun onNewRawLocation(rawLocation: Location) {}
+        override fun onNewLocationMatcherResult(locationMatcherResult: LocationMatcherResult) {
+            val enhancedLocation = locationMatcherResult.enhancedLocation
+            navigationLocationProvider.changePosition(
+                location = enhancedLocation,
+                keyPoints = locationMatcherResult.keyPoints,
+            )
+            viewportDataSource.onLocationChanged(enhancedLocation)
+            viewportDataSource.evaluate()
+            navigationCamera.requestNavigationCameraToFollowing()
+        }
+    }
+
+    @OptIn(ExperimentalPreviewMapboxNavigationAPI::class)
+    private val mapboxNavigation: MapboxNavigation by requireMapboxNavigation(
+        onResumedObserver = object : MapboxNavigationObserver {
+            @SuppressLint("MissingPermission")
+            override fun onAttached(mapboxNavigation: MapboxNavigation) {
+                mapboxNavigation.registerRoutesObserver(routesObserver)
+                mapboxNavigation.registerLocationObserver(locationObserver)
+                if (simulateRoute) {
+                    replayProgressObserver = ReplayProgressObserver(mapboxNavigation.mapboxReplayer)
+                    mapboxNavigation.registerRouteProgressObserver(replayProgressObserver)
+                    mapboxNavigation.startReplayTripSession()
+                } else {
+                    mapboxNavigation.startTripSession()
+                }
+            }
+            override fun onDetached(mapboxNavigation: MapboxNavigation) {
+                mapboxNavigation.unregisterRoutesObserver(routesObserver)
+                mapboxNavigation.unregisterLocationObserver(locationObserver)
+                if (simulateRoute && ::replayProgressObserver.isInitialized) {
+                    mapboxNavigation.unregisterRouteProgressObserver(replayProgressObserver)
+                }
+                mapboxNavigation.stopTripSession()
+                if (simulateRoute) {
+                    mapboxNavigation.mapboxReplayer.finish()
+                }
+            }
+        },
+        onInitialize = this::initNavigation
+    )
+
+    @OptIn(ExperimentalPreviewMapboxNavigationAPI::class)
+    private fun initNavigation() {
+        // MapboxNavigationApp.setup is already called in the plugin implementation
+        
+        mapView.location.apply {
+            setLocationProvider(navigationLocationProvider)
+            this.locationPuck = createDefault2DPuck( true)
+            puckBearingEnabled = true
+            puckBearing = PuckBearing.COURSE
+            enabled = true
+        }
+
+        val origin = Point.fromLngLat(originLng, originLat)
+        val destination = Point.fromLngLat(destLng, destLat)
+
+        mapboxNavigation.requestRoutes(
+            RouteOptions.builder()
+                .applyDefaultNavigationOptions()
+                .coordinatesList(listOf(origin, destination))
+                .layersList(listOf(mapboxNavigation.getZLevel(), null))
+                .build(),
+            object : NavigationRouterCallback {
+                override fun onCanceled(routeOptions: RouteOptions, routerOrigin: String) {}
+                override fun onFailure(reasons: List<RouterFailure>, routeOptions: RouteOptions) {
+                    val errorMessage = reasons.joinToString(", ") { it.message }
+                    android.util.Log.e("NavigationActivity", "Route request failed: $errorMessage")
+                    Toast.makeText(this@NavigationActivity, "Route failed: $errorMessage", Toast.LENGTH_LONG).show()
+                }
+                override fun onRoutesReady(routes: List<NavigationRoute>, routerOrigin: String) {
+                    if (routes.isEmpty()) {
+                        Toast.makeText(this@NavigationActivity, "No routes found", Toast.LENGTH_SHORT).show()
+                        return
+                    }
+                    mapboxNavigation.setNavigationRoutes(routes)
+                    if (simulateRoute) {
+                        val replayData = replayRouteMapper.mapDirectionsRouteGeometry(routes.first().directionsRoute)
+                        mapboxNavigation.mapboxReplayer.pushEvents(replayData)
+                        mapboxNavigation.mapboxReplayer.seekTo(replayData[0])
+                        mapboxNavigation.mapboxReplayer.play()
+                    }
+                }
+            }
+        )
+    }
+}