react-native-brouter 0.0.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 jhotadhari
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# react-native-brouter
+
+React Native Turbo Module for Android to communicate with the [BRouter](https://github.com/abrensch/brouter) Android app service for offline routing/navigation based on OpenStreetMap data.
+
+## Installation
+
+```sh
+npm install react-native-brouter
+```
+
+Add this to your app's `AndroidManifest.xml`:
+```xml
+<queries>
+    <package android:name="btools.routingapp" />
+</queries>
+```
+
+Install the [BRouter Android app](https://github.com/abrensch/brouter) on the device.
+
+## Usage
+
+### Core API
+
+```ts
+import { getRoute, type Waypoint } from 'react-native-brouter';
+
+const waypoints: Waypoint[] = [
+  { position: [-71.047736, -13.950089] },
+  { position: [-70.902377, -13.791436] },
+  { position: [-70.97545, -13.591525] },
+];
+
+try {
+  const result = await getRoute({
+    waypoints,
+    vehicle: 'bicycle',
+    format: 'json',
+  });
+  console.log(result.raw); // JSON track string
+} catch (e) {
+  console.log(e.code);     // 'SERVICE_UNAVAILABLE' | 'INVALID_PARAMS' | ...
+  console.log(e.message);  // human-readable description
+}
+```
+
+### GeoJSON API (works with `@turf/turf`)
+
+```ts
+import { getRoute } from 'react-native-brouter/geojson';
+import turfAlong from '@turf/along';
+import { lineString, point } from '@turf/helpers';
+
+const result = await getRoute({
+  waypoints: [
+    [-71.047736, -13.950089],
+    [-70.902377, -13.791436],
+    [-70.97545, -13.591525],
+  ],
+  vehicle: 'bicycle',
+  format: 'json',
+});
+
+// result.parsed.track → GeoJSON FeatureCollection<LineString>
+// result.parsed.waypoints → GeoJSON FeatureCollection<Point>
+// result.parsed.summary → { totalDistanceMeters, totalDurationSeconds, ascentMeters, ... }
+
+// Use with turf:
+const line = lineString(result.parsed.track.features[0].geometry.coordinates);
+const midpoint = turfAlong(line, result.parsed.summary.totalDistanceMeters / 2);
+console.log(midpoint.geometry.coordinates); // [lng, lat] of route midpoint
+```
+
+### Nogo Areas
+
+```ts
+import { getRoute } from 'react-native-brouter';
+
+const result = await getRoute({
+  waypoints: [
+    { position: [10, 20] },
+    { position: [30, 40] },
+  ],
+  vehicle: 'foot',
+  nogos: [
+    { position: [15, 25], radiusMeters: 500 },           // simple circle
+    { position: [35, 45], radiusMeters: 1000, weight: 2 }, // weighted
+  ],
+});
+```
+
+### All Supported Options
+
+| Option | Type | Description |
+|---|---|---|
+| `waypoints` | `Waypoint[]` (≥2) | Route waypoints with position, optional name, optional direct flag |
+| `profile` | `string` | BRouter profile file name (without `.brf`) |
+| `remoteProfile` | `string` | Raw profile content (overrides `profile` + `vehicle` + `fast`) |
+| `vehicle` | `'motorcar' \| 'bicycle' \| 'foot'` | Travel mode |
+| `fast` | `boolean` | Fast mode (ignored if `remoteProfile` is set) |
+| `format` | `'gpx' \| 'kml' \| 'json'` | Output format (default `'gpx'`) |
+| `alternativeIndex` | `0 \| 1 \| 2 \| 3` | Alternative route index (default 0) |
+| `nogos` | `NogoArea[]` | Exclusion zones (position + radiusMeters + optional weight) |
+| `polylines` | `Polyline[]` | Waypoint corridors |
+| `polygons` | `Polygon[]` | Area constraints |
+| `pois` | `Poi[]` | Points of interest in output |
+| `exportWaypoints` | `boolean` | Include waypoints in output |
+| `turnInstructionFormat` | `'osmand' \| 'locus'` | Turn instruction format |
+| `turnInstructionMode` | `'none' \| 'auto-choose' \| 'locus' \| 'osmand' \| 'comment' \| 'gpsies' \| 'orux' \| 'locus-old'` | Turn instruction detail level |
+| `heading` | `number` | Start direction in degrees |
+| `direction` | `number` | Recalculation start direction in degrees |
+| `elevation` | `boolean` | Request elevation data (`engineMode=2`) |
+| `maxRunningTime` | `number` | Routing timeout in seconds (default 60) |
+| `connectTimeout` | `number` | Connection timeout in ms (default 1000) |
+| `pathToFileResult` | `string` | Save result to file path instead of returning |
+| `acceptCompressedResult` | `boolean` | Compress gpx output |
+| `extraParams` | `Record<string, string>` | Profile setup key=value pairs |
+
+## License
+
+MIT
+
+---
+
+- Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
+- The Java code to connect to the BRouter service is copied from [OsmAnd](https://github.com/osmandapp/OsmAnd)

package/android/build.gradle

@@ -0,0 +1,110 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['BRouter_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.9.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["BRouter_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.jhotadhari.reactnative.brouter"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+    aidl true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  testOptions {
+    unitTests.returnDefaultValues = true
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.mockito:mockito-core:5.1.1"
+  testImplementation "net.bytebuddy:byte-buddy:1.14.12"
+  testImplementation "net.bytebuddy:byte-buddy-agent:1.14.12"
+}
+
+react {
+  jsRootDir = file("../src/")
+  libraryName = "BRouter"
+  codegenJavaPackageName = "com.jhotadhari.reactnative.brouter"
+}

package/android/generated/java/com/jhotadhari/reactnative/brouter/NativeBRouterSpec.java

@@ -0,0 +1,39 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.jhotadhari.reactnative.brouter;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeBRouterSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "BRouter";
+
+  public NativeBRouterSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getRoute(ReadableMap params, Promise promise);
+}

package/android/generated/jni/CMakeLists.txt

@@ -0,0 +1,28 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB react_codegen_SRCS CONFIGURE_DEPENDS *.cpp react/renderer/components/RNBRouterSpec/*.cpp)
+
+add_library(
+  react_codegen_RNBRouterSpec
+  OBJECT
+  ${react_codegen_SRCS}
+)
+
+target_include_directories(react_codegen_RNBRouterSpec PUBLIC . react/renderer/components/RNBRouterSpec)
+
+target_link_libraries(
+  react_codegen_RNBRouterSpec
+  fbjni
+  jsi
+  # We need to link different libraries based on whether we are building rncore or not, that's necessary
+  # because we want to break a circular dependency between react_codegen_rncore and reactnative
+  reactnative
+)
+
+target_compile_reactnative_options(react_codegen_RNBRouterSpec PRIVATE)

package/android/generated/jni/RNBRouterSpec-generated.cpp

@@ -0,0 +1,32 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniCpp.js
+ */
+
+#include "RNBRouterSpec.h"
+
+namespace facebook::react {
+
+static facebook::jsi::Value __hostFunction_NativeBRouterSpecJSI_getRoute(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "getRoute", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+NativeBRouterSpecJSI::NativeBRouterSpecJSI(const JavaTurboModule::InitParams &params)
+  : JavaTurboModule(params) {
+  methodMap_["getRoute"] = MethodMetadata {1, __hostFunction_NativeBRouterSpecJSI_getRoute};
+}
+
+std::shared_ptr<TurboModule> RNBRouterSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+  if (moduleName == "BRouter") {
+    return std::make_shared<NativeBRouterSpecJSI>(params);
+  }
+  return nullptr;
+}
+
+} // namespace facebook::react

package/android/generated/jni/RNBRouterSpec.h

@@ -0,0 +1,31 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+/**
+ * JNI C++ class for module 'NativeBRouter'
+ */
+class JSI_EXPORT NativeBRouterSpecJSI : public JavaTurboModule {
+public:
+  NativeBRouterSpecJSI(const JavaTurboModule::InitParams &params);
+};
+
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> RNBRouterSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params);
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/RNBRouterSpec/RNBRouterSpecJSI.h

@@ -0,0 +1,38 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+template <typename T>
+class JSI_EXPORT NativeBRouterCxxSpec : public TurboModule {
+public:
+  static constexpr std::string_view kModuleName = "BRouter";
+
+protected:
+  NativeBRouterCxxSpec(std::shared_ptr<CallInvoker> jsInvoker) : TurboModule(std::string{NativeBRouterCxxSpec::kModuleName}, jsInvoker) {
+    methodMap_["getRoute"] = MethodMetadata {.argCount = 1, .invoker = __getRoute};
+  }
+  
+private:
+  static jsi::Value __getRoute(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::getRoute) == 2,
+      "Expected getRoute(...) to have 2 parameters");
+    return bridging::callFromJs<jsi::Value>(rt, &T::getRoute,  static_cast<NativeBRouterCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asObject(rt));
+  }
+};
+
+} // namespace facebook::react

