@atomiqlab/react-native-mapbox-navigation 1.1.0

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

@@ -0,0 +1,296 @@
+package expo.modules.mapboxnavigation
+
+import android.content.Intent
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class MapboxNavigationModule : Module() {
+  private var isNavigating = false
+
+  override fun definition() = ModuleDefinition {
+    Name("MapboxNavigationModule")
+
+    Events(
+      "onLocationChange",
+      "onRouteProgressChange",
+      "onBannerInstruction",
+      "onArrive",
+      "onCancelNavigation",
+      "onError"
+    )
+
+    OnCreate {
+      MapboxNavigationEventBridge.setEmitter { eventName, payload ->
+        sendEvent(eventName, payload)
+      }
+    }
+
+    OnDestroy {
+      MapboxNavigationEventBridge.clearEmitter()
+    }
+
+    AsyncFunction("startNavigation") { options: Map<String, Any?>, promise: Promise ->
+      startNavigation(options, promise)
+    }
+
+    AsyncFunction("stopNavigation") { promise: Promise ->
+      stopNavigation(promise)
+    }
+
+    AsyncFunction("setMuted") { _: Boolean, promise: Promise ->
+      // Voice control is handled by native navigation UI state.
+      promise.resolve(null)
+    }
+
+    AsyncFunction("setVoiceVolume") { _: Double, promise: Promise ->
+      promise.resolve(null)
+    }
+
+    AsyncFunction("setDistanceUnit") { _: String, promise: Promise ->
+      promise.resolve(null)
+    }
+
+    AsyncFunction("setLanguage") { _: String, promise: Promise ->
+      promise.resolve(null)
+    }
+
+    AsyncFunction("isNavigating") { promise: Promise ->
+      promise.resolve(isNavigating)
+    }
+
+    AsyncFunction("getNavigationSettings") { promise: Promise ->
+      promise.resolve(
+        mapOf(
+          "isNavigating" to isNavigating,
+          "mute" to false,
+          "voiceVolume" to 1.0,
+          "distanceUnit" to "metric",
+          "language" to "en"
+        )
+      )
+    }
+
+    View(MapboxNavigationView::class) {
+      Events(
+        "onLocationChange",
+        "onRouteProgressChange",
+        "onBannerInstruction",
+        "onArrive",
+        "onCancelNavigation",
+        "onError"
+      )
+
+      Prop("startOrigin") { view: MapboxNavigationView, origin: Map<String, Double> ->
+        view.setStartOrigin(origin)
+      }
+
+      Prop("destination") { view: MapboxNavigationView, destination: Map<String, Any> ->
+        view.setDestination(destination)
+      }
+
+      Prop("waypoints") { view: MapboxNavigationView, waypoints: List<Map<String, Any>>? ->
+        view.setWaypoints(waypoints)
+      }
+
+      Prop("shouldSimulateRoute") { view: MapboxNavigationView, simulate: Boolean ->
+        view.setShouldSimulateRoute(simulate)
+      }
+
+      Prop("showCancelButton") { view: MapboxNavigationView, show: Boolean ->
+        view.setShowCancelButton(show)
+      }
+
+      Prop("mute") { view: MapboxNavigationView, mute: Boolean ->
+        view.setMute(mute)
+      }
+
+      Prop("voiceVolume") { view: MapboxNavigationView, volume: Double ->
+        view.setVoiceVolume(volume)
+      }
+
+      Prop("cameraPitch") { view: MapboxNavigationView, pitch: Double ->
+        view.setCameraPitch(pitch)
+      }
+
+      Prop("cameraZoom") { view: MapboxNavigationView, zoom: Double ->
+        view.setCameraZoom(zoom)
+      }
+
+      Prop("cameraMode") { view: MapboxNavigationView, mode: String ->
+        view.setCameraMode(mode)
+      }
+
+      Prop("mapStyleUri") { view: MapboxNavigationView, styleUri: String ->
+        view.setMapStyleUri(styleUri)
+      }
+
+      Prop("mapStyleUriDay") { view: MapboxNavigationView, styleUri: String ->
+        view.setMapStyleUriDay(styleUri)
+      }
+
+      Prop("mapStyleUriNight") { view: MapboxNavigationView, styleUri: String ->
+        view.setMapStyleUriNight(styleUri)
+      }
+
+      Prop("uiTheme") { view: MapboxNavigationView, theme: String ->
+        view.setUiTheme(theme)
+      }
+
+      Prop("routeAlternatives") { view: MapboxNavigationView, routeAlternatives: Boolean ->
+        view.setRouteAlternatives(routeAlternatives)
+      }
+
+      Prop("showsSpeedLimits") { view: MapboxNavigationView, showsSpeedLimits: Boolean ->
+        view.setShowsSpeedLimits(showsSpeedLimits)
+      }
+
+      Prop("showsWayNameLabel") { view: MapboxNavigationView, showsWayNameLabel: Boolean ->
+        view.setShowsWayNameLabel(showsWayNameLabel)
+      }
+
+      Prop("showsTripProgress") { view: MapboxNavigationView, showsTripProgress: Boolean ->
+        view.setShowsTripProgress(showsTripProgress)
+      }
+
+      Prop("showsManeuverView") { view: MapboxNavigationView, showsManeuverView: Boolean ->
+        view.setShowsManeuverView(showsManeuverView)
+      }
+
+      Prop("showsActionButtons") { view: MapboxNavigationView, showsActionButtons: Boolean ->
+        view.setShowsActionButtons(showsActionButtons)
+      }
+
+      Prop("distanceUnit") { view: MapboxNavigationView, unit: String ->
+        view.setDistanceUnit(unit)
+      }
+
+      Prop("language") { view: MapboxNavigationView, language: String ->
+        view.setLanguage(language)
+      }
+    }
+  }
+
+  private fun startNavigation(options: Map<String, Any?>, promise: Promise) {
+    val activity = appContext.currentActivity
+    if (activity == null) {
+      promise.reject("NO_ACTIVITY", "No current activity", null)
+      return
+    }
+
+    val origin = options["startOrigin"] as? Map<*, *>
+    val destination = options["destination"] as? Map<*, *>
+
+    val originLat = (origin?.get("latitude") as? Number)?.toDouble()
+    val originLng = (origin?.get("longitude") as? Number)?.toDouble()
+    val destLat = (destination?.get("latitude") as? Number)?.toDouble()
+    val destLng = (destination?.get("longitude") as? Number)?.toDouble()
+
+    if (destLat == null || destLng == null) {
+      promise.reject("INVALID_COORDINATES", "Missing or invalid coordinates", null)
+      return
+    }
+
+    val shouldSimulate = (options["shouldSimulateRoute"] as? Boolean) ?: false
+    val mute = (options["mute"] as? Boolean) ?: false
+    val cameraPitch = (options["cameraPitch"] as? Number)?.toDouble()
+    val cameraZoom = (options["cameraZoom"] as? Number)?.toDouble()
+    val cameraMode = (options["cameraMode"] as? String) ?: "following"
+    val mapStyleUri = (options["mapStyleUri"] as? String) ?: ""
+    val mapStyleUriDay = (options["mapStyleUriDay"] as? String) ?: ""
+    val mapStyleUriNight = (options["mapStyleUriNight"] as? String) ?: ""
+    val uiTheme = (options["uiTheme"] as? String) ?: "system"
+    val routeAlternatives = (options["routeAlternatives"] as? Boolean) ?: false
+    val showsSpeedLimits = (options["showsSpeedLimits"] as? Boolean) ?: true
+    val showsWayNameLabel = (options["showsWayNameLabel"] as? Boolean) ?: true
+    val showsTripProgress = (options["showsTripProgress"] as? Boolean) ?: true
+    val showsManeuverView = (options["showsManeuverView"] as? Boolean) ?: true
+    val showsActionButtons = (options["showsActionButtons"] as? Boolean) ?: true
+    val waypoints = parseCoordinatesList(options["waypoints"] as? List<*>)
+
+    activity.runOnUiThread {
+      val accessToken = try {
+        getMapboxAccessToken(activity.packageName)
+      } catch (e: IllegalStateException) {
+        promise.reject("MISSING_ACCESS_TOKEN", e.message ?: "Missing mapbox_access_token", e)
+        return@runOnUiThread
+      }
+
+      val intent = Intent(activity, MapboxNavigationActivity::class.java).apply {
+        putExtra("accessToken", accessToken)
+        if (originLat != null && originLng != null) {
+          putExtra("originLat", originLat)
+          putExtra("originLng", originLng)
+        }
+        putExtra("destLat", destLat)
+        putExtra("destLng", destLng)
+        putExtra("shouldSimulate", shouldSimulate)
+        putExtra("mute", mute)
+        putExtra("cameraPitch", cameraPitch)
+        putExtra("cameraZoom", cameraZoom)
+        putExtra("cameraMode", cameraMode)
+        putExtra("mapStyleUri", mapStyleUri)
+        putExtra("mapStyleUriDay", mapStyleUriDay)
+        putExtra("mapStyleUriNight", mapStyleUriNight)
+        putExtra("uiTheme", uiTheme)
+        putExtra("routeAlternatives", routeAlternatives)
+        putExtra("showsSpeedLimits", showsSpeedLimits)
+        putExtra("showsWayNameLabel", showsWayNameLabel)
+        putExtra("showsTripProgress", showsTripProgress)
+        putExtra("showsManeuverView", showsManeuverView)
+        putExtra("showsActionButtons", showsActionButtons)
+        if (waypoints.isNotEmpty()) {
+          putExtra("waypointLats", waypoints.map { it.first }.toDoubleArray())
+          putExtra("waypointLngs", waypoints.map { it.second }.toDoubleArray())
+        }
+      }
+
+      activity.startActivity(intent)
+      isNavigating = true
+      promise.resolve(null)
+    }
+  }
+
+  private fun getMapboxAccessToken(packageName: String): String {
+    val context = appContext.reactContext ?: throw IllegalStateException("Missing React context")
+    val resourceId = context.resources.getIdentifier(
+      "mapbox_access_token",
+      "string",
+      packageName
+    )
+
+    if (resourceId == 0) {
+      throw IllegalStateException("Missing string resource: mapbox_access_token")
+    }
+
+    val token = context.getString(resourceId).trim()
+    if (token.isEmpty()) {
+      throw IllegalStateException("mapbox_access_token is empty")
+    }
+
+    return token
+  }
+
+  private fun stopNavigation(promise: Promise) {
+    val activity = appContext.currentActivity
+    activity?.finish()
+    isNavigating = false
+    promise.resolve(null)
+  }
+
+  private fun parseCoordinatesList(value: List<*>?): List<Pair<Double, Double>> {
+    if (value.isNullOrEmpty()) {
+      return emptyList()
+    }
+
+    return value.mapNotNull { item ->
+      val map = item as? Map<*, *> ?: return@mapNotNull null
+      val latitude = (map["latitude"] as? Number)?.toDouble() ?: return@mapNotNull null
+      val longitude = (map["longitude"] as? Number)?.toDouble() ?: return@mapNotNull null
+      if (latitude < -90.0 || latitude > 90.0 || longitude < -180.0 || longitude > 180.0) {
+        return@mapNotNull null
+      }
+      latitude to longitude
+    }
+  }
+}

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

