@sentiance-react-native/event-timeline 6.9.1-rc.1 → 6.10.0-alpha.1

package/android/src/main/java/com/sentiance/react/bridge/eventtimeline/ErrorCodes.java

@@ -0,0 +1,5 @@
+package com.sentiance.react.bridge.eventtimeline;
+
+public class ErrorCodes {
+    public static final String E_TRANSPORT_TAG_ERROR = "E_TRANSPORT_TAG_ERROR";
+}

package/android/src/main/java/com/sentiance/react/bridge/eventtimeline/SentianceEventTimelineModule.java

@@ -1,5 +1,6 @@
 package com.sentiance.react.bridge.eventtimeline;
 
+import static com.sentiance.react.bridge.eventtimeline.ErrorCodes.E_TRANSPORT_TAG_ERROR;
 import static com.sentiance.react.bridge.eventtimeline.EventTimelineEmitter.TIMELINE_UPDATE_EVENT;
 
 import androidx.annotation.NonNull;
@@ -7,9 +8,11 @@ import androidx.annotation.NonNull;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
 import com.sentiance.react.bridge.core.common.SentianceSubscriptionsManager;
 import com.sentiance.react.bridge.core.common.base.AbstractSentianceModule;
 import com.sentiance.react.bridge.eventtimeline.converters.OnDeviceTypesConverter;
+import com.sentiance.sdk.NoSentianceUserException;
 import com.sentiance.sdk.Sentiance;
 import com.sentiance.sdk.eventtimeline.api.EventTimelineApi;
 import com.sentiance.sdk.eventtimeline.api.EventTimelineUpdateListener;
