@situm/react-native 3.9.3 → 3.10.1

package/android/src/main/java/com/situm/plugin/PluginHelper.java

@@ -12,7 +12,7 @@ import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.situm.plugin.utils.ReactNativeJson;
+import com.situm.plugin.utils.ReactNativeUtils;
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -56,20 +56,28 @@ import es.situm.sdk.realtime.RealTimeRequest;
 import es.situm.sdk.utils.Handler;
 import es.situm.sdk.v1.SitumEvent;
 import es.situm.sdk.location.GeofenceListener;
+import es.situm.sdk.navigation.ExternalNavigation;
 
 import static com.situm.plugin.SitumPlugin.EVENT_LOCATION_CHANGED;
 import static com.situm.plugin.SitumPlugin.EVENT_LOCATION_ERROR;
 import static com.situm.plugin.SitumPlugin.EVENT_LOCATION_STATUS_CHANGED;
 import static com.situm.plugin.SitumPlugin.EVENT_LOCATION_STOPPED;
+import static com.situm.plugin.SitumPlugin.EVENT_NAVIGATION_START;
+import static com.situm.plugin.SitumPlugin.EVENT_NAVIGATION_PROGRESS;
+import static com.situm.plugin.SitumPlugin.EVENT_NAVIGATION_DESTINATION_REACHED;
+import static com.situm.plugin.SitumPlugin.EVENT_NAVIGATION_FINISHED;
+import static com.situm.plugin.SitumPlugin.EVENT_NAVIGATION_OUTSIDE_ROUTE;
+import static com.situm.plugin.SitumPlugin.EVENT_NAVIGATION_CANCELLATION;
 import static com.situm.plugin.SitumPlugin.EVENT_NAVIGATION_ERROR;
-import static com.situm.plugin.SitumPlugin.EVENT_NAVIGATION_UPDATE;
 import static com.situm.plugin.SitumPlugin.EVENT_REALTIME_ERROR;
 import static com.situm.plugin.SitumPlugin.EVENT_REALTIME_UPDATE;
 import static com.situm.plugin.SitumPlugin.EVENT_ENTER_GEOFENCES;
 import static com.situm.plugin.SitumPlugin.EVENT_EXIT_GEOFENCES;