@@ -0,0 +1,143 @@
+package expo.modules.mapboxnavigation
+
+import android.content.Context
+import android.view.Gravity
+import android.widget.FrameLayout
+import android.widget.TextView
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.viewevent.EventDispatcher
+import expo.modules.kotlin.views.ExpoView
+
+class MapboxNavigationView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+  private var startOrigin: Map<String, Double>? = null
+  private var destination: Map<String, Any>? = null
+  private var waypoints: List<Map<String, Any>>? = null
+  private var shouldSimulateRoute = false
+  private var showCancelButton = true
+  private var mute = false
+  private var voiceVolume = 1.0
+  private var cameraPitch = 0.0
+  private var cameraZoom = 14.0
+  private var cameraMode = "following"
+  private var mapStyleUri = ""
+  private var mapStyleUriDay = ""
+  private var mapStyleUriNight = ""
+  private var uiTheme = "system"
+  private var routeAlternatives = false
+  private var showsSpeedLimits = true
+  private var showsWayNameLabel = true
+  private var showsTripProgress = true
+  private var showsManeuverView = true
+  private var showsActionButtons = true
+  private var distanceUnit = "metric"
+  private var language = "en"
+
+  val onLocationChange by EventDispatcher()
+  val onRouteProgressChange by EventDispatcher()
+  val onBannerInstruction by EventDispatcher()
+  val onArrive by EventDispatcher()
+  val onCancelNavigation by EventDispatcher()
+  val onError by EventDispatcher()
+
+  init {
+    val label = TextView(context).apply {
+      text = "Mapbox native navigation view is initializing..."
+      gravity = Gravity.CENTER
+    }
+    addView(
+      label,
+      FrameLayout.LayoutParams(
+        FrameLayout.LayoutParams.MATCH_PARENT,
+        FrameLayout.LayoutParams.MATCH_PARENT
+      )
+    )
+  }
+
+  fun setStartOrigin(origin: Map<String, Double>) {
+    startOrigin = origin
+  }
+
+  fun setDestination(dest: Map<String, Any>) {
+    destination = dest
+  }
+
+  fun setWaypoints(wps: List<Map<String, Any>>?) {
+    waypoints = wps
+  }
+
+  fun setShouldSimulateRoute(simulate: Boolean) {
+    shouldSimulateRoute = simulate
+  }
+
+  fun setShowCancelButton(show: Boolean) {
+    showCancelButton = show
+  }
+
+  fun setMute(muted: Boolean) {
+    mute = muted
+  }
+
+  fun setVoiceVolume(volume: Double) {
+    voiceVolume = volume
+  }
+
+  fun setCameraPitch(pitch: Double) {
+    cameraPitch = pitch
+  }
+
+  fun setCameraZoom(zoom: Double) {
+    cameraZoom = zoom
+  }
+
+  fun setCameraMode(mode: String) {
+    cameraMode = mode
+  }
+
+  fun setMapStyleUri(styleUri: String) {
+    mapStyleUri = styleUri
+  }
+
+  fun setMapStyleUriDay(styleUri: String) {
+    mapStyleUriDay = styleUri
+  }
+
+  fun setMapStyleUriNight(styleUri: String) {
+    mapStyleUriNight = styleUri
+  }
+
+  fun setUiTheme(theme: String) {
+    uiTheme = theme
+  }
+
+  fun setRouteAlternatives(enabled: Boolean) {
+    routeAlternatives = enabled
+  }
+
+  fun setShowsSpeedLimits(enabled: Boolean) {
+    showsSpeedLimits = enabled
+  }
+
+  fun setShowsWayNameLabel(enabled: Boolean) {
+    showsWayNameLabel = enabled
+  }
+
+  fun setShowsTripProgress(enabled: Boolean) {
+    showsTripProgress = enabled
+  }
+
+  fun setShowsManeuverView(enabled: Boolean) {
+    showsManeuverView = enabled
+  }
+
+  fun setShowsActionButtons(enabled: Boolean) {
+    showsActionButtons = enabled
+  }
+
+  fun setDistanceUnit(unit: String) {
+    distanceUnit = unit
+  }
+
+  fun setLanguage(lang: String) {
+    language = lang
+  }
+}