package/android/gradle.properties

@@ -0,0 +1,5 @@
+BRouter_kotlinVersion=2.0.21
+BRouter_minSdkVersion=24
+BRouter_targetSdkVersion=34
+BRouter_compileSdkVersion=35
+BRouter_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.jhotadhari.reactnative.brouter">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/aidl/btools/routingapp/IBRouterService.aidl

@@ -0,0 +1,47 @@
+package btools.routingapp;
+
+// Copy of https://github.com/abrensch/brouter/blob/master/brouter-routing-app/src/main/aidl/btools/routingapp/IBRouterService.aidl
+
+interface IBRouterService {
+
+
+    //param params--> Map of params:
+    //  "pathToFileResult"-->String with the path to where the result must be saved, including file name and extension
+    //                    -->if null, the track is passed via the return argument, this should be default when Android Q or later
+    //  "maxRunningTime"-->String with a number of seconds for the routing timeout, default = 60
+    //  "turnInstructionFormat"-->String selecting the format for turn-instructions values: osmand, locus
+    //  "trackFormat"-->[kml|gpx|json] default = gpx
+    //  "acceptCompressedResult"-->[true] sends a compressed result when output format is gpx
+    //  "lats"-->double[] array of latitudes; 2 values at least.
+    //  "lons"-->double[] array of longitudes; 2 values at least.
+    //  "nogoLats"-->double[] array of nogo latitudes; may be null.
+    //  "nogoLons"-->double[] array of nogo longitudes; may be null.
+    //  "nogoRadi"-->double[] array of nogo radius in meters; may be null.
+    //  "fast"-->[0|1]
+    //  "v"-->[motorcar|bicycle|foot]
+    //  "remoteProfile"--> (String), net-content of a profile. If remoteProfile != null, v+fast are ignored
+    //
+    //  "lonlats"         = lon,lat|... (unlimited list of lon,lat waypoints separated by |)
+    //                      variantes: lon,lat,d|... (from this point to the next  do a direct line)
+    //                                 lon,lat,name|... (route point has a name and should not be ignored)
+    //  "straight"        = idx1,idx2,.. (optional, minimum one value, index of a direct routing point in the waypoint list)
+    //  "nogos"           = lon,lat,radius,weight|... (optional, list of lon, lat, radius in meters, weight (optional))
+    //  "polylines"       = lon,lat,lon,lat,...,weight|... (unlimited list of lon,lat and weight (optional), lists separated by |)
+    //  "polygons"        = lon,lat,lon,lat,...,weight|... (unlimited list of lon,lat and weight (optional), lists separated by |)
+    //  "profile"         = profile file name without .brf
+    //  "alternativeidx"  = [0|1|2|3] (optional, default 0)
+    //  "exportWaypoints" = 1 to export them (optional, default is no export)
+    //  "pois"            = lon,lat,name|... (optional)
+    //  "extraParams"     = Bundle key=value list for a profile setup (like "profile:")
+    //  "timode"          = turnInstructionMode [0=none, 1=auto-choose, 2=locus-style, 3=osmand-style, 4=comment-style, 5=gpsies-style, 6=orux-style, 7=locus-old-style] default 0
+    //  "heading"         = angle (optional to give a route a start direction)
+    //  "direction"       = angle (optional, used like "heading" on a recalculation request by Locus as start direction)
+    //  "engineMode"      = 0 (optional, default 0, 2 = get elevation)
+
+    // return null if all ok and no path given, the track if ok and path given, an error message if it was wrong
+    //        the resultas string when 'pathToFileResult' is null, this should be default when Android Q or later
+    // call in a background thread, heavy task!
+
+    String getTrackFromParams(in Bundle params);
+}
+