@@ -19,108 +22,124 @@ import java.util.Date;
 import java.util.List;
 
 public class SentianceEventTimelineModule extends AbstractSentianceModule {
-  public static final String NATIVE_MODULE_NAME = "SentianceEventTimeline";
-
-  private final EventTimelineApi mEventTimelineApi;
-  private final EventTimelineEmitter mEmitter;
-  private final OnDeviceTypesConverter onDeviceTypesConverter;
-
-  public SentianceEventTimelineModule(ReactApplicationContext reactApplicationContext,
-                                      Sentiance sentiance,
-                                      SentianceSubscriptionsManager subscriptionsManager,
-                                      EventTimelineApi eventTimelineApi,
-                                      EventTimelineEmitter emitter,
-                                      OnDeviceTypesConverter converter) {
-    super(reactApplicationContext, sentiance, subscriptionsManager);
-    mEventTimelineApi = eventTimelineApi;
-    mEmitter = emitter;
-    onDeviceTypesConverter = converter;
-  }
-
-  @Override
-  protected void addSupportedEventSubscriptions(SentianceSubscriptionsManager subscriptionsManager) {
-    subscriptionsManager.addSupportedSubscription(
-      TIMELINE_UPDATE_EVENT,
-      mEventTimelineApi::setTimelineUpdateListener,
-      listener -> mEventTimelineApi.setTimelineUpdateListener(null),
-      SentianceSubscriptionsManager.SubscriptionType.SINGLE
-    );
-  }
-
-  @Override
-  @ReactMethod
-  protected void removeNativeListener(String eventName, int subscriptionId, Promise promise) {
-    if (rejectIfNotInitialized(promise)) {
-      return;
+    public static final String NATIVE_MODULE_NAME = "SentianceEventTimeline";
+
+    private final EventTimelineApi mEventTimelineApi;
+    private final EventTimelineEmitter mEmitter;
+    private final OnDeviceTypesConverter onDeviceTypesConverter;
+
+    public SentianceEventTimelineModule(ReactApplicationContext reactApplicationContext,
+                                        Sentiance sentiance,
+                                        SentianceSubscriptionsManager subscriptionsManager,
+                                        EventTimelineApi eventTimelineApi,
+                                        EventTimelineEmitter emitter,
+                                        OnDeviceTypesConverter converter) {
+        super(reactApplicationContext, sentiance, subscriptionsManager);
+        mEventTimelineApi = eventTimelineApi;
+        mEmitter = emitter;
+        onDeviceTypesConverter = converter;
     }
 
-    mSubscriptionsManager.removeSubscription(subscriptionId, eventName);
-    promise.resolve(null);
-  }
+    @Override
+    protected void addSupportedEventSubscriptions(SentianceSubscriptionsManager subscriptionsManager) {
+        subscriptionsManager.addSupportedSubscription(
+            TIMELINE_UPDATE_EVENT,
+            mEventTimelineApi::setTimelineUpdateListener,
+            listener -> mEventTimelineApi.setTimelineUpdateListener(null),
+            SentianceSubscriptionsManager.SubscriptionType.SINGLE
+        );
+    }
+
+    @Override
+    @ReactMethod
+    protected void removeNativeListener(String eventName, int subscriptionId, Promise promise) {
+        if (rejectIfNotInitialized(promise)) {
+            return;
+        }
 
-  @Override
-  @ReactMethod
-  protected void addNativeListener(String eventName, int subscriptionId, Promise promise) {
-    if (rejectIfNotInitialized(promise)) {
-      return;
+        mSubscriptionsManager.removeSubscription(subscriptionId, eventName);
+        promise.resolve(null);
     }
 
-    switch (eventName) {
-      case TIMELINE_UPDATE_EVENT:
-        mSubscriptionsManager.addSubscription(eventName, subscriptionId, (EventTimelineUpdateListener) mEmitter::sendTimelineUpdateEvent);
-        break;
+    @Override
+    @ReactMethod
+    protected void addNativeListener(String eventName, int subscriptionId, Promise promise) {
+        if (rejectIfNotInitialized(promise)) {
+            return;
+        }
+
+        switch (eventName) {
+            case TIMELINE_UPDATE_EVENT:
+                mSubscriptionsManager.addSubscription(eventName, subscriptionId, (EventTimelineUpdateListener) mEmitter::sendTimelineUpdateEvent);
+                break;
+        }
+        promise.resolve(null);
     }
-    promise.resolve(null);
-  }
 
-  @Override
-  @ReactMethod
-  protected void addListener(String eventName) {
+    @Override
+    @ReactMethod
+    protected void addListener(String eventName) {
 
-  }
+    }
 
-  @Override
-  @ReactMethod
-  protected void removeListeners(Integer count) {
+    @Override
+    @ReactMethod
+    protected void removeListeners(Integer count) {
 
-  }
+    }
 
-  @NonNull
-  @Override
-  public String getName() {
-    return NATIVE_MODULE_NAME;
-  }
+    @NonNull
+    @Override
+    public String getName() {
+        return NATIVE_MODULE_NAME;
+    }
+
+    @ReactMethod
+    public void getTimelineUpdates(final Double afterEpochTimeMs, final Promise promise) {
+        if (rejectIfNotInitialized(promise)) {
+            return;
+        }
 
-  @ReactMethod
-  public void getTimelineUpdates(final Double afterEpochTimeMs, final Promise promise) {
-    if (rejectIfNotInitialized(promise)) {
-      return;
+        Date afterDate = new Date(afterEpochTimeMs.longValue());
+        List<Event> events = mEventTimelineApi.getTimelineUpdates(afterDate);
+        promise.resolve(onDeviceTypesConverter.convertEvents(events));
     }
 
-    Date afterDate = new Date(afterEpochTimeMs.longValue());
-    List<Event> events = mEventTimelineApi.getTimelineUpdates(afterDate);
-    promise.resolve(onDeviceTypesConverter.convertEvents(events));
-  }
+    @ReactMethod
+    public void getTimelineEvents(final Double fromEpochTimeMs, final Double toEpochTimeMs, final Promise promise) {
+        if (rejectIfNotInitialized(promise)) {
+            return;
+        }
 
-  @ReactMethod
-  public void getTimelineEvents(final Double fromEpochTimeMs, final Double toEpochTimeMs, final Promise promise) {
-    if (rejectIfNotInitialized(promise)) {
-      return;
+        Date fromDate = new Date(fromEpochTimeMs.longValue());
+        Date toDate = new Date(toEpochTimeMs.longValue());
+        List<Event> events = mEventTimelineApi.getTimelineEvents(fromDate, toDate);
+        promise.resolve(onDeviceTypesConverter.convertEvents(events));
     }
 
-    Date fromDate = new Date(fromEpochTimeMs.longValue());
-    Date toDate = new Date(toEpochTimeMs.longValue());
-    List<Event> events = mEventTimelineApi.getTimelineEvents(fromDate, toDate);
-    promise.resolve(onDeviceTypesConverter.convertEvents(events));
-  }
+    @ReactMethod
+    public void getTimelineEvent(final String eventId, final Promise promise) {
+        if (rejectIfNotInitialized(promise)) {
+            return;
+        }
 
-  @ReactMethod
-  public void getTimelineEvent(final String eventId, final Promise promise) {
-    if (rejectIfNotInitialized(promise)) {
-      return;
+        Event event = mEventTimelineApi.getTimelineEvent(eventId);
+        promise.resolve(event == null ? null : onDeviceTypesConverter.convertEvent(event));
     }
 
-    Event event = mEventTimelineApi.getTimelineEvent(eventId);
-    promise.resolve(event == null ? null : onDeviceTypesConverter.convertEvent(event));
-  }
+    @ReactMethod
+    public void setTransportTags(ReadableMap tags, final Promise promise) {
+        if (rejectIfNotInitialized(promise)) {
+            return;
+        }
+
+        try {
+            mEventTimelineApi.setTransportTags(onDeviceTypesConverter.convertTransportTags(tags));
+            promise.resolve(null);
+        } catch (IllegalArgumentException | NoSentianceUserException e) {
+            promise.reject(E_TRANSPORT_TAG_ERROR, e.getMessage());
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
 }

package/android/src/main/java/com/sentiance/react/bridge/eventtimeline/converters/OnDeviceTypesConverter.java

@@ -6,6 +6,7 @@ import static com.sentiance.react.bridge.core.SentianceConverter.JS_KEY_LONGITUD
 import static com.sentiance.react.bridge.core.SentianceConverter.JS_KEY_TIMESTAMP;
 
 import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.sentiance.sdk.ondevice.api.GeoLocation;
@@ -16,136 +17,151 @@ import com.sentiance.sdk.ondevice.api.event.TransportEvent;
 import com.sentiance.sdk.ondevice.api.venue.Venue;
 
 import java.util.List;
+import java.util.Map;
 
 public class OnDeviceTypesConverter {
-  public static final String JS_KEY_ID = "id";
-  public static final String JS_KEY_START_TIME = "startTime";
-  public static final String JS_KEY_START_TIME_EPOCH = "startTimeEpoch";
-  public static final String JS_KEY_END_TIME = "endTime";
-  public static final String JS_KEY_END_TIME_EPOCH = "endTimeEpoch";
-  public static final String JS_KEY_LAST_UPDATE_TIME = "lastUpdateTime";
-  public static final String JS_KEY_LAST_UPDATE_TIME_EPOCH = "lastUpdateTimeEpoch";
-  public static final String JS_KEY_DURATION_SECONDS = "durationInSeconds";
-  public static final String JS_KEY_TYPE = "type";
-  public static final String JS_KEY_LOCATION = "location";
-  public static final String JS_KEY_VENUE = "venue";
-  public static final String JS_KEY_SIGNIFICANCE = "significance";
-  public static final String JS_KEY_TRANSPORT_MODE = "transportMode";
-  public static final String JS_KEY_WAYPOINTS = "waypoints";
-  public static final String JS_KEY_DISTANCE = "distance";
-  public static final String JS_KEY_SPEED_IN_MPS = "speedInMps";
-  public static final String JS_KEY_SPEED_LIMIT_IN_MPS = "speedLimitInMps";
-  public static final String JS_KEY_HAS_UNLIMITED_SPEED_LIMIT = "hasUnlimitedSpeedLimit";
-  public static final String JS_KEY_IS_SPEED_LIMIT_INFO_SET = "isSpeedLimitInfoSet";
-
-  public WritableMap convertGeoLocation(GeoLocation location) {
-    WritableMap locationMap = Arguments.createMap();
-
-    locationMap.putDouble(JS_KEY_LATITUDE, location.getLatitude());
-    locationMap.putDouble(JS_KEY_LONGITUDE, location.getLongitude());
-    locationMap.putInt(JS_KEY_ACCURACY, location.getAccuracyInMeters());
-
-    return locationMap;
-  }
-
-  public WritableArray convertEvents(List<Event> events) {
-    WritableArray array = Arguments.createArray();
-    for (Event event : events) {
-      array.pushMap(convertEvent(event));
-    }
-    return array;
-  }
-
-  public WritableMap convertEvent(Event event) {
-    WritableMap map = Arguments.createMap();
-
-    map.putString(JS_KEY_ID, event.getId());
-    map.putString(JS_KEY_START_TIME, event.getStartTime().toString());
-    map.putDouble(JS_KEY_START_TIME_EPOCH, event.getStartTime().getEpochTime());
-    if (event.getEndTime() != null) {
-      map.putString(JS_KEY_END_TIME, event.getEndTime().toString());
-      map.putDouble(JS_KEY_END_TIME_EPOCH, event.getEndTime().getEpochTime());
-
-      Long durationInSeconds = event.getDurationInSeconds();
-      if (durationInSeconds != null) {
-        map.putDouble(JS_KEY_DURATION_SECONDS, durationInSeconds);
-      }
+    public static final String JS_KEY_ID = "id";
+    public static final String JS_KEY_START_TIME = "startTime";
+    public static final String JS_KEY_START_TIME_EPOCH = "startTimeEpoch";
+    public static final String JS_KEY_END_TIME = "endTime";
+    public static final String JS_KEY_END_TIME_EPOCH = "endTimeEpoch";
+    public static final String JS_KEY_LAST_UPDATE_TIME = "lastUpdateTime";
+    public static final String JS_KEY_LAST_UPDATE_TIME_EPOCH = "lastUpdateTimeEpoch";
+    public static final String JS_KEY_DURATION_SECONDS = "durationInSeconds";
+    public static final String JS_KEY_TYPE = "type";
+    public static final String JS_KEY_LOCATION = "location";
+    public static final String JS_KEY_VENUE = "venue";
+    public static final String JS_KEY_SIGNIFICANCE = "significance";
+    public static final String JS_KEY_TRANSPORT_MODE = "transportMode";
+    public static final String JS_KEY_WAYPOINTS = "waypoints";
+    public static final String JS_KEY_DISTANCE = "distance";
+    public static final String JS_KEY_SPEED_IN_MPS = "speedInMps";
+    public static final String JS_KEY_SPEED_LIMIT_IN_MPS = "speedLimitInMps";
+    public static final String JS_KEY_HAS_UNLIMITED_SPEED_LIMIT = "hasUnlimitedSpeedLimit";
+    public static final String JS_KEY_IS_SPEED_LIMIT_INFO_SET = "isSpeedLimitInfoSet";
+    public static final String JS_KEY_TRANSPORT_TAGS = "transportTags";
+
+    private final TransportTagsConverter transportTagsConverter;
+
+    public OnDeviceTypesConverter() {
+        transportTagsConverter = new TransportTagsConverter();
     }
 
-    map.putString(JS_KEY_LAST_UPDATE_TIME, event.getLastUpdateTime().toString());
-    map.putDouble(JS_KEY_LAST_UPDATE_TIME_EPOCH, event.getLastUpdateTime().getEpochTime());
+    public WritableMap convertGeoLocation(GeoLocation location) {
+        WritableMap locationMap = Arguments.createMap();
 
-    map.putString(JS_KEY_TYPE, event.getEventType().toString());
+        locationMap.putDouble(JS_KEY_LATITUDE, location.getLatitude());
+        locationMap.putDouble(JS_KEY_LONGITUDE, location.getLongitude());
+        locationMap.putInt(JS_KEY_ACCURACY, location.getAccuracyInMeters());
 
-    if (event instanceof StationaryEvent) {
-      addStationaryEventInfo(map, (StationaryEvent) event);
-    } else if (event instanceof TransportEvent) {
-      addTransportEventInfo(map, (TransportEvent) event);
+        return locationMap;
     }
 
-    return map;
-  }
-
-  private void addStationaryEventInfo(WritableMap map, StationaryEvent event) {
-    if (event.getLocation() != null) {
-      map.putMap(JS_KEY_LOCATION, convertGeoLocation(event.getLocation()));
+    public WritableArray convertEvents(List<Event> events) {
+        WritableArray array = Arguments.createArray();
+        for (Event event : events) {
+            array.pushMap(convertEvent(event));
+        }
+        return array;
     }
-    map.putMap(JS_KEY_VENUE, convertVenue(event.getVenue()));
-  }
 
-  public WritableMap convertVenue(Venue venue) {
-    WritableMap venueMap = Arguments.createMap();
+    public WritableMap convertEvent(Event event) {
+        WritableMap map = Arguments.createMap();
+
+        map.putString(JS_KEY_ID, event.getId());
+        map.putString(JS_KEY_START_TIME, event.getStartTime().toString());
+        map.putDouble(JS_KEY_START_TIME_EPOCH, event.getStartTime().getEpochTime());
+        if (event.getEndTime() != null) {
+            map.putString(JS_KEY_END_TIME, event.getEndTime().toString());
+            map.putDouble(JS_KEY_END_TIME_EPOCH, event.getEndTime().getEpochTime());
+
+            Long durationInSeconds = event.getDurationInSeconds();
+            if (durationInSeconds != null) {
+                map.putDouble(JS_KEY_DURATION_SECONDS, durationInSeconds);
+            }
+        }
+
+        map.putString(JS_KEY_LAST_UPDATE_TIME, event.getLastUpdateTime().toString());
+        map.putDouble(JS_KEY_LAST_UPDATE_TIME_EPOCH, event.getLastUpdateTime().getEpochTime());
+
+        map.putString(JS_KEY_TYPE, event.getEventType().toString());
+
+        if (event instanceof StationaryEvent) {
+            addStationaryEventInfo(map, (StationaryEvent) event);
+        } else if (event instanceof TransportEvent) {
+            addTransportEventInfo(map, (TransportEvent) event);
+        }
 
-    if (venue.getLocation() != null) {
-      venueMap.putMap(JS_KEY_LOCATION, convertGeoLocation(venue.getLocation()));
+        return map;
     }
-    venueMap.putString(JS_KEY_SIGNIFICANCE, venue.getSignificance().name());
-    venueMap.putString(JS_KEY_TYPE, venue.getType().name());
 
-    return venueMap;
-  }
+    private void addStationaryEventInfo(WritableMap map, StationaryEvent event) {
+        if (event.getLocation() != null) {
+            map.putMap(JS_KEY_LOCATION, convertGeoLocation(event.getLocation()));
+        }
+        map.putMap(JS_KEY_VENUE, convertVenue(event.getVenue()));
+    }
+
+    public WritableMap convertVenue(Venue venue) {
+        WritableMap venueMap = Arguments.createMap();
 
-  private void addTransportEventInfo(WritableMap map, TransportEvent event) {
-    map.putString(JS_KEY_TRANSPORT_MODE, event.getTransportMode().toString());
-    map.putArray(JS_KEY_WAYPOINTS, convertWaypointList(event.getWaypoints()));
+        if (venue.getLocation() != null) {
+            venueMap.putMap(JS_KEY_LOCATION, convertGeoLocation(venue.getLocation()));
+        }
+        venueMap.putString(JS_KEY_SIGNIFICANCE, venue.getSignificance().name());
+        venueMap.putString(JS_KEY_TYPE, venue.getType().name());
 
-    if (event.getDistanceInMeters() != null) {
-      map.putInt(JS_KEY_DISTANCE, event.getDistanceInMeters());
+        return venueMap;
     }
-  }
 
-  public WritableArray convertWaypoints(List<Waypoint> waypointList) {
-    WritableArray array = Arguments.createArray();
-    for (Waypoint waypoint : waypointList) {
-      array.pushMap(convertWaypoint(waypoint));
+    private void addTransportEventInfo(WritableMap map, TransportEvent event) {
+        map.putString(JS_KEY_TRANSPORT_MODE, event.getTransportMode().toString());
+        map.putArray(JS_KEY_WAYPOINTS, convertWaypointList(event.getWaypoints()));
+
+        if (event.getDistanceInMeters() != null) {
+            map.putInt(JS_KEY_DISTANCE, event.getDistanceInMeters());
+        }
+
+        Map<String, String> transportTags = event.getTags();
+        map.putMap(JS_KEY_TRANSPORT_TAGS, transportTagsConverter.convertFrom(transportTags));
     }
-    return array;
-  }
-
-  public WritableMap convertWaypoint(Waypoint waypoint) {
-    WritableMap waypointMap = Arguments.createMap();
-
-    waypointMap.putDouble(JS_KEY_LATITUDE, waypoint.getLatitude());
-    waypointMap.putDouble(JS_KEY_LONGITUDE, waypoint.getLongitude());
-    waypointMap.putInt(JS_KEY_ACCURACY, waypoint.getAccuracyInMeters());
-    waypointMap.putDouble(JS_KEY_TIMESTAMP, waypoint.getTimestamp());
-    if (waypoint.hasSpeed()) {
-      waypointMap.putDouble(JS_KEY_SPEED_IN_MPS, waypoint.getSpeedInMps());
+
+    public WritableArray convertWaypoints(List<Waypoint> waypointList) {
+        WritableArray array = Arguments.createArray();
+        for (Waypoint waypoint : waypointList) {
+            array.pushMap(convertWaypoint(waypoint));
+        }
+        return array;
     }
-    if (waypoint.isSpeedLimitInfoSet() && !waypoint.hasUnlimitedSpeedLimit()) {
-      waypointMap.putDouble(JS_KEY_SPEED_LIMIT_IN_MPS, waypoint.getSpeedLimitInMps());
+
+    public WritableMap convertWaypoint(Waypoint waypoint) {
+        WritableMap waypointMap = Arguments.createMap();
+
+        waypointMap.putDouble(JS_KEY_LATITUDE, waypoint.getLatitude());
+        waypointMap.putDouble(JS_KEY_LONGITUDE, waypoint.getLongitude());
+        waypointMap.putInt(JS_KEY_ACCURACY, waypoint.getAccuracyInMeters());
+        waypointMap.putDouble(JS_KEY_TIMESTAMP, waypoint.getTimestamp());
+        if (waypoint.hasSpeed()) {
+            waypointMap.putDouble(JS_KEY_SPEED_IN_MPS, waypoint.getSpeedInMps());
+        }
+        if (waypoint.isSpeedLimitInfoSet() && !waypoint.hasUnlimitedSpeedLimit()) {
+            waypointMap.putDouble(JS_KEY_SPEED_LIMIT_IN_MPS, waypoint.getSpeedLimitInMps());
+        }
+        waypointMap.putBoolean(JS_KEY_IS_SPEED_LIMIT_INFO_SET, waypoint.isSpeedLimitInfoSet());
+        waypointMap.putBoolean(JS_KEY_HAS_UNLIMITED_SPEED_LIMIT, waypoint.hasUnlimitedSpeedLimit());
+
+        return waypointMap;
     }
-    waypointMap.putBoolean(JS_KEY_IS_SPEED_LIMIT_INFO_SET, waypoint.isSpeedLimitInfoSet());
-    waypointMap.putBoolean(JS_KEY_HAS_UNLIMITED_SPEED_LIMIT, waypoint.hasUnlimitedSpeedLimit());
 
-    return waypointMap;
-  }
+    private WritableArray convertWaypointList(List<Waypoint> waypointList) {
+        WritableArray array = Arguments.createArray();
+        for (Waypoint waypoint : waypointList) {
+            array.pushMap(convertWaypoint(waypoint));
+        }
+        return array;
+    }
 
-  private WritableArray convertWaypointList(List<Waypoint> waypointList) {
-    WritableArray array = Arguments.createArray();
-    for (Waypoint waypoint : waypointList) {
-      array.pushMap(convertWaypoint(waypoint));
+    public Map<String, String> convertTransportTags(ReadableMap tags) {
+        return transportTagsConverter.convertFrom(tags);
     }
-    return array;
-  }
 }

package/android/src/main/java/com/sentiance/react/bridge/eventtimeline/converters/TransportTagsConverter.java

@@ -0,0 +1,42 @@
+package com.sentiance.react.bridge.eventtimeline.converters;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableMap;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Utility converter to handle conversions from/to React Native maps and standard Java hashmaps.
+ */
+public class TransportTagsConverter {
+    public Map<String, String> convertFrom(ReadableMap tags) {
+        Map<String, String> map = new HashMap<>();
+        ReadableMapKeySetIterator iterator = tags.keySetIterator();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            String value = tags.getString(key);
+
+            if (value == null) {
+                throw new IllegalArgumentException("Cannot get string value for key: " + key);
+            }
+
+            map.put(key, value);
+        }
+        return map;
+    }
+
+    public WritableMap convertFrom(Map<String, String> tags) {
+        WritableMap writableMap = Arguments.createMap();
+        Set<String> keys = tags.keySet();
+
+        for (String key : keys) {
+            writableMap.putString(key, tags.get(key));
+        }
+
+        return writableMap;
+    }
+}

package/lib/errors/errors.d.ts

@@ -0,0 +1,3 @@
+export class TransportTaggingError extends Error {
+  constructor(message: string);
+}

package/lib/errors/errors.js

@@ -0,0 +1,13 @@
+export const E_TRANSPORT_TAG_ERROR = "E_TRANSPORT_TAG_ERROR";
+
+class TransportTaggingError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TransportTaggingError";
+  }
+}
+
+module.exports = {
+  TransportTaggingError,
+  E_TRANSPORT_TAG_ERROR
+}

package/lib/index.d.ts

@@ -18,6 +18,7 @@ declare module "@sentiance-react-native/event-timeline" {
     transportMode: TransportMode | null;
     waypoints: Waypoint[];
     distance?: number; // in meters
+    transportTags: TransportTags;
   }
 
   export interface GeoLocation {
@@ -96,11 +97,48 @@ declare module "@sentiance-react-native/event-timeline" {
     isSpeedLimitInfoSet: boolean;
   }
 
+  export type TransportTags = { [key: string]: string };
+
   export interface SentianceEventTimeline {
     getTimelineUpdates(afterEpochTimeMs: number): Promise<Event[]>;
     getTimelineEvents(fromEpochTimeMs: number, toEpochTimeMs: number): Promise<Event[]>;
     getTimelineEvent(eventId: string): Promise<Event | null>;
     addTimelineUpdateListener(onTimelineUpdated: (event: Event) => void): Promise<EmitterSubscription>;
+
+    /**
+     * Sets the tags that will be assigned to a detected transport.
+     *
+     * @remarks
+     * The provided tags will be assigned to a transport at the moment the transport ends. When you
+     * receive an {@link Event} representing the ended transport, it will include these tags.
+     *
+     * The supplied tags are persisted and applied to future transports, even after the app is restarted.
+     * By calling this method again, you will replace the tags that will be assigned to future transports.
+     *
+     * You can include up to 6 tags (key-value pairs), and each tag component (key or value) must
+     * be at most 256 characters.
+     *
+     * @example Setting custom transport tags
+     * try {
+     *   await SentianceEventTimeline.setTransportTags({
+     *    key1: "value1",
+     *    key2: "value2"
+     *   });
+     *   console.log('Transport tags have been set.');
+     * } catch (error) {
+     *   if (error instanceof TransportTagsError) {
+     *     console.error(`Failed to set transport tags: ${error.message}`);
+     *   } else {
+     *     console.error(`Error: ${error.message}`);
+     *   }
+     * }
+     *
+     * @param tags The transport tags to set
+     *
+     * @throws TransportTaggingError if the supplied tags count is more than 6, or if one of the tag components exceeds
+     * the 256 characters limit.
+     */
+    setTransportTags(tags: TransportTags): Promise<void>;
   }
 
   /**

package/lib/index.js

@@ -1,17 +1,18 @@
-const {NativeModules, Platform} = require("react-native");
-const {varToString} = require("@sentiance-react-native/core/lib/utils");
+const { NativeModules, Platform } = require("react-native");
+const { varToString } = require("@sentiance-react-native/core/lib/utils");
 const SentianceEventEmitter = require("@sentiance-react-native/core/lib/SentianceEventEmitter");
-const {createEventListener} = require("@sentiance-react-native/core/lib/SentianceEventListenerUtils");
-const {SentianceEventTimeline, SentianceCore} = NativeModules;
+const { createEventListener } = require("@sentiance-react-native/core/lib/SentianceEventListenerUtils");
+const { TransportTaggingError, E_TRANSPORT_TAG_ERROR } = require("./errors/errors");
+const { SentianceEventTimeline, SentianceCore } = NativeModules;
 
 const TIMELINE_UPDATE_EVENT = "SENTIANCE_TIMELINE_UPDATE_EVENT";
 
 let didLocateNativeModule = true;
 let eventTimelineModule = {};
-if (Platform.OS === 'android') {
+if (Platform.OS === "android") {
   if (!SentianceEventTimeline) {
     didLocateNativeModule = false;
-    const nativeModuleName = varToString({SentianceEventTimeline});
+    const nativeModuleName = varToString({ SentianceEventTimeline });
     console.error(`Could not locate the native ${nativeModuleName} module.
     Make sure that your native code is properly linked, and that the module name you specified is correct.`);
   } else {
@@ -20,7 +21,7 @@ if (Platform.OS === 'android') {
 } else {
   if (!SentianceCore) {
     didLocateNativeModule = false;
-    const nativeModuleName = varToString({SentianceCore});
+    const nativeModuleName = varToString({ SentianceCore });
     console.error(`Could not locate the native ${nativeModuleName} module.
     Make sure that your native code is properly linked, and that the module name you specified is correct.`);
   } else {
@@ -44,11 +45,23 @@ const getTimelineEvent = (eventId) => eventTimelineModule.getTimelineEvent(event
 
 const addTimelineUpdateListener = eventTimelineModule._addTimelineUpdateListener;
 
+const setTransportTags = async (tags) => {
+  try {
+    return await eventTimelineModule.setTransportTags(tags);
+  } catch (e) {
+    if (e.code === E_TRANSPORT_TAG_ERROR) {
+      throw new TransportTaggingError(e.message);
+    }
+    throw e;
+  }
+};
+
 module.exports = {
   getTimelineUpdates,
   getTimelineEvents,
   getTimelineEvent,
-  addTimelineUpdateListener
+  addTimelineUpdateListener,
+  setTransportTags
 };
 module.exports.events = {
   TIMELINE_UPDATE_EVENT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentiance-react-native/event-timeline",
-  "version": "6.9.1-rc.1",
+  "version": "6.10.0-alpha.1",
   "description": "The Sentiance Event Timeline library",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -14,7 +14,7 @@
     "sentiance"
   ],
   "peerDependencies": {
-    "@sentiance-react-native/core": "6.9.1-rc.1"
+    "@sentiance-react-native/core": "6.10.0-alpha.1"
   },
   "author": "",
   "license": "",