react-native-ipostmap-navigation 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 IOTLink
+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,109 @@
+# react-native-ipostmap-navigation
+
+iPostMap Navigation SDK for React Native
+
+## Installation
+
+
+```sh
+npm install react-native-ipostmap-navigation
+```
+
+## Setup API key
+
+The API key is a unique identifier that authenticates requests associated with your project for usage and billing purposes. You must have at least one API key associated with your project.
+
+Get an API key at <https://map.ipostmap.vn/user> > Developer > Key
+
+### Android
+
+Provide access key from `android/app/src/main/AndroidManifest.xml`
+
+```xml
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application>
+        <meta-data
+            android:name="vn.map4d.map.ACCESS_KEY"
+            android:value="YOUR_MAP_ACCESS_KEY"/>
+        <meta-data
+            android:name="vn.map4d.services.ACCESS_KEY"
+            android:value="YOUR_SERVICES_ACCESS_KEY"/>
+    </application>
+</manifest>
+```
+
+### iOS
+
+Provide access key from `ios/Runner/Info.plist`
+
+```xml
+<key>Map4dMapAccessKey</key>
+<string>YOUR_MAP_ACCESS_KEY</string>
+<key>Map4dServicesAccessKey</key>
+<string>YOUR_SERVICES_ACCESS_KEY</string>
+```
+
+## Usage
+
+
+```js
+import { View, StyleSheet, Button, Alert } from 'react-native';
+import { startMapNavigation } from 'react-native-ipostmap-navigation';
+import { fetchDirections, type MFDirectionsParams } from 'react-native-ipostmap-services';
+
+const startNavigation = async () => {
+  const params: MFDirectionsParams = {
+    origin: { latitude: 16.039572, longitude: 108.212173 },
+    destination: { latitude: 16.048087, longitude: 108.246115 },
+    mode: "car"
+  }
+
+  const response = await fetchDirections(params)
+
+  if (response.code !== 'ok') {
+    console.log(`Get directions error with code: ${response.code}, message: ${response.message}`)
+    Alert.alert(response.code, response.message)
+    return
+  }
+
+  const result = response.result
+  if (!result || typeof result !== 'object') {
+    Alert.alert('Invalid directions result', result)
+    return
+  }
+
+  const routes = result.routes
+  if (!routes || !Array.isArray(routes)) {
+    Alert.alert('Invalid directions routes', routes)
+    return
+  }
+
+  if (routes.length == 0) {
+    Alert.alert('Direction rout not found')
+    return
+  }
+
+  const routeIndex = Math.floor(Math.random() * routes.length)
+  startMapNavigation(result, routeIndex, params)
+}
+
+export default function App() {
+  return (
+    <View style={styles.container}>
+      <Button
+        onPress={startNavigation}
+        title='Start Navigation'
+      />
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+});
+
+```

package/android/build.gradle