package/app.plugin.js

@@ -0,0 +1,154 @@
+const {
+  withProjectBuildGradle,
+  withAppBuildGradle,
+  withAndroidManifest,
+  withInfoPlist,
+  createRunOncePlugin,
+} = require("@expo/config-plugins");
+
+const MAPBOX_REPO_BLOCK = `    maven {
+      url 'https://api.mapbox.com/downloads/v2/releases/maven'
+      authentication {
+        basic(BasicAuthentication)
+      }
+      credentials {
+        username = "mapbox"
+        password = mapboxDownloadsToken
+      }
+    }`;
+
+const MAPBOX_TOKEN_LINES = `        def mapboxPublicToken = project.findProperty("MAPBOX_PUBLIC_TOKEN") ?: System.getenv("EXPO_PUBLIC_MAPBOX_ACCESS_TOKEN") ?: ""
+        resValue "string", "mapbox_access_token", mapboxPublicToken`;
+
+const REQUIRED_ANDROID_PERMISSIONS = [
+  "android.permission.ACCESS_COARSE_LOCATION",
+  "android.permission.ACCESS_FINE_LOCATION",
+  "android.permission.ACCESS_BACKGROUND_LOCATION",
+  "android.permission.FOREGROUND_SERVICE",
+  "android.permission.FOREGROUND_SERVICE_LOCATION",
+  "android.permission.POST_NOTIFICATIONS",
+];
+
+const DEFAULT_IOS_LOCATION_USAGE =
+  "Allow $(PRODUCT_NAME) to access your location for turn-by-turn navigation.";
+
+function ensureAndroidPermissions(androidManifest) {
+  const manifest = androidManifest.manifest;
+  if (!manifest["uses-permission"]) {
+    manifest["uses-permission"] = [];
+  }
+
+  const existingPermissions = new Set(
+    manifest["uses-permission"]
+      .map((entry) => entry?.$?.["android:name"])
+      .filter(Boolean)
+  );
+
+  REQUIRED_ANDROID_PERMISSIONS.forEach((permission) => {
+    if (!existingPermissions.has(permission)) {
+      manifest["uses-permission"].push({
+        $: {
+          "android:name": permission,
+        },
+      });
+    }
+  });
+
+  return androidManifest;
+}
+
+function ensureProjectBuildGradle(src) {
+  let out = src;
+
+  if (!out.includes("def mapboxDownloadsToken =")) {
+    out =
+      `def mapboxDownloadsToken = (findProperty("MAPBOX_DOWNLOADS_TOKEN") ?: System.getenv("MAPBOX_DOWNLOADS_TOKEN") ?: "")\n` +
+      `  .toString()\n` +
+      `  .replace('"', '')\n` +
+      `  .trim()\n\n` +
+      out;
+  }
+
+  if (!out.includes("https://api.mapbox.com/downloads/v2/releases/maven")) {
+    out = out.replace(
+      /allprojects\s*\{\s*repositories\s*\{\s*google\(\)\s*mavenCentral\(\)/m,
+      (match) => `${match}\n${MAPBOX_REPO_BLOCK}`
+    );
+  }
+
+  return out;
+}
+
+function ensureAppBuildGradle(src) {
+  if (src.includes('resValue "string", "mapbox_access_token"')) {
+    return src;
+  }
+
+  return src.replace(
+    /(versionName\s+"[^"]+"\s*\n)/m,
+    `$1${MAPBOX_TOKEN_LINES}\n`
+  );
+}
+
+function withMapboxNavigationAndroid(config) {
+  config = withProjectBuildGradle(config, (config) => {
+    config.modResults.contents = ensureProjectBuildGradle(
+      config.modResults.contents
+    );
+    return config;
+  });
+
+  config = withAppBuildGradle(config, (config) => {
+    config.modResults.contents = ensureAppBuildGradle(config.modResults.contents);
+    return config;
+  });
+
+  config = withAndroidManifest(config, (config) => {
+    config.modResults = ensureAndroidPermissions(config.modResults);
+    return config;
+  });
+
+  return config;
+}
+
+function withMapboxNavigationIos(config) {
+  return withInfoPlist(config, (config) => {
+    const infoPlist = config.modResults;
+    const mapboxPublicToken =
+      process.env.EXPO_PUBLIC_MAPBOX_ACCESS_TOKEN ||
+      process.env.MAPBOX_PUBLIC_TOKEN ||
+      "";
+
+    if (!infoPlist.MBXAccessToken && mapboxPublicToken) {
+      infoPlist.MBXAccessToken = mapboxPublicToken;
+    }
+
+    if (!infoPlist.NSLocationWhenInUseUsageDescription) {
+      infoPlist.NSLocationWhenInUseUsageDescription = DEFAULT_IOS_LOCATION_USAGE;
+    }
+
+    if (!infoPlist.NSLocationAlwaysAndWhenInUseUsageDescription) {
+      infoPlist.NSLocationAlwaysAndWhenInUseUsageDescription = DEFAULT_IOS_LOCATION_USAGE;
+    }
+
+    const existingModes = Array.isArray(infoPlist.UIBackgroundModes)
+      ? infoPlist.UIBackgroundModes
+      : [];
+    const mergedModes = new Set([...existingModes, "location", "audio"]);
+    infoPlist.UIBackgroundModes = Array.from(mergedModes);
+
+    return config;
+  });
+}
+
+const withMapboxNavigation = (config) => {
+  config = withMapboxNavigationAndroid(config);
+  config = withMapboxNavigationIos(config);
+  return config;
+};
+
+module.exports = createRunOncePlugin(
+  withMapboxNavigation,
+  "react-native-mapbox-navigation-plugin",
+  "1.1.0"
+);

package/docs/PUBLISHING.md

@@ -0,0 +1,97 @@
+# Publishing & CI/CD Guide
+
+## 1. Create the package repository
+
+Recommended repo name: `react-native-mapbox-navigation`.
+
+Use this module as the repository root (do not keep it under `modules/` after copying).
+
+Required top-level items:
+- `src/`, `android/`, `ios/`
+- `app.plugin.js`, `expo-module.config.json`, `package.json`
+- `README.md`, `QUICKSTART.md`, `CHANGELOG.md`, `docs/`
+- `.github/workflows/`
+- `website/` (GitHub Pages)
+
+## 2. Prepare GitHub repo
+
+1. Create GitHub repo `react-native-mapbox-navigation`.
+2. Copy this folder contents into that repo root.
+3. Push initial commit:
+
+```bash
+git init
+git add .
+git commit -m "chore: initial release-ready package"
+git branch -M main
+git remote add origin git@github.com:<your-org-or-user>/react-native-mapbox-navigation.git
+git push -u origin main
+```
+
+## 3. Enable CI
+
+This package includes workflow templates you can use directly:
+- `.github/workflows/ci.yml`
+- `.github/workflows/deploy-pages.yml`
+
+`ci.yml` validates:
+- TypeScript check (`npx tsc --noEmit`)
+- Android module compile (`./gradlew ...compileDebugKotlin`)
+- npm tarball dry-run (`npm pack --dry-run`)
+
+## 4. Enable GitHub Pages
+
+1. In GitHub repo: `Settings -> Pages`.
+2. Source: `GitHub Actions`.
+3. Keep `website/` as docs source for deployed site.
+4. Push to `main`; workflow will publish automatically.
+
+## 5. Local release verification
+
+From package root:
+
+```bash
+npm run verify
+```
+
+This runs:
+1. TypeScript check
+2. Android compile check
+3. `npm pack --dry-run`
+
+## 6. Test before npm publish
+
+### Pack locally
+
+```bash
+npm pack --cache /tmp/npm-cache-react-native-mapbox-navigation
+```
+
+### Install in a clean test app
+
+```bash
+npm install /absolute/path/to/react-native-mapbox-navigation-<version>.tgz
+```
+
+Then validate both platforms:
+
+```bash
+npx expo prebuild --clean
+npx expo run:android
+npx expo run:ios
+```
+
+## 7. Publish steps (after testing)
+
+```bash
+npm version patch   # or minor / major
+git push --follow-tags
+npm publish --access public
+```
+
+## 8. Recommended production setup
+
+- Protect `main` and require PR checks.
+- Enable npm trusted publishing from GitHub Actions.
+- Create GitHub Releases for each version tag.
+- Keep `CHANGELOG.md` updated per release.