@sentiance-react-native/event-timeline 6.6.0

package/README.md

@@ -0,0 +1,9 @@
+# Sentiance Event Timeline module for React Native
+
+## Demo Application
+
+https://github.com/sentiance/sample-apps-react-native
+
+## Usage
+
+To use the Event Timeline SDK module, please visit the corresponding [API reference page.](https://docs.sentiance.com/sdk/api-reference/react-native/event-timeline)

package/android/build.gradle

@@ -0,0 +1,42 @@
+plugins {
+  id "com.android.library"
+}
+
+def coreProj
+if (findProject(':core')) {
+  coreProj = project(':core')
+} else if (findProject(':sentiance-react-native_core')) {
+  // Starting from RN 0.61, the @ sign is stripped from project names
+  coreProj = project(':sentiance-react-native_core')
+} else if (findProject(':@sentiance-react-native_core')) {
+  // On RN 0.60, the @ sign is not stripped from project names
+  coreProj = project(':@sentiance-react-native_core')
+} else {
+  throw new GradleException('Could not find the @sentiance-react-native/core package, have you installed it?')
+}
+
+android {
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+apply from: "$coreProj.projectDir/package-json-reader.gradle"
+apply from: "$coreProj.projectDir/sentiance-version-finder.gradle"
+
+def corePackageJson = PackageJson.of(coreProj)
+applyAndroidVersionsFrom(corePackageJson)
+def sentianceSdkVersion = getSentianceSdkVersion()
+
+dependencies {
+  implementation(platform("com.sentiance:sdk-bom:${sentianceSdkVersion}"))
+  api("com.sentiance:sdk-event-timeline") { transitive = true }
+  api coreProj
+
+  if (findProject(':test-common')) {
+    testImplementation project(':test-common')
+  }
+}
+
+applyReactNativeDependency()

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="com.sentiance.react.bridge.eventtimeline">
+
+</manifest>

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

@@ -0,0 +1,22 @@
+package com.sentiance.react.bridge.eventtimeline;
+
+import android.content.Context;
+
+import com.sentiance.react.bridge.core.common.base.AbstractSentianceEmitter;
+import com.sentiance.react.bridge.eventtimeline.converters.OnDeviceTypesConverter;
+import com.sentiance.sdk.ondevice.api.event.Event;
+
+public class EventTimelineEmitter extends AbstractSentianceEmitter {
+
+  public static final String TIMELINE_UPDATE_EVENT = "SENTIANCE_TIMELINE_UPDATE_EVENT";
+  private final OnDeviceTypesConverter onDeviceTypesConverter;
+
+  public EventTimelineEmitter(Context context) {
+    super(context);
+    onDeviceTypesConverter = new OnDeviceTypesConverter();
+  }
+
+  public void sendTimelineUpdateEvent(Event event) {
+    sendEvent(TIMELINE_UPDATE_EVENT, onDeviceTypesConverter.convertEvent(event));
+  }
+}

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

@@ -0,0 +1,126 @@
+package com.sentiance.react.bridge.eventtimeline;
+
+import static com.sentiance.react.bridge.eventtimeline.EventTimelineEmitter.TIMELINE_UPDATE_EVENT;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+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.Sentiance;
+import com.sentiance.sdk.eventtimeline.api.EventTimelineApi;
+import com.sentiance.sdk.eventtimeline.api.EventTimelineUpdateListener;
+import com.sentiance.sdk.ondevice.api.event.Event;
+
+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;
+    }
+
+    mSubscriptionsManager.removeSubscription(subscriptionId, eventName);
+    promise.resolve(null);
+  }
+
+  @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);
+  }
+
+  @Override
+  @ReactMethod
+  protected void addListener(String eventName) {
+
+  }
+
+  @Override
+  @ReactMethod
+  protected void removeListeners(Integer count) {
+
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NATIVE_MODULE_NAME;
+  }
+
+  @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));
+  }
+
+  @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));
+  }
+
+  @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));
+  }
+}

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