@@ -0,0 +1,86 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Map4dNavigationReactNative_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // 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["Map4dNavigationReactNative_" + name]).toInteger()
+}
+
+android {
+  namespace "com.map4dnavigationreactnative"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  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"
+  implementation "androidx.constraintlayout:constraintlayout:1.1.3"
+  implementation 'com.google.android.material:material:1.4.0'
+
+  implementation 'vn.map4d:iPostMapNavigationCore:1.0.+'
+  implementation 'vn.map4d:iPostMapNavigation:1.0.+'
+
+  implementation 'vn.map4d:iPostMap:1.0.+'
+  implementation 'vn.map4d:iPostMapServices:1.0.+'
+  implementation 'vn.map4d:Map4dTypes:1.1.+'
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Map4dNavigationReactNative_kotlinVersion=2.0.21
+Map4dNavigationReactNative_minSdkVersion=24
+Map4dNavigationReactNative_targetSdkVersion=34
+Map4dNavigationReactNative_compileSdkVersion=35
+Map4dNavigationReactNative_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <application>
+    <activity
+      android:name=".RMFNavigationActivity"
+      android:exported="false" />
+  </application>
+
+</manifest>

package/android/src/main/java/com/map4dnavigationreactnative/JsonUtils.java

@@ -0,0 +1,303 @@
+package com.map4dnavigationreactnative;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import vn.map4d.services.MFLocationComponent;
+import vn.map4d.services.directions.MFDirectionOptions;
+import vn.map4d.services.directions.MFManeuver;
+import vn.map4d.services.directions.MFRoute;
+import vn.map4d.services.directions.MFRouteRestriction;
+import vn.map4d.services.directions.MFTravelMode;
+import vn.map4d.services.directions.MFWeighting;
+import vn.map4d.services.internal.JsonParser;
+
+class JsonUtils {
+
+  static MFDirectionOptions toDirectionOptions(String json) {
+    try {
+      JSONObject jsonObject = new JSONObject(json);
+      MFLocationComponent origin = toLocationComponent(JsonParser.getJsonObject("origin", jsonObject));
+      MFLocationComponent destination = toLocationComponent(JsonParser.getJsonObject("destination", jsonObject));
+      MFDirectionOptions.Builder directionOptionsBuilder = new MFDirectionOptions.Builder()
+        .origin(origin)
+        .destination(destination);
+
+      String mode = JsonParser.getString("mode", jsonObject);
+      if (mode != null) {
+        MFTravelMode travelMode = MFTravelMode.fromValue(mode);
+        if (travelMode != null) {
+          directionOptionsBuilder.mode(travelMode);
+        }
+      }
+
+      String weightingString = JsonParser.getString("weighting", jsonObject);
+      if (weightingString != null) {
+        MFWeighting weighting = weightingFromValue(weightingString);
+        if (weighting != null) {
+          directionOptionsBuilder.weighting(weighting);
+        }
+      }
+
+      String language = JsonParser.getString("language", jsonObject);
+      if (language != null) {
+        directionOptionsBuilder.language(language);
+      }
+
+      List<MFLocationComponent> waypoints = new ArrayList<>();
+      JSONArray waypointsArray = JsonParser.getJsonArray("waypoints", jsonObject);
+      if (waypointsArray != null) {
+        for (int i = 0; i < waypointsArray.length(); ++i) {
+          JSONObject waypointJsonObject = waypointsArray.getJSONObject(i);
+          if (waypointJsonObject != null) {
+            waypoints.add(toLocationComponent(waypointJsonObject));
+          }
+        }
+      }
+      if (!waypoints.isEmpty()) {
+        directionOptionsBuilder.waypoints(waypoints);
+      }
+
+      JSONObject restrictionJsonObject = JsonParser.getJsonObject("restriction", jsonObject);
+      if (restrictionJsonObject != null) {
+        directionOptionsBuilder.restriction(routeRestrictionFromJsonObject(restrictionJsonObject));
+      }
+
+      MFDirectionOptions directionOptions = directionOptionsBuilder.build();
+      return directionOptions;
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+
+  static ArrayList<MFRoute> toDirectionsRoute(String json) {
+    try {
+      ArrayList<MFRoute> routes = new ArrayList<>();
+      JSONObject jsonObject = new JSONObject(json);
+      JSONArray routesArrays = JsonParser.getJsonArray("routes", jsonObject);
+      for (int i = 0; i < Objects.requireNonNull(routesArrays).length(); ++i) {
+        JSONObject routeObject = routesArrays.getJSONObject(i);
+        if (routeObject != null) {
+          MFRoute route = toRoute(routeObject);
+          if (route != null) {
+            routes.add(route);
+          }
+        }
+      }
+      return routes;
+    } catch (Exception e) {
+      return null;
+    }
+  }
+
+  @Nullable
+  private static MFWeighting weightingFromValue(@Nonnull String value) {
+    switch (value.toLowerCase()) {
+      case "shortest":
+        return MFWeighting.SHORTEST;
+      case "fastest":
+        return MFWeighting.FASTEST;
+      case "balance":
+        return MFWeighting.BALANCE;
+      default:
+        return null;
+    }
+  }
+
+  @Nullable
+  private static MFRouteRestriction routeRestrictionFromJsonObject(@Nullable JSONObject jsonObject) {
+    // Types
+    List<MFRouteRestriction.MFRouteType> types = null;
+    JSONArray typesArr = jsonObject.optJSONArray("types");
+    if (typesArr != null) {
+      types = new ArrayList<>();
+      for (int i = 0; i < typesArr.length(); i++) {
+        String t = typesArr.optString(i, null);
+        MFRouteRestriction.MFRouteType type = MFRouteRestriction.MFRouteType.fromValue(t);
+        if (type != null) types.add(type);
+      }
+      if (types.isEmpty()) types = null;
+    }
+
+    // Location
+    if (jsonObject.has("location")) {
+      JSONObject loc = jsonObject.optJSONObject("location");
+      MFLocationComponent point = toLocationComponent(loc);
+      return MFRouteRestriction.restrictLocation(point, types);
+    }
+
+    // Circle
+    if (jsonObject.has("location") && jsonObject.has("radius")) {
+      JSONObject loc = jsonObject.optJSONObject("location");
+      Integer radius = jsonObject.has("radius") ? jsonObject.optInt("radius") : null;
+      MFLocationComponent point = toLocationComponent(loc);
+      return MFRouteRestriction.restrictCircleArea(point, radius, types);
+    }
+
+    // View box
+    if (jsonObject.has("viewbox")) {
+      JSONObject box = jsonObject.optJSONObject("viewbox");
+      JSONObject sw = box.optJSONObject("southwest");
+      JSONObject ne = box.optJSONObject("northeast");
+      MFLocationComponent southWest = toLocationComponent(sw);
+      MFLocationComponent northEast = toLocationComponent(ne);
+      return MFRouteRestriction.restrictCoordinateBounds(southWest, northEast, types);
+    }
+
+    // Path (polygon)
+    JSONArray pathArr = jsonObject.optJSONArray("path");
+    if (pathArr != null) {
+      List<MFLocationComponent> points = new ArrayList<>();
+      for (int i = 0; i < pathArr.length(); i++) {
+        JSONObject p = pathArr.optJSONObject(i);
+        MFLocationComponent c = toLocationComponent(p);
+        if (c != null) points.add(c);
+      }
+      if (!points.isEmpty()) {
+        return MFRouteRestriction.restrictPolygonArea(points, types);
+      }
+    }
+
+    // Only types
+    if (types != null) {
+      return MFRouteRestriction.restrictRouteTypes(types);
+    }
+
+    return null;
+  }
+
+  private static MFRoute toRoute(JSONObject jsonObject) {
+    List<MFRoute.Leg> legs = new ArrayList<>();
+    JSONArray legsArray = JsonParser.getJsonArray("legs", jsonObject);
+    if (legsArray != null) {
+      for (int i = 0; i < legsArray.length(); ++i) {
+        try {
+          JSONObject legJsonObject = legsArray.getJSONObject(i);
+          MFRoute.Leg leg = toLeg(legJsonObject);
+          legs.add(leg);
+        } catch (JSONException e) {
+          e.printStackTrace();
+        }
+      }
+    }
+    String overviewPolyline = JsonParser.getString("overviewPolyline", jsonObject);
+    String summary = JsonParser.getString("summary", jsonObject);
+    MFRoute.Info distance = toInfo(JsonParser.getJsonObject("distance", jsonObject));
+    MFRoute.Info duration = toInfo(JsonParser.getJsonObject("duration", jsonObject));
+    List<MFLocationComponent> snappedWaypoints = new ArrayList<>();
+    JSONArray snappedWaypointsArray = JsonParser.getJsonArray("snappedWaypoints", jsonObject);
+    if (snappedWaypointsArray != null) {
+      for (int i = 0; i < snappedWaypointsArray.length(); ++i) {
+        try {
+          JSONObject locationJsonObject = snappedWaypointsArray.getJSONObject(i);
+          MFLocationComponent location = toLocationComponent(locationJsonObject);
+          snappedWaypoints.add(location);
+        } catch (JSONException e) {
+          e.printStackTrace();
+        }
+      }
+    }
+
+    List<MFLocationComponent> overviewCoordinates = PolylineUtils.decodePolyline(overviewPolyline != null ? overviewPolyline : "");
+    return new MFRoute(
+      summary,
+      overviewCoordinates.toArray(new MFLocationComponent[0]),
+      legs.toArray(new MFRoute.Leg[0]),
+      distance,
+      duration,
+      snappedWaypoints.toArray(new MFLocationComponent[0]),
+      new byte[0]
+    );
+  }
+
+  private static MFRoute.Leg toLeg(JSONObject jsonObject) {
+    MFRoute.Info distance = toInfo(JsonParser.getJsonObject("distance", jsonObject));
+    MFRoute.Info duration = toInfo(JsonParser.getJsonObject("duration", jsonObject));
+    String startAddress = JsonParser.getString("startAddress", jsonObject);
+    String endAddress = JsonParser.getString("endAddress", jsonObject);
+    JSONObject startLocationJson = JsonParser.getJsonObject("startLocation", jsonObject);
+    MFLocationComponent startLocation = toLocationComponent(startLocationJson);
+    JSONObject endLocationJson = JsonParser.getJsonObject("endLocation", jsonObject);
+    MFLocationComponent endLocation = toLocationComponent(endLocationJson);
+    List<MFRoute.Step> steps = new ArrayList<>();
+    JSONArray stepsJsonArray = JsonParser.getJsonArray("steps", jsonObject);
+
+    if (stepsJsonArray != null) {
+      for (int i = 0; i < stepsJsonArray.length(); ++i) {
+        try {
+          JSONObject stepJsonObject = stepsJsonArray.getJSONObject(i);
+          MFRoute.Step step = toStep(stepJsonObject);
+          steps.add(step);
+        } catch (JSONException e) {
+          e.printStackTrace();
+        }
+      }
+    }
+
+    MFRoute.Step[] stepsArray = new MFRoute.Step[steps.size()];
+    stepsArray = steps.toArray(stepsArray);
+    return new MFRoute.Leg(distance, duration, startAddress, endAddress, startLocation, endLocation, stepsArray);
+  }
+
+  private static MFRoute.Step toStep(JSONObject jsonObject) {
+    MFRoute.Info distance = toInfo(JsonParser.getJsonObject("distance", jsonObject));
+    MFRoute.Info duration = toInfo(JsonParser.getJsonObject("duration", jsonObject));
+    MFLocationComponent startLocation = toLocationComponent(JsonParser.getJsonObject("startLocation", jsonObject));
+    MFLocationComponent endLocation = toLocationComponent(JsonParser.getJsonObject("endLocation", jsonObject));
+    String htmlInstructions = JsonParser.getString("htmlInstructions", jsonObject);
+    MFManeuver maneuver = MFManeuver.fromValue(JsonParser.getString("maneuver", jsonObject));
+    String polyline = JsonParser.getString("polyline", jsonObject);
+    MFTravelMode travelMode = MFTravelMode.fromValue(JsonParser.getString("travelMode", jsonObject));
+    String streetName = JsonParser.getString("streetName", jsonObject);
+    return new MFRoute.Step(
+      htmlInstructions,
+      maneuver,
+      distance,
+      duration,
+      startLocation,
+      endLocation,
+      PolylineUtils.decodePolyline(polyline == null ? "" : polyline).toArray(new MFLocationComponent[0]),
+      streetName,
+      travelMode == null ? MFTravelMode.CAR : travelMode
+    );
+  }
+
+  private static MFRoute.Info toInfo(JSONObject jsonObject) {
+    if (jsonObject == null) {
+      return new MFRoute.Info(null, null);
+    } else {
+      String text = JsonParser.getString("text", jsonObject);
+      Double value = JsonParser.getDouble("value", jsonObject);
+      return new MFRoute.Info(text, value);
+    }
+  }
+
+  private static MFLocationComponent toLocationComponent(JSONObject jsonObject) {
+    if (jsonObject == null) {
+      return new MFLocationComponent(0.0, 0.0);
+    }
+
+    Double lat = JsonParser.getDouble("lat", jsonObject);
+    if (lat == null) {
+      lat = JsonParser.getDouble("latitude", jsonObject);
+    }
+
+    Double lng = JsonParser.getDouble("lng", jsonObject);
+    if (lng == null) {
+      lng = JsonParser.getDouble("longitude", jsonObject);
+    }
+
+    return new MFLocationComponent(
+      lat != null ? lat : 0.0,
+      lng != null ? lng : 0.0
+    );
+  }
+}

package/android/src/main/java/com/map4dnavigationreactnative/Map4dNavigationReactNativeModule.kt

@@ -0,0 +1,34 @@
+package com.map4dnavigationreactnative
+
+import android.content.Intent
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = Map4dNavigationReactNativeModule.NAME)
+class Map4dNavigationReactNativeModule(reactContext: ReactApplicationContext) :
+  NativeMap4dNavigationReactNativeSpec(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun startMapNavigation(
+    directions: String?,
+    routeIndex: Double,
+    params: String?
+  ) {
+    val navigationIntent = Intent(reactApplicationContext, RMFNavigationActivity::class.java)
+    navigationIntent.putExtra(DIRECTIONS_KEY, directions)
+    navigationIntent.putExtra(ROUTE_INDEX_KEY, routeIndex)
+    navigationIntent.putExtra(PARAMS_KEY, params)
+    navigationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+    reactApplicationContext.startActivity(navigationIntent)
+  }
+
+  companion object {
+    const val NAME = "Map4dNavigationReactNative"
+    const val DIRECTIONS_KEY = "directions"
+    const val ROUTE_INDEX_KEY = "routeIndex"
+    const val PARAMS_KEY = "params"
+  }
+}

package/android/src/main/java/com/map4dnavigationreactnative/Map4dNavigationReactNativePackage.kt

@@ -0,0 +1,33 @@
+package com.map4dnavigationreactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class Map4dNavigationReactNativePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == Map4dNavigationReactNativeModule.NAME) {
+      Map4dNavigationReactNativeModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[Map4dNavigationReactNativeModule.NAME] = ReactModuleInfo(
+        Map4dNavigationReactNativeModule.NAME,
+        Map4dNavigationReactNativeModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/com/map4dnavigationreactnative/PolylineUtils.java

@@ -0,0 +1,52 @@
+package com.map4dnavigationreactnative;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import vn.map4d.services.MFLocationComponent;
+
+class PolylineUtils {
+  static List<MFLocationComponent> decodePolyline(String polyline) {
+    int len = polyline.length();
+
+    // For speed we preallocate to an upper bound on the final length, then
+    // truncate the array before returning.
+    List<MFLocationComponent> path = new ArrayList<>();
+    int index = 0;
+    int lat = 0;
+    int lng = 0;
+
+    while (index < len) {
+      int result = 1;
+      int shift = 0;
+      int b;
+      do {
+        b = polyline.charAt(index++) - 63 - 1;
+        result += b << shift;
+        shift += 5;
+      } while (b >= 0x1f);
+
+      if ((result & 1) != 0) {
+        lat += ~(result >> 1);
+      } else {
+        lat += result >> 1;
+      }
+      result = 1;
+      shift = 0;
+
+      do {
+        b = polyline.charAt(index++) - 63 - 1;
+        result += b << shift;
+        shift += 5;
+      } while (b >= 0x1f);
+
+      if ((result & 1) != 0) {
+        lng += ~(result >> 1);
+      } else {
+        lng += result >> 1;
+      }
+      path.add(new MFLocationComponent(1e-5 * lat, lng * 1e-5));
+    }
+    return path;
+  }
+}

package/android/src/main/java/com/map4dnavigationreactnative/RMFNavigationActivity.java

@@ -0,0 +1,112 @@
+package com.map4dnavigationreactnative;
+
+import static com.map4dnavigationreactnative.Map4dNavigationReactNativeModule.DIRECTIONS_KEY;
+import static com.map4dnavigationreactnative.Map4dNavigationReactNativeModule.PARAMS_KEY;
+import static com.map4dnavigationreactnative.Map4dNavigationReactNativeModule.ROUTE_INDEX_KEY;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+
+import vn.map4d.android.navigation.R;
+import vn.map4d.android.navigation.ui.MFNavigationView;
+import vn.map4d.android.navigation.ui.OnNavigationReadyCallback;
+import vn.map4d.navigation.listeners.NavigationListener;
+import vn.map4d.navigation.options.MFNavigationViewOptions;
+
+public class RMFNavigationActivity extends AppCompatActivity implements OnNavigationReadyCallback, NavigationListener {
+
+  private MFNavigationView navigationView;
+  private String directions;
+  private double routeIndex;
+  private String params;
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    navigationView.onSaveInstanceState(outState);
+    super.onSaveInstanceState(outState);
+  }
+
+  @Override
+  protected void onRestoreInstanceState(@NonNull Bundle savedInstanceState) {
+    super.onRestoreInstanceState(savedInstanceState);
+    navigationView.onRestoreInstanceState(savedInstanceState);
+  }
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_navigation);
+    navigationView = findViewById(R.id.navigationView);
+    navigationView.onCreate(savedInstanceState);
+    initialize();
+  }
+
+  @Override
+  protected void onDestroy() {
+    navigationView.onDestroy();
+    super.onDestroy();
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    navigationView.onStart();
+  }
+
+  @Override
+  protected void onPause() {
+    navigationView.onPause();
+    super.onPause();
+  }
+
+  @Override
+  protected void onStop() {
+    navigationView.onStop();
+    super.onStop();
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    navigationView.onResume();
+  }
+
+  private void initialize() {
+    navigationView.initialize(this);
+    directions = getIntent().getStringExtra(DIRECTIONS_KEY);
+    routeIndex = getIntent().getDoubleExtra(ROUTE_INDEX_KEY, 0.0);
+    params = getIntent().getStringExtra(PARAMS_KEY);
+  }
+
+  @Override
+  public void onNavigationReady(boolean isRunning) {
+    MFNavigationViewOptions.Builder options = MFNavigationViewOptions.builder();
+    options.navigationListener(this);
+    options.directionOptions(JsonUtils.toDirectionOptions(params));
+    options.directionsRoute(JsonUtils.toDirectionsRoute(directions));
+    options.routeIndex((int) routeIndex);
+    options.shouldSimulateRoute(false);
+    navigationView.startNavigation(options.build());
+  }
+
+  @Override
+  public void onCancelNavigation() {
+    finish();
+  }
+
+  @Override
+  public void onNavigationStart() {
+    // Intentionally empty
+  }
+
+  @Override
+  public void onNavigationFinished() {
+  }
+
+  @Override
+  public void onNavigationRunning() {
+    // Intentionally empty
+  }
+}