-import static com.situm.plugin.utils.ReactNativeJson.convertJsonToArray;
-import static com.situm.plugin.utils.ReactNativeJson.convertJsonToMap;
-import static com.situm.plugin.utils.ReactNativeJson.convertMapToJson;
+import static com.situm.plugin.utils.ReactNativeUtils.convertJsonToArray;
+import static com.situm.plugin.utils.ReactNativeUtils.convertJsonToMap;
+import static com.situm.plugin.utils.ReactNativeUtils.convertMapToJson;
+import static com.situm.plugin.utils.ReactNativeUtils.convertReadableMapToMap;
+import static com.situm.plugin.utils.ReactNativeUtils.convertMapToReadableMap;
 
 public class PluginHelper {
 
@@ -132,10 +140,6 @@ public class PluginHelper {
         return nmInstance;
     }
 
-    public void setNavigationManager(NavigationManager navigationManager) {
-        nmInstance = navigationManager;
-    }
-
     public void fetchBuildings(Callback success, Callback error) {
         try {
             getCommunicationManagerInstance().fetchBuildings(new Handler<Collection<Building>>() {
@@ -175,7 +179,7 @@ public class PluginHelper {
     // building, floors, events, indoorPois, outdoorPois, ¿geofences? ¿Paths?
     public void fetchTilesFromBuilding(ReadableMap buildingMap, Callback success, Callback error) {
         try {
-            JSONObject jsonBuilding = ReactNativeJson.convertMapToJson(buildingMap);
+            JSONObject jsonBuilding = ReactNativeUtils.convertMapToJson(buildingMap);
             Building building = SitumMapper.buildingJsonObjectToBuilding(jsonBuilding);
 
             getCommunicationManagerInstance().fetchTilesFromBuilding(building.getIdentifier(), new Handler<String>() {
@@ -187,7 +191,7 @@ public class PluginHelper {
                         JSONObject jsonObject = new JSONObject();
                         jsonObject.put("results", url);
 
-                        invokeCallback(success, ReactNativeJson.convertJsonToMap(jsonObject));
+                        invokeCallback(success, ReactNativeUtils.convertJsonToMap(jsonObject));
                     } catch (JSONException e) {
                         invokeCallback(error, e.getMessage());
                     }
@@ -209,7 +213,7 @@ public class PluginHelper {
     // building, floors, events, indoorPois, outdoorPois, ¿geofences? ¿Paths?
     public void fetchBuildingInfo(ReadableMap buildingMap, Callback success, Callback error) {
         try {
-            JSONObject jsonBuilding = ReactNativeJson.convertMapToJson(buildingMap);
+            JSONObject jsonBuilding = ReactNativeUtils.convertMapToJson(buildingMap);
             Building building = SitumMapper.buildingJsonObjectToBuilding(jsonBuilding);
 
             getCommunicationManagerInstance().fetchBuildingInfo(building, new Handler<BuildingInfo>() {
@@ -222,7 +226,7 @@ public class PluginHelper {
                                                                                               // parse ? This needs to
                                                                                               // be on sdk
 
-                        invokeCallback(success, ReactNativeJson.convertJsonToMap(jsonObject));
+                        invokeCallback(success, ReactNativeUtils.convertJsonToMap(jsonObject));
                     } catch (JSONException e) {
                         invokeCallback(error, e.getMessage());
                     }
@@ -243,7 +247,7 @@ public class PluginHelper {
 
     public void fetchFloorsFromBuilding(ReadableMap buildingMap, Callback success, Callback error) {
         try {
-            JSONObject jsonBuilding = ReactNativeJson.convertMapToJson(buildingMap);
+            JSONObject jsonBuilding = ReactNativeUtils.convertMapToJson(buildingMap);
             Building building = SitumMapper.buildingJsonObjectToBuilding(jsonBuilding);
 
             getCommunicationManagerInstance().fetchFloorsFromBuilding(building, new Handler<Collection<Floor>>() {
@@ -281,7 +285,7 @@ public class PluginHelper {
 
     public void fetchMapFromFloor(ReadableMap buildingMap, Callback success, Callback error) {
         try {
-            JSONObject jsonFloor = ReactNativeJson.convertMapToJson(buildingMap);
+            JSONObject jsonFloor = ReactNativeUtils.convertMapToJson(buildingMap);
             Floor floor = SitumMapper.floorJsonObjectToFloor(jsonFloor);
 
             getCommunicationManagerInstance().fetchMapFromFloor(floor, new Handler<Bitmap>() {
@@ -309,7 +313,7 @@ public class PluginHelper {
 
     public void fetchGeofencesFromBuilding(ReadableMap buildingMap, Callback success, Callback error) {
         try {
-            JSONObject jsonBuilding = ReactNativeJson.convertMapToJson(buildingMap);
+            JSONObject jsonBuilding = ReactNativeUtils.convertMapToJson(buildingMap);
             Building building = SitumMapper.buildingJsonObjectToBuilding(jsonBuilding);
 
             getCommunicationManagerInstance().fetchGeofencesFromBuilding(building, new Handler<List<Geofence>>() {
@@ -355,7 +359,7 @@ public class PluginHelper {
                 SitumSdk.locationManager().removeLocationListener(locationListener);
             }
 
-            JSONObject jsonRequst = ReactNativeJson.convertMapToJson(locationRequestMap);
+            JSONObject jsonRequst = ReactNativeUtils.convertMapToJson(locationRequestMap);
             LocationRequest.Builder locationBuilder = new LocationRequest.Builder();
             SitumMapper.locationRequestJSONObjectToLocationRequest(jsonRequst, locationBuilder);
             LocationRequest locationRequest = locationBuilder.build();
@@ -632,58 +636,7 @@ public class PluginHelper {
 
         navigationRequest = builder.build();
 
-        // 2.2) Build Navigation Callback
-        navigationListener = new NavigationListener() {
-            public void onProgress(NavigationProgress progress) {
-                Log.d(TAG, "On progress received: " + progress);
-                try {
-                    JSONObject jsonProgress = SitumMapper.navigationProgressToJsonObject(progress, context);
-                    try {
-                        jsonProgress.put("type", "progress");
-                    } catch (JSONException e) {
-                        Log.e(TAG, "error inserting type in navigation progress");
-                    }
-                    eventEmitter.emit(EVENT_NAVIGATION_UPDATE, convertJsonToMap(jsonProgress));
-
-                } catch (Exception e) {
-                    Log.d(TAG, "On Error parsing progress: " + progress);
-                    eventEmitter.emit(EVENT_NAVIGATION_ERROR, e.getMessage());
-                }
-            }
-
-            ;
-
-            public void onDestinationReached() {
-                Log.d(TAG, "On destination reached: ");
-                JSONObject jsonResult = new JSONObject();
-                try {
-                    jsonResult.put("type", "destinationReached");
-                    jsonResult.put("message", "Destination reached");
-                    eventEmitter.emit(EVENT_NAVIGATION_UPDATE, convertJsonToMap(jsonResult));
-                } catch (JSONException e) {
-                    Log.e(TAG, "error inserting type in destination reached");
-                }
-
-            }
-
-            ;
-
-            public void onUserOutsideRoute() {
-                Log.d(TAG, "On user outside route: ");
-                JSONObject jsonResult = new JSONObject();
-                try {
-                    jsonResult.put("type", "userOutsideRoute");
-                    jsonResult.put("message", "User outside route");
-                    eventEmitter.emit(EVENT_NAVIGATION_UPDATE, convertJsonToMap(jsonResult));
-
-                } catch (JSONException e) {
-                    Log.e(TAG, "error inserting type in user outside route");
-                }
-
-            }
-        };
-
-        getNavigationManagerInstance().requestNavigationUpdates(navigationRequest, navigationListener);
+        getNavigationManagerInstance().requestNavigationUpdates(navigationRequest);
 
     }
 
@@ -707,6 +660,18 @@ public class PluginHelper {
         }
     }
 
+    public void updateNavigationState(ReadableMap payload) {
+        try {
+            Map<String, Object> externalNavigationMap = convertReadableMapToMap(payload);
+
+            getNavigationManagerInstance().updateNavigationState(
+                ExternalNavigation.fromMap(externalNavigationMap)
+            );
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
     public void removeNavigationUpdates(Callback callback) {
         Log.i(TAG, "Remove navigation updates");
         boolean success = getNavigationManagerInstance().removeUpdates();
@@ -991,4 +956,61 @@ public class PluginHelper {
         };
         SitumSdk.locationManager().setGeofenceListener(geofenceListener);
     }
+
+    public void onSdkInitialized(
+        DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter,
+        Context context
+    ) {
+        navigationListener = _buildNavigationListener(eventEmitter, context);
+        SitumSdk.navigationManager().addNavigationListener(navigationListener);
+    }
+
+    private NavigationListener _buildNavigationListener(
+        DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter,
+        Context context
+    ) {
+        return new NavigationListener() {
+            public void onStart(Route route) {
+                Log.d(TAG, "NavigationListener.onStart() called with: "+ route);
+                try {
+                    eventEmitter.emit(EVENT_NAVIGATION_START, convertMapToReadableMap(route.toMap()));
+                } catch (Exception e) {
+                    Log.e(TAG, "error building onStart() hybrid message with native Route: "+ route);
+                    eventEmitter.emit(EVENT_NAVIGATION_ERROR, e.getMessage());
+                }
+            }
+
+            public void onProgress(NavigationProgress progress) {
+                Log.d(TAG, "NavigationListener.onProgress() called with: " + progress);
+                try {
+                    eventEmitter.emit(EVENT_NAVIGATION_PROGRESS, convertMapToReadableMap(progress.toMap()));
+                } catch (Exception e) {
+                    Log.e(TAG, "error building onProgress() hybrid message with native NavigationProgress: " + progress);
+                    eventEmitter.emit(EVENT_NAVIGATION_ERROR, e.getMessage());
+                }
+            }
+
+            public void onDestinationReached(Route route) {
+                Log.d(TAG, "NavigationListener.onDestinationReached() called with: " + route);
+                try {
+                    eventEmitter.emit(EVENT_NAVIGATION_DESTINATION_REACHED, convertMapToReadableMap(route.toMap()));
+                    eventEmitter.emit(EVENT_NAVIGATION_FINISHED, convertMapToReadableMap(route.toMap()));
+                } catch (Exception e) {
+                    Log.e(TAG, "error building onDestinationReached() hybrid message with native Route: "+ route);
+                    eventEmitter.emit(EVENT_NAVIGATION_ERROR, e.getMessage());
+                }
+            }
+
+            public void onUserOutsideRoute() {
+                Log.d(TAG, "NavigationListener.onUserOutsideRoute() called.");
+                eventEmitter.emit(EVENT_NAVIGATION_OUTSIDE_ROUTE, Arguments.createMap());
+            }
+
+            public void onCancellation() {
+                Log.d(TAG, "NavigationListener.onCancellation() called.");
+                eventEmitter.emit(EVENT_NAVIGATION_CANCELLATION, Arguments.createMap());
+                eventEmitter.emit(EVENT_NAVIGATION_FINISHED, Arguments.createMap());
+            }
+        };
+    }
 }

package/android/src/main/java/com/situm/plugin/SitumMapper.java

@@ -1120,17 +1120,17 @@ class SitumMapper {
         if (joOptions != null) {
 
             if (joOptions.has(SitumMapper.INCLUDED_TAGS) && joOptions.get(SitumMapper.INCLUDED_TAGS) != null) {
-                includedTags = new ArrayList<String>();     
-                JSONArray jsonArray = joOptions.getJSONArray(SitumMapper.INCLUDED_TAGS); 
-                for (int i=0;i<jsonArray.length();i++) { 
+                includedTags = new ArrayList<String>();
+                JSONArray jsonArray = joOptions.getJSONArray(SitumMapper.INCLUDED_TAGS);
+                for (int i=0;i<jsonArray.length();i++) {
                     includedTags.add(jsonArray.get(i).toString());
                 }
             }
 
             if (joOptions.has(SitumMapper.EXCLUDED_TAGS) && joOptions.get(SitumMapper.EXCLUDED_TAGS) != null) {
-                excludedTags = new ArrayList<String>();     
-                JSONArray jsonArray = joOptions.getJSONArray(SitumMapper.EXCLUDED_TAGS); 
-                for (int i=0;i<jsonArray.length();i++) { 
+                excludedTags = new ArrayList<String>();
+                JSONArray jsonArray = joOptions.getJSONArray(SitumMapper.EXCLUDED_TAGS);
+                for (int i=0;i<jsonArray.length();i++) {
                     excludedTags.add(jsonArray.get(i).toString());
                 }
             }

package/android/src/main/java/com/situm/plugin/SitumPlugin.java

@@ -10,8 +10,13 @@ public interface SitumPlugin {
     String EVENT_LOCATION_STATUS_CHANGED = "statusChanged";
     String EVENT_LOCATION_STOPPED = "locationStopped";
 
-    String EVENT_NAVIGATION_UPDATE = "navigationUpdated";
-    String EVENT_NAVIGATION_ERROR = "navigationError";
+    String EVENT_NAVIGATION_START = "onNavigationStart";
+    String EVENT_NAVIGATION_PROGRESS = "onNavigationProgress";
+    String EVENT_NAVIGATION_FINISHED = "onNavigationFinished";
+    String EVENT_NAVIGATION_DESTINATION_REACHED = "onNavigationDestinationReached";
+    String EVENT_NAVIGATION_OUTSIDE_ROUTE = "onUserOutsideRoute";
+    String EVENT_NAVIGATION_CANCELLATION = "onNavigationCancellation";
+    String EVENT_NAVIGATION_ERROR = "onNavigationError";
 
     String EVENT_REALTIME_ERROR = "realtimeError";
     String EVENT_REALTIME_UPDATE = "realtimeUpdated";
@@ -65,6 +70,8 @@ public interface SitumPlugin {
 
     void updateNavigationWithLocation(ReadableMap map, Callback success, Callback error);
 
+    void updateNavigationState(ReadableMap map);
+
     void removeNavigationUpdates(Callback callback);
 
     void requestRealTimeUpdates(ReadableMap map);

package/android/src/main/java/com/situm/plugin/SitumPluginImpl.java

@@ -53,6 +53,10 @@ public class SitumPluginImpl extends ReactContextBaseJavaModule implements Situm
     @ReactMethod
     public void initSitumSDK() {
         SitumSdk.init(reactContext);
+        getPluginInstance().onSdkInitialized(
+            getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class),
+            getReactApplicationContext()
+        );
     }
 
     // Required for rn built in EventEmitter Calls.
@@ -240,6 +244,12 @@ public class SitumPluginImpl extends ReactContextBaseJavaModule implements Situm
         getPluginInstance().updateNavigationWithLocation(map, success, error);
     }
 
+    @Override
+    @ReactMethod
+    public void updateNavigationState(ReadableMap map) {
+        getPluginInstance().updateNavigationState(map);
+    }
+
     @Override
     @ReactMethod
     public void removeNavigationUpdates(Callback callback) {

package/android/src/main/java/com/situm/plugin/utils/ReactNativeUtils.java

@@ -0,0 +1,284 @@
+package com.situm.plugin.utils;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.List;
+import java.util.ArrayList;
+
+public class ReactNativeUtils {
+    public static WritableMap convertJsonToMap(JSONObject jsonObject) throws JSONException {
+        WritableMap map = new WritableNativeMap();
+
+        Iterator<String> iterator = jsonObject.keys();
+        while (iterator.hasNext()) {
+            String key = iterator.next();
+            Object value = jsonObject.get(key);
+            if (value instanceof JSONObject) {
+                map.putMap(key, convertJsonToMap((JSONObject) value));
+            } else if (value instanceof JSONArray) {
+                map.putArray(key, convertJsonToArray((JSONArray) value));
+            } else if (value instanceof Boolean) {
+                map.putBoolean(key, (Boolean) value);
+            } else if (value instanceof Integer) {
+                map.putInt(key, (Integer) value);
+            } else if (value instanceof Double) {
+                map.putDouble(key, (Double) value);
+            } else if (value instanceof String) {
+                map.putString(key, (String) value);
+            } else {
+                map.putString(key, value.toString());
+            }
+        }
+        return map;
+    }
+
+    public static WritableArray convertJsonToArray(JSONArray jsonArray) throws JSONException {
+        WritableArray array = new WritableNativeArray();
+
+        for (int i = 0; i < jsonArray.length(); i++) {
+            Object value = jsonArray.get(i);
+            if (value instanceof JSONObject) {
+                array.pushMap(convertJsonToMap((JSONObject) value));
+            } else if (value instanceof JSONArray) {
+                array.pushArray(convertJsonToArray((JSONArray) value));
+            } else if (value instanceof Boolean) {
+                array.pushBoolean((Boolean) value);
+            } else if (value instanceof Integer) {
+                array.pushInt((Integer) value);
+            } else if (value instanceof Double) {
+                array.pushDouble((Double) value);
+            } else if (value instanceof String) {
+                array.pushString((String) value);
+            } else {
+                array.pushString(value.toString());
+            }
+        }
+        return array;
+    }
+
+    public static JSONObject convertMapToJson(ReadableMap readableMap) throws JSONException {
+        JSONObject object = new JSONObject();
+        ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            switch (readableMap.getType(key)) {
+                case Null:
+                    object.put(key, JSONObject.NULL);
+                    break;
+                case Boolean:
+                    object.put(key, readableMap.getBoolean(key));
+                    break;
+                case Number:
+                    // Check if the number is an integer or a double
+                    double tmpValue = readableMap.getDouble(key);
+                    if (tmpValue == Math.rint(tmpValue)) {
+                        object.put(key, readableMap.getInt(key));
+                    } else {
+                        object.put(key, tmpValue);
+                    }
+                    object.put(key, readableMap.getDouble(key));
+                    break;
+                case String:
+                    object.put(key, readableMap.getString(key));
+                    break;
+                case Map:
+                    object.put(key, convertMapToJson(readableMap.getMap(key)));
+                    break;
+                case Array:
+                    object.put(key, convertArrayToJson(readableMap.getArray(key)));
+                    break;
+            }
+        }
+        return object;
+    }
+
+    public static JSONArray convertArrayToJson(ReadableArray readableArray) throws JSONException {
+        JSONArray array = new JSONArray();
+        for (int i = 0; i < readableArray.size(); i++) {
+            switch (readableArray.getType(i)) {
+                case Null:
+                    break;
+                case Boolean:
+                    array.put(readableArray.getBoolean(i));
+                    break;
+                case Number:
+                    array.put(readableArray.getDouble(i));
+                    break;
+                case String:
+                    array.put(readableArray.getString(i));
+                    break;
+                case Map:
+                    array.put(convertMapToJson(readableArray.getMap(i)));
+                    break;
+                case Array:
+                    array.put(convertArrayToJson(readableArray.getArray(i)));
+                    break;
+            }
+        }
+        return array;
+    }
+
+    public static Map<String, Object> convertReadableMapToMap(ReadableMap readableMap) {
+        Map<String, Object> map = new HashMap<>();
+
+        ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+
+            switch (readableMap.getType(key)) {
+                case Null:
+                    map.put(key, null);
+                    break;
+                case Boolean:
+                    map.put(key, readableMap.getBoolean(key));
+                    break;
+                case Number:
+                    // Check if the number is an integer or a double
+                    double tmpValue = readableMap.getDouble(key);
+                    if (tmpValue == Math.rint(tmpValue)) {
+                        map.put(key, readableMap.getInt(key));
+                    } else {
+                        map.put(key, tmpValue);
+                    }
+                    break;
+                case String:
+                    map.put(key, readableMap.getString(key));
+                    break;
+                case Map:
+                    map.put(key, convertReadableMapToMap(readableMap.getMap(key)));
+                    break;
+                case Array:
+                    map.put(key, convertReadableArrayToList(readableMap.getArray(key)));
+                    break;
+            }
+        }
+
+        return map;
+    }
+
+    private static List<Object> convertReadableArrayToList(ReadableArray readableArray) {
+        List<Object> list = new ArrayList<>();
+
+        for (int i = 0; i < readableArray.size(); i++) {
+
+            switch (readableArray.getType(i)) {
+                case Null:
+                    list.add(null);
+                    break;
+                case Boolean:
+                    list.add(readableArray.getBoolean(i));
+                    break;
+                case Number:
+                    // Check if the number is an integer or a double
+                    double tmpValue = readableArray.getDouble(i);
+                    if (tmpValue == Math.rint(tmpValue)) {
+                        list.add(readableArray.getInt(i));
+                    } else {
+                        list.add(tmpValue);
+                    }
+                    break;
+                case String:
+                    list.add(readableArray.getString(i));
+                    break;
+                case Map:
+                    list.add(convertReadableMapToMap(readableArray.getMap(i)));
+                    break;
+                case Array:
+                    list.add(convertReadableArrayToList(readableArray.getArray(i)));
+                    break;
+            }
+        }
+
+        return list;
+    }
+
+    public static ReadableMap convertMapToReadableMap(Map<String, Object> map) {
+        WritableMap writableMap = Arguments.createMap();
+
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            String key = entry.getKey();
+            Object value = entry.getValue();
+
+            if (value == null) {
+                writableMap.putNull(key);
+            } else if (value instanceof String) {
+                writableMap.putString(key, (String) value);
+            } else if (value instanceof Integer) {
+                writableMap.putInt(key, (Integer) value);
+            } else if (value instanceof Double) {
+                writableMap.putDouble(key, (Double) value);
+            } else if (value instanceof Float) {
+                writableMap.putDouble(key, ((Float) value).doubleValue());
+            } else if (value instanceof Long) {
+                Long longValue = (Long) value;
+                if (longValue <= Integer.MAX_VALUE && longValue >= Integer.MIN_VALUE) {
+                    writableMap.putInt(key, longValue.intValue());
+                } else {
+                    writableMap.putDouble(key, longValue.doubleValue());
+                }
+            } else if (value instanceof Boolean) {
+                writableMap.putBoolean(key, (Boolean) value);
+            } else if (value instanceof Map) {
+                writableMap.putMap(key, convertMapToReadableMap((Map<String, Object>) value));
+            } else if (value instanceof List) {
+                writableMap.putArray(key, convertListToWritableArray((List<Object>) value));
+            } else {
+                // Handle other types if necessary
+                throw new IllegalArgumentException("Unsupported value type for key: " + key);
+            }
+        }
+
+        return writableMap;
+    }
+
+    private static WritableArray convertListToWritableArray(List<Object> list) {
+        WritableArray writableArray = Arguments.createArray();
+
+        for (Object value : list) {
+            if (value == null) {
+                writableArray.pushNull();
+            } else if (value instanceof String) {
+                writableArray.pushString((String) value);
+            } else if (value instanceof Integer) {
+                writableArray.pushInt((Integer) value);
+            } else if (value instanceof Double) {
+                writableArray.pushDouble((Double) value);
+            } else if (value instanceof Float) {
+                writableArray.pushDouble(((Float) value).doubleValue());
+            } else if (value instanceof Long) {
+                Long longValue = (Long) value;
+                if (longValue <= Integer.MAX_VALUE && longValue >= Integer.MIN_VALUE) {
+                    writableArray.pushInt(longValue.intValue());
+                } else {
+                    writableArray.pushDouble(longValue.doubleValue());
+                }
+            } else if (value instanceof Boolean) {
+                writableArray.pushBoolean((Boolean) value);
+            } else if (value instanceof Map) {
+                writableArray.pushMap(convertMapToReadableMap((Map<String, Object>) value));
+            } else if (value instanceof List) {
+                writableArray.pushArray(convertListToWritableArray((List<Object>) value));
+            } else {
+                // Handle other types if necessary
+                throw new IllegalArgumentException("Unsupported value type in list");
+            }
+        }
+
+        return writableArray;
+    }
+
+}

package/ios/SitumLocationWrapper.m

@@ -999,6 +999,10 @@ static SitumLocationWrapper *singletonSitumLocationWrapperObj;
     [jo setObject:stepsJsonArray.lastObject forKey:@"lastStep"];
     [jo setObject:pointsJsonArray forKey:@"nodes"];
     
+    if (route.poiTo == nil) return jo;
+    
+    [jo setObject:[route.poiTo toDictionary] forKey:@"poiTo"];
+    
     return jo.copy;
 }