@@ -0,0 +1,40 @@
+package com.sentiance.react.bridge.eventtimeline;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.sentiance.react.bridge.core.common.SentianceSubscriptionsManager;
+import com.sentiance.react.bridge.eventtimeline.converters.OnDeviceTypesConverter;
+import com.sentiance.sdk.Sentiance;
+import com.sentiance.sdk.eventtimeline.api.EventTimelineApi;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SentianceEventTimelinePackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    SentianceEventTimelineModule eventTimelineModule = new SentianceEventTimelineModule(
+      reactContext,
+      Sentiance.getInstance(reactContext),
+      new SentianceSubscriptionsManager(),
+      EventTimelineApi.getInstance(reactContext),
+      new EventTimelineEmitter(reactContext),
+      new OnDeviceTypesConverter()
+    );
+    modules.add(eventTimelineModule);
+    return modules;
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

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

@@ -0,0 +1,151 @@
+package com.sentiance.react.bridge.eventtimeline.converters;
+
+import static com.sentiance.react.bridge.core.SentianceConverter.JS_KEY_ACCURACY;
+import static com.sentiance.react.bridge.core.SentianceConverter.JS_KEY_LATITUDE;
+import static com.sentiance.react.bridge.core.SentianceConverter.JS_KEY_LONGITUDE;
+import static com.sentiance.react.bridge.core.SentianceConverter.JS_KEY_TIMESTAMP;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.sentiance.sdk.ondevice.api.GeoLocation;
+import com.sentiance.sdk.ondevice.api.Waypoint;
+import com.sentiance.sdk.ondevice.api.event.Event;
+import com.sentiance.sdk.ondevice.api.event.StationaryEvent;
+import com.sentiance.sdk.ondevice.api.event.TransportEvent;
+import com.sentiance.sdk.ondevice.api.venue.Venue;
+
+import java.util.List;
+
+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);
+      }
+    }
+
+    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);
+    }
+
+    return map;
+  }
+
+  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();
+
+    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());
+
+    return venueMap;
+  }
+
+  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());
+    }
+  }
+
+  public WritableArray convertWaypoints(List<Waypoint> waypointList) {
+    WritableArray array = Arguments.createArray();
+    for (Waypoint waypoint : waypointList) {
+      array.pushMap(convertWaypoint(waypoint));
+    }
+    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());
+    }
+    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;
+  }
+
+  private WritableArray convertWaypointList(List<Waypoint> waypointList) {
+    WritableArray array = Arguments.createArray();
+    for (Waypoint waypoint : waypointList) {
+      array.pushMap(convertWaypoint(waypoint));
+    }
+    return array;
+  }
+}

package/lib/index.d.ts