package/iPostMapNavigationReactNative.podspec

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "iPostMapNavigationReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/map4d/map4d-navigation-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  s.dependency "iPostMapNavigation", "~> 1.0"
+
+  install_modules_dependencies(s)
+end

package/ios/Map4dNavigationReactNative.h

@@ -0,0 +1,5 @@
+#import <Map4dNavigationReactNativeSpec/Map4dNavigationReactNativeSpec.h>
+
+@interface Map4dNavigationReactNative : NSObject <NativeMap4dNavigationReactNativeSpec>
+
+@end

package/ios/Map4dNavigationReactNative.mm

@@ -0,0 +1,89 @@
+#import "Map4dNavigationReactNative.h"
+#import <Map4dServices/Map4dServices.h>
+#import <Map4dNavigation/Map4dNavigation.h>
+#import <React/RCTUtils.h>
+#import <react-native-ipostmap-services/SParamConvert.h>
+
+@interface MFDirectionsResult (Extension)
+
+- (instancetype)initWithDictionary:(NSDictionary *)data;
+
+@end
+
+@implementation Map4dNavigationReactNative
+
++ (NSString *)moduleName {
+  return @"Map4dNavigationReactNative";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+    return std::make_shared<facebook::react::NativeMap4dNavigationReactNativeSpecJSI>(params);
+}
+
+- (void)startMapNavigation:(NSString *)resultJson routeIndex:(double)routeIndex params:(NSString *)paramsJson {
+  MFDirectionsResult *result = [self toDirectionsResult:resultJson];
+  MFDirectionsParams *params = [self toDirectionsParams:paramsJson];
+  NSInteger rIndex = routeIndex;
+
+  MFNavigationOptions *options = [[MFNavigationOptions alloc] init];
+  
+  dispatch_async(dispatch_get_main_queue(), ^{
+    MFNavigationViewController *vc = [[MFNavigationViewController alloc] initWithDirectionsResult:result
+                                                                                       routeIndex:rIndex
+                                                                                 directionsParams:params
+                                                                                navigationOptions:options];
+    UIViewController *root = RCTPresentedViewController();
+    if (root.navigationController) {
+      [root.navigationController pushViewController:vc animated:YES];
+    }
+    else {
+      vc.modalPresentationStyle = UIModalPresentationFullScreen;
+      [root presentViewController:vc animated:YES completion:nil];
+    }
+  });
+}
+
+- (MFDirectionsResult *)toDirectionsResult:(NSString *)json {
+  if (json == nil || [json isEqualToString:@""]) {
+    return nil;
+  }
+
+  NSData *data = [json dataUsingEncoding:NSUTF8StringEncoding];
+  NSError *error = nil;
+  NSDictionary *result = [NSJSONSerialization JSONObjectWithData:data options:0 error:&error];
+
+  if (error || ![result isKindOfClass:[NSDictionary class]]) {
+    NSLog(@"Error parsing JSON params: %@", error.localizedDescription);
+    return nil;
+  }
+  
+  return [[MFDirectionsResult alloc] initWithDictionary:result];
+}
+
+- (MFDirectionsParams *)toDirectionsParams:(NSString *)json {
+  if (json == nil || [json isEqualToString:@""]) {
+    return nil;
+  }
+
+  NSData *data = [json dataUsingEncoding:NSUTF8StringEncoding];
+  NSError *error = nil;
+  NSDictionary *dict = [NSJSONSerialization JSONObjectWithData:data options:0 error:&error];
+
+  if (error || ![dict isKindOfClass:[NSDictionary class]]) {
+    NSLog(@"Error parsing JSON params: %@", error.localizedDescription);
+    return nil;
+  }
+  
+  MFLocationComponent *origin = [SParamConvert MFLocationComponent:dict[@"origin"]];
+  MFLocationComponent *destination = [SParamConvert MFLocationComponent:dict[@"destination"]];
+  MFDirectionsParams *params = [[MFDirectionsParams alloc] initWithOrigin:origin destination:destination];
+  params.mode = [SParamConvert MFTravelMode:dict[@"mode"] fallback:params.mode];
+  params.waypoints = [SParamConvert MFLocationComponentArray:dict[@"waypoints"]];
+  params.language = [SParamConvert MFLanguageResult:dict[@"language"] fallback:params.language];
+  params.weighting = [SParamConvert MFRouteWeighting:dict[@"weighting"] fallback:params.weighting];
+  params.restriction = [SParamConvert MFRouteRestriction:dict[@"restriction"]];
+  
+  return params;
+}
+
+@end

package/lib/module/NativeMap4dNavigationReactNative.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('Map4dNavigationReactNative');
+//# sourceMappingURL=NativeMap4dNavigationReactNative.js.map

package/lib/module/NativeMap4dNavigationReactNative.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"..\\..\\src","sources":["NativeMap4dNavigationReactNative.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAMpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,4BAA4B,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import Map4dNavigationReactNative from "./NativeMap4dNavigationReactNative.js";
+export function startMapNavigation(directions, routeIndex, params) {
+  const directionsJson = JSON.stringify(directions);
+  const paramsJson = JSON.stringify(params);
+  return Map4dNavigationReactNative.startMapNavigation(directionsJson, routeIndex, paramsJson);
+}
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Map4dNavigationReactNative","startMapNavigation","directions","routeIndex","params","directionsJson","JSON","stringify","paramsJson"],"sourceRoot":"..\\..\\src","sources":["index.tsx"],"mappings":";;AACA,OAAOA,0BAA0B,MAAM,uCAAoC;AAE3E,OAAO,SAASC,kBAAkBA,CAACC,UAA8B,EAAEC,UAAkB,EAAEC,MAA0B,EAAQ;EACvH,MAAMC,cAAc,GAAGC,IAAI,CAACC,SAAS,CAACL,UAAU,CAAC;EACjD,MAAMM,UAAU,GAAGF,IAAI,CAACC,SAAS,CAACH,MAAM,CAAC;EACzC,OAAOJ,0BAA0B,CAACC,kBAAkB,CAACI,cAAc,EAAEF,UAAU,EAAEK,UAAU,CAAC;AAC9F","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NativeMap4dNavigationReactNative.d.ts

@@ -0,0 +1,7 @@
+import { type TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    startMapNavigation(directions: string, routeIndex: number, params: string): void;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeMap4dNavigationReactNative.d.ts.map

package/lib/typescript/src/NativeMap4dNavigationReactNative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeMap4dNavigationReactNative.d.ts","sourceRoot":"","sources":["../../../src/NativeMap4dNavigationReactNative.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAClF;;AAED,wBAAoF"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,3 @@
+import type { MFDirectionsParams, MFDirectionsResult } from 'react-native-ipostmap-services';
+export declare function startMapNavigation(directions: MFDirectionsResult, routeIndex: number, params: MFDirectionsParams): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAG7F,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAIvH"}

package/package.json

@@ -0,0 +1,161 @@
+{
+  "name": "react-native-ipostmap-navigation",
+  "version": "1.0.0",
+  "description": "iPostMap Navigation SDK for React Native",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace react-native-ipostmap-navigation-example",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "test": "jest",
+    "release": "release-it --only-version"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "map4d",
+    "navigation",
+    "ipostmap",
+    "vnpost",
+    "iotlink"
+  ],
+  "author": "VNPost <cskh@vnpost.vn>",
+  "license": "MIT",
+  "homepage": "https://ipostmap.vn",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "react-native-ipostmap-services": "^1.0.0"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.3.2",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@react-native/babel-preset": "0.83.0",
+    "@react-native/eslint-config": "0.83.0",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.2.0",
+    "del-cli": "^6.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "prettier": "^2.8.8",
+    "react": "19.2.0",
+    "react-native": "0.83.0",
+    "react-native-builder-bob": "^0.40.17",
+    "release-it": "^19.0.4",
+    "turbo": "^2.5.6",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@4.11.0",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "Map4dNavigationReactNativeSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.map4dnavigationreactnative"
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "create-react-native-library": {
+    "type": "turbo-module",
+    "languages": "kotlin-objc",
+    "tools": [
+      "eslint",
+      "jest",
+      "release-it"
+    ],
+    "version": "0.56.1"
+  }
+}

package/src/NativeMap4dNavigationReactNative.ts

@@ -0,0 +1,7 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  startMapNavigation(directions: string, routeIndex: number, params: string): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Map4dNavigationReactNative');

package/src/index.tsx

@@ -0,0 +1,8 @@
+import type { MFDirectionsParams, MFDirectionsResult } from 'react-native-ipostmap-services';
+import Map4dNavigationReactNative from './NativeMap4dNavigationReactNative';
+
+export function startMapNavigation(directions: MFDirectionsResult, routeIndex: number, params: MFDirectionsParams): void {
+  const directionsJson = JSON.stringify(directions)
+  const paramsJson = JSON.stringify(params)
+  return Map4dNavigationReactNative.startMapNavigation(directionsJson, routeIndex, paramsJson);
+}