@@ -0,0 +1,108 @@
+declare module "@sentiance-react-native/event-timeline" {
+  import {EmitterSubscription} from "react-native";
+
+  export interface Event {
+    id: string;
+    startTime: string;
+    startTimeEpoch: number; // in milliseconds
+    lastUpdateTime: string;
+    lastUpdateTimeEpoch: number; // in milliseconds
+    endTime: string | null;
+    endTimeEpoch: number | null; // in milliseconds
+    durationInSeconds: number | null;
+    type: EventType;
+    // stationary event fields
+    location: GeoLocation | null;
+    venue: Venue | null;
+    // transport event fields
+    transportMode: TransportMode | null;
+    waypoints: Waypoint[];
+    distance?: number; // in meters
+  }
+
+  export interface GeoLocation {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+  }
+
+  export interface Venue {
+    location: GeoLocation | null;
+    significance: VenueSignificance;
+    type: VenueType;
+  }
+
+  export type VenueType =
+    | "UNKNOWN"
+    | "DRINK_DAY"
+    | "DRINK_EVENING"
+    | "EDUCATION_INDEPENDENT"
+    | "EDUCATION_PARENTS"
+    | "HEALTH"
+    | "INDUSTRIAL"
+    | "LEISURE_BEACH"
+    | "LEISURE_DAY"
+    | "LEISURE_EVENING"
+    | "LEISURE_MUSEUM"
+    | "LEISURE_NATURE"
+    | "LEISURE_PARK"
+    | "OFFICE"
+    | "RELIGION"
+    | "RESIDENTIAL"
+    | "RESTO_MID"
+    | "RESTO_SHORT"
+    | "SHOP_LONG"
+    | "SHOP_SHORT"
+    | "SPORT"
+    | "SPORT_ATTEND"
+    | "TRAVEL_BUS"
+    | "TRAVEL_CONFERENCE"
+    | "TRAVEL_FILL"
+    | "TRAVEL_HOTEL"
+    | "TRAVEL_LONG"
+    | "TRAVEL_SHORT"
+
+  export type VenueSignificance =
+    | "UNKNOWN"
+    | "HOME"
+    | "WORK"
+    | "POINT_OF_INTEREST";
+
+  export type EventType =
+    | "UNKNOWN"
+    | "STATIONARY"
+    | "OFF_THE_GRID"
+    | "IN_TRANSPORT";
+
+  export type TransportMode =
+    | "UNKNOWN"
+    | "BICYCLE"
+    | "WALKING"
+    | "RUNNING"
+    | "TRAM"
+    | "TRAIN"
+    | "CAR"
+    | "BUS"
+    | "MOTORCYCLE";
+
+  export interface Waypoint {
+    latitude: number;
+    longitude: number;
+    accuracy: number;   // in meters
+    timestamp: number;  // UTC epoch time in milliseconds
+    speedInMps?: number;  // in meters per second
+    speedLimitInMps?: number;  // in meters per second
+    hasUnlimitedSpeedLimit: boolean;
+    isSpeedLimitInfoSet: boolean;
+  }
+
+  export interface EventTimelineApi {
+    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>;
+  }
+
+  const EventTimelineApi: EventTimelineApi;
+  export default EventTimelineApi;
+}

package/lib/index.js

@@ -0,0 +1,55 @@
+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 TIMELINE_UPDATE_EVENT = "SENTIANCE_TIMELINE_UPDATE_EVENT";
+
+let didLocateNativeModule = true;
+let eventTimelineModule = {};
+if (Platform.OS === 'android') {
+  if (!SentianceEventTimeline) {
+    didLocateNativeModule = false;
+    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 {
+    eventTimelineModule = SentianceEventTimeline;
+  }
+} else {
+  if (!SentianceCore) {
+    didLocateNativeModule = false;
+    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 {
+    eventTimelineModule = SentianceCore;
+  }
+}
+
+if (didLocateNativeModule) {
+  const emitter = new SentianceEventEmitter(eventTimelineModule);
+
+  eventTimelineModule._addTimelineUpdateListener = async (onTimelineUpdated) => {
+    return createEventListener(TIMELINE_UPDATE_EVENT, emitter, onTimelineUpdated);
+  };
+}
+
+const getTimelineUpdates = (afterEpochTimeMs) => eventTimelineModule.getTimelineUpdates(afterEpochTimeMs);
+
+const getTimelineEvents = (fromEpochTimeMs, toEpochTimeMs) => eventTimelineModule.getTimelineEvents(fromEpochTimeMs, toEpochTimeMs);
+
+const getTimelineEvent = (eventId) => eventTimelineModule.getTimelineEvent(eventId);
+
+const addTimelineUpdateListener = eventTimelineModule._addTimelineUpdateListener;
+
+module.exports = {
+  getTimelineUpdates,
+  getTimelineEvents,
+  getTimelineEvent,
+  addTimelineUpdateListener
+};
+module.exports.events = {
+  TIMELINE_UPDATE_EVENT
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@sentiance-react-native/event-timeline",
+  "version": "6.6.0",
+  "description": "The Sentiance Event Timeline library",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "scripts": {
+    "test": "jest --verbose",
+    "lint": "npx eslint lib/index.d.ts"
+  },
+  "keywords": [
+    "react-native",
+    "event-timeline",
+    "sentiance"
+  ],
+  "peerDependencies": {
+    "@sentiance-react-native/core": "6.6.0"
+  },
+  "author": "",
+  "license": "",
+  "homepage": "https://github.com/sentiance/react-native-sentiance/tree/main/packages/event-timeline",
+  "repository": "github:sentiance/react-native-sentiance",
+  "publishConfig": {
+    "access": "public"
+  }
+}