@sentiance-react-native/legacy 6.0.0-beta.9

package/android/src/main/java/com/sentiance/react/bridge/legacy/LegacySentiancePackage.java

@@ -0,0 +1,29 @@
+package com.sentiance.react.bridge.legacy;
+
+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 java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class LegacySentiancePackage implements ReactPackage {
+
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    LegacySentianceModule legacySentianceModule = new LegacySentianceModule(reactContext);
+    modules.add(legacySentianceModule);
+    return modules;
+  }
+
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/android/src/main/java/com/sentiance/react/bridge/legacy/RNSentianceHelper.java

@@ -0,0 +1,251 @@
+package com.sentiance.react.bridge.legacy;
+
+import android.app.Notification;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.sentiance.react.bridge.core.SentianceEmitter;
+import com.sentiance.react.bridge.core.UserLinker;
+import com.sentiance.react.bridge.core.utils.SentianceUtils;
+import com.sentiance.sdk.OnInitCallback;
+import com.sentiance.sdk.OnStartFinishedHandler;
+import com.sentiance.sdk.SdkConfig;
+import com.sentiance.sdk.SdkStatus;
+import com.sentiance.sdk.Sentiance;
+
+import java.lang.ref.WeakReference;
+import java.util.Date;
+
+public class RNSentianceHelper {
+
+  private static final String SDK_NATIVE_INIT_FLAG = "SDK_NATIVE_INIT_FLAG";
+  private static final String MY_PREFS_NAME = "RNSentianceHelper";
+  private static final String TAG = "RNSentianceHelper";
+  private static RNSentianceHelper rnSentianceHelper;
+
+  private final SentianceEmitter sentianceEmitter;
+  private final WeakReference<Context> weakContext;
+
+  public static RNSentianceHelper getInstance(Context context) {
+    if (rnSentianceHelper == null) {
+      synchronized (RNSentianceHelper.class) {
+        rnSentianceHelper = new RNSentianceHelper(context);
+      }
+    }
+    return rnSentianceHelper;
+  }
+
+
+  private RNSentianceHelper(Context context) {
+    weakContext = new WeakReference<>(context);
+    sentianceEmitter = new SentianceEmitter(weakContext.get());
+  }
+
+  /**
+   * ========================================
+   * Temporary wrapper methods to ease the
+   * integration of the SDK
+   * ========================================
+   */
+
+  /**
+   * The wrapper method handle SDK initialization without needing to pass the
+   * crendentials. This method is meant to be called in the "MainActivity.onCreate". While
+   * the credentials are passed during the "createUser" method exposed.
+   * <p>
+   * This method basically rallies around the state vairables.
+   * - SENTIANCE_SDK_IS_READY_FOR_BACKGROUND
+   * - SENTIANCE_SDK_APP_ID
+   * - SENTIANCE_SDK_APP_SECRET
+   * <p>
+   * The above variables are set in the "createUser" method
+   *
+   * @param callback
+   */
+  public void initialize(@Nullable final InitCallback callback) {
+    String isReadyForBackground = this.getValueForKey("SENTIANCE_SDK_IS_READY_FOR_BACKGROUND", "");
+
+    if (!isReadyForBackground.equals("YES")) {
+      return;
+    }
+
+    String appId = this.getValueForKey("SENTIANCE_SDK_APP_ID", "");
+    String appSecret = this.getValueForKey("SENTIANCE_SDK_APP_SECRET", "");
+    String baseUrl = this.getValueForKey("SENTIANCE_SDK_APP_BASE_URL", "");
+    final String isDisabled = this.getValueForKey("SENTIANCE_SDK_IS_DISABLED", "");
+
+    if (appId.equals("") || appSecret.equals("")) {
+      return;
+    }
+
+    this.initializeSentianceSDK(appId, appSecret, false, baseUrl, new OnInitCallback() {
+      @Override
+      public void onInitSuccess() {
+        if (!isDisabled.equals("YES")) {
+          startSentianceSDK(
+            new OnStartFinishedHandler() {
+              @Override
+              public void onStartFinished(SdkStatus sdkStatus) {
+                if (callback != null) callback.onSuccess();
+              }
+            }
+          );
+        }
+      }
+
+      @Override
+      public void onInitFailure(InitIssue issue, @Nullable Throwable throwable) {
+        if (callback != null) callback.onFailure(issue);
+      }
+    }, null);
+  }
+
+  public void initializeAndStartSentianceSDK(String appId, String appSecret,
+                                             final boolean shouldStart, @Nullable String baseUrl,
+                                             boolean userLinkingEnabled,
+                                             final @Nullable OnInitCallback initCallback,
+                                             final @Nullable OnStartFinishedHandler startFinishedHandler) {
+    Context context = weakContext.get();
+    if (context == null) return;
+
+    Notification notification = SentianceUtils.createNotificationFromManifestData(weakContext);
+
+    // Create the config.
+    SdkConfig.Builder builder = new SdkConfig.Builder(appId, appSecret, notification)
+      .setOnSdkStatusUpdateHandler(sentianceEmitter::sendStatusUpdateEvent);
+    if (userLinkingEnabled)
+      builder.setUserLinker(new UserLinker(sentianceEmitter));
+    if (baseUrl != null)
+      builder.baseURL(baseUrl);
+
+    SdkConfig config = builder.build();
+
+    // Initialize and start Sentiance SDK.
+    Sentiance.getInstance(context).init(config, new OnInitCallback() {
+      @Override
+      public void onInitSuccess() {
+        if (initCallback != null)
+          initCallback.onInitSuccess();
+        if (shouldStart)
+          startSentianceSDK(startFinishedHandler);
+      }
+
+      @Override
+      public void onInitFailure(InitIssue issue, @Nullable Throwable throwable) {
+        if (initCallback != null)
+          initCallback.onInitFailure(issue, throwable);
+        Log.e(TAG, issue.toString());
+      }
+    });
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public void startSentianceSDK(@Nullable final OnStartFinishedHandler callback) {
+    startSentianceSDK(null, callback);
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public void startSentianceSDK(@Nullable final Long stopEpochTimeMs,
+                                @Nullable final OnStartFinishedHandler callback) {
+    Context context = weakContext.get();
+    if (context == null) return;
+
+    if (stopEpochTimeMs != null) {
+      Sentiance.getInstance(context).start(new Date(stopEpochTimeMs), callback);
+    } else {
+      Sentiance.getInstance(context).start(callback);
+    }
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public void initializeSentianceSDK(String appId, String appSecret, boolean shouldStart,
+                                     @Nullable OnInitCallback initCallback,
+                                     @Nullable OnStartFinishedHandler startFinishedHandler) {
+    initializeAndStartSentianceSDK(appId, appSecret, shouldStart, null, false, initCallback,
+      startFinishedHandler);
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public void initializeSentianceSDK(String appId, String appSecret, boolean shouldStart,
+                                     @Nullable String baseUrl, @Nullable OnInitCallback initCallback,
+                                     @Nullable OnStartFinishedHandler startFinishedHandler) {
+    initializeAndStartSentianceSDK(appId, appSecret, shouldStart, baseUrl, false, initCallback,
+      startFinishedHandler);
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public void initializeSentianceSDKWithUserLinking(String appId, String appSecret, boolean shouldStart,
+                                                    @Nullable OnInitCallback initCallback,
+                                                    @Nullable OnStartFinishedHandler startFinishedHandler) {
+    initializeAndStartSentianceSDK(appId, appSecret, shouldStart, null, true, initCallback,
+      startFinishedHandler);
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public void initializeSentianceSDKWithUserLinking(String appId, String appSecret, boolean shouldStart,
+                                                    @Nullable String baseUrl, @Nullable OnInitCallback initCallback,
+                                                    @Nullable OnStartFinishedHandler startFinishedHandler) {
+    initializeAndStartSentianceSDK(appId, appSecret, shouldStart, baseUrl, true, initCallback,
+      startFinishedHandler);
+  }
+
+  public Boolean initializeSentianceSDKIfUserLinkingCompleted(String appId, String appSecret, boolean shouldStart,
+                                                              @Nullable String baseUrl,
+                                                              @Nullable OnInitCallback initCallback,
+                                                              @Nullable OnStartFinishedHandler startFinishedHandler) {
+    if (isThirdPartyLinked()) {
+      initializeAndStartSentianceSDK(appId, appSecret, shouldStart, baseUrl, true, initCallback,
+        startFinishedHandler);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public Boolean isThirdPartyLinked() {
+    Context context = weakContext.get();
+    if (context == null) return false;
+    return Sentiance.getInstance(context).isUserLinked();
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public void setValueForKey(String key, String value) {
+    Context context = weakContext.get();
+    if (context == null) return;
+    SharedPreferences prefs = context.getSharedPreferences(MY_PREFS_NAME, Context.MODE_PRIVATE);
+    prefs.edit().putString(key, value).apply();
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public String getValueForKey(String key, String defaultValue) {
+    Context context = weakContext.get();
+    if (context == null) return defaultValue;
+    SharedPreferences prefs = context.getSharedPreferences(MY_PREFS_NAME, Context.MODE_PRIVATE);
+    return prefs.getString(key, defaultValue);
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public Boolean isNativeInitializationEnabled() {
+    String nativeInitFlag = rnSentianceHelper.getValueForKey(SDK_NATIVE_INIT_FLAG, "");
+    return nativeInitFlag.equals("enabled");
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public void enableNativeInitialization() {
+    setValueForKey(SDK_NATIVE_INIT_FLAG, "enabled");
+  }
+
+  @SuppressWarnings({"unused", "WeakerAccess"})
+  public void disableNativeInitialization() {
+    setValueForKey(SDK_NATIVE_INIT_FLAG, "");
+  }
+
+  public interface InitCallback {
+    void onSuccess();
+
+    void onFailure(OnInitCallback.InitIssue issue);
+  }
+}

package/android/src/main/java/com/sentiance/react/bridge/legacy/StartFinishedHandlerCreator.java

@@ -0,0 +1,41 @@
+package com.sentiance.react.bridge.legacy;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+import com.sentiance.react.bridge.core.SentianceConverter;
+import com.sentiance.sdk.OnStartFinishedHandler;
+import com.sentiance.sdk.SdkStatus;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class StartFinishedHandlerCreator {
+
+  private final List<OnStartFinishedHandler> startFinishedHandlers;
+
+  StartFinishedHandlerCreator() {
+    this.startFinishedHandlers = new ArrayList<>();
+  }
+
+  OnStartFinishedHandler createNewStartFinishedHandler(final Promise promise) {
+    final OnStartFinishedHandler startFinishedHandler = new OnStartFinishedHandler() {
+      @Override
+      public void onStartFinished(@NonNull SdkStatus sdkStatus) {
+        promise.resolve(SentianceConverter.convertSdkStatus(sdkStatus));
+        removeStartFinishHandler(this);
+      }
+    };
+    // hold strong reference
+    addStartFinishHandler(startFinishedHandler);
+    return startFinishedHandler;
+  }
+
+  private synchronized void addStartFinishHandler(OnStartFinishedHandler handler) {
+    startFinishedHandlers.add(handler);
+  }
+
+  private synchronized void removeStartFinishHandler(OnStartFinishedHandler handler) {
+    startFinishedHandlers.remove(handler);
+  }
+}

package/lib/index.d.ts

@@ -0,0 +1,243 @@
+declare module "react-native-sentiance" {
+  import {EmitterSubscription, EventSubscriptionVendor, NativeEventEmitter,} from "react-native";
+
+  export type LocationPermission = "ALWAYS" | "ONLY_WHILE_IN_USE" | "NEVER";
+  export type SdkInitState =
+    | "NOT_INITIALIZED"
+    | "INIT_IN_PROGRESS"
+    | "INITIALIZED"
+    | "RESETTING"
+    | "UNRECOGNIZED_STATE";
+
+  export type SdkResetFailureReason =
+    | "SDK_INIT_IN_PROGRESS"
+    | "SDK_RESET_IN_PROGRESS"
+    | "SDK_RESET_UNKNOWN_ERROR";
+
+  export type InitIssue =
+    | "INVALID_CREDENTIALS"
+    | "CHANGED_CREDENTIALS"
+    | "SERVICE_UNREACHABLE"
+    | "LINK_FAILED"
+    | "SDK_RESET_IN_PROGRESS"
+    | "INITIALIZATION_ERROR";
+
+  export type TripType = "TRIP_TYPE_SDK" | "TRIP_TYPE_EXTERNAL";
+  export type SdkEvent =
+    "SENTIANCE_STATUS_UPDATE_EVENT"
+    | "SENTIANCE_USER_LINK_EVENT"
+    | "SENTIANCE_USER_ACTIVITY_UPDATE_EVENT"
+    | "SENTIANCE_ON_TRIP_TIMED_OUT_EVENT"
+    | "SENTIANCE_VEHICLE_CRASH_EVENT";
+
+  export type SDKStatusUpdateListener = (sdkStatus: SdkStatus) => void;
+
+  export type SDKUserLinkListener = (param: { installId: string }) => void;
+
+  export type SDKUserActivityUpdateListener = (userActivity: UserActivity) => void;
+
+  export type SDKCrashEventListener = (crashEvent: CrashEvent) => void;
+
+  export type SdkEventListener =
+    SDKStatusUpdateListener |
+    SDKUserLinkListener |
+    SDKUserActivityUpdateListener |
+    SDKCrashEventListener;
+
+  export enum TransportMode {
+    UNKNOWN = 1,
+    CAR,
+    BICYCLE,
+    ON_FOOT,
+    TRAIN,
+    TRAM,
+    BUS,
+    PLANE,
+    BOAT,
+    METRO,
+    RUNNING,
+  }
+
+  export interface VehicleCrashEvent {
+    time: number;
+    location?: Location;
+    magnitude?: number;
+    speedAtImpact?: number;
+    deltaV?: number;
+    confidence?: number;
+  }
+
+  export interface CrashEvent {
+    time: number;
+    lastKnownLocation?: Location;
+  }
+
+  export interface Location {
+    latitude: string;
+    longitude: string;
+    accuracy?: string; // Android only
+    altitude?: string; // Android only
+    provider?: string; // Android only
+  }
+
+  export interface StationaryInfo {
+    location?: Location;
+  }
+
+  export interface TripInfo {
+    type: "TRIP_TYPE_SDK" | "TRIP_TYPE_EXTERNAL" | "TRIP_TYPE_UNRECOGNIZED" | "ANY";
+  }
+
+  export interface UserActivity {
+    type: "USER_ACTIVITY_TYPE_TRIP" | "USER_ACTIVITY_TYPE_STATIONARY" | "USER_ACTIVITY_TYPE_UNKNOWN" | "USER_ACTIVITY_TYPE_UNRECOGNIZED";
+    tripInfo?: TripInfo;
+    stationaryInfo?: StationaryInfo;
+  }
+
+  export interface MetadataObject {
+    [key: string]: string;
+  }
+
+  export interface UserAccessToken {
+    tokenId: string;
+    expiryDate?: string; // Android only
+  }
+
+  export interface SdkStatus {
+    startStatus: string;
+    canDetect: boolean;
+    isRemoteEnabled: boolean;
+    isAccelPresent: boolean;
+    isGyroPresent: boolean;
+    isGpsPresent: boolean;
+    wifiQuotaStatus: string;
+    mobileQuotaStatus: string;
+    diskQuotaStatus: string;
+    locationPermission: LocationPermission;
+    isBgAccessPermGranted?: boolean; // iOS only
+    isActivityRecognitionPermGranted?: boolean; // Android only
+    locationSetting?: string; // Android only
+    isAirplaneModeEnabled?: boolean; // Android only
+    isLocationAvailable?: boolean; // Android only
+    isGooglePlayServicesMissing?: boolean; // Android only
+    isBatteryOptimizationEnabled?: boolean; // Android only
+    isBatterySavingEnabled?: boolean; // Android only
+    isBackgroundProcessingRestricted?: boolean; // Android only
+    isPreciseLocationAuthorizationGranted: boolean;
+    isSchedulingExactAlarmsPermitted?: boolean; // Android only
+  }
+
+  export interface RNSentianceConstructor extends EventSubscriptionVendor {
+    init(
+      appId: string,
+      secret: string,
+      baseURL: string | null,
+      shouldStart: boolean
+    ): Promise<boolean | SdkStatus>;
+
+    initWithUserLinkingEnabled(
+      appId: string,
+      secret: string,
+      baseURL: string | null,
+      shouldStart: boolean
+    ): Promise<boolean | SdkStatus>;
+
+    start(): Promise<SdkStatus>;
+
+    startWithStopDate(stopEpochTimeMs: number | null): Promise<SdkStatus>;
+
+    stop(): Promise<boolean>;
+
+    reset(): Promise<boolean>;
+
+    getInitState(): Promise<SdkInitState>;
+
+    getSdkStatus(): Promise<SdkStatus>;
+
+    getVersion(): Promise<string>;
+
+    getUserId(): Promise<string>;
+
+    getUserAccessToken(): Promise<UserAccessToken>;
+
+    addUserMetadataField(label: string, value: string): Promise<boolean>;
+
+    addUserMetadataFields(metadata: MetadataObject): Promise<boolean>;
+
+    removeUserMetadataField(label: string): Promise<boolean>;
+
+    getWiFiQuotaLimit(): Promise<string>;
+
+    getWiFiQuotaUsage(): Promise<string>;
+
+    getMobileQuotaLimit(): Promise<string>;
+
+    getMobileQuotaUsage(): Promise<string>;
+
+    getDiskQuotaLimit(): Promise<string>;
+
+    getDiskQuotaUsage(): Promise<string>;
+
+    disableBatteryOptimization(): Promise<boolean>;
+
+    getUserActivity(): Promise<UserActivity>;
+
+    listenUserActivityUpdates(): Promise<boolean>;
+
+    listenTripTimeout(): Promise<void>;
+
+    userLinkCallback(success: boolean): void;
+
+    getValueForKey(key: string, defaultValue: string): Promise<string>;
+
+    setValueForKey(key: string, value: string): void;
+
+    startTrip(
+      metadata: MetadataObject | null,
+      hint: TransportMode
+    ): Promise<boolean>;
+
+    stopTrip(): Promise<boolean>;
+
+    isTripOngoing(type: TripType): Promise<boolean>;
+
+    submitDetections(): Promise<boolean>;
+
+    updateSdkNotification(title: string, message: string): Promise<boolean>;
+
+    addTripMetadata(metadata: MetadataObject): Promise<boolean>;
+
+    isThirdPartyLinked(): Promise<boolean>;
+
+    isNativeInitializationEnabled(): Promise<boolean>;
+
+    enableNativeInitialization(): Promise<boolean>;
+
+    disableNativeInitialization(): Promise<boolean>;
+
+    listenVehicleCrashEvents(): Promise<boolean>;
+
+    invokeDummyVehicleCrash(): Promise<boolean>;
+
+    isVehicleCrashDetectionSupported(): Promise<boolean>;
+  }
+
+  export interface RNSentianceEventEmitter extends NativeEventEmitter {
+    addListener(
+      eventType: SdkEvent,
+      listener: SdkEventListener,
+      context?: any
+    ): EmitterSubscription;
+  }
+
+  export interface RNSentianceEventSubscriptions {
+    sdkStatusSubscription?: EmitterSubscription;
+    sdkUserLinkSubscription?: EmitterSubscription;
+    sdkUserActivityUpdateSubscription?: EmitterSubscription;
+    sdkCrashEventSubscription?: EmitterSubscription;
+    sdkTripProfileListener?: EmitterSubscription;
+  }
+
+  const RNSentiance: RNSentianceConstructor;
+  export default RNSentiance;
+}

package/lib/index.js

@@ -0,0 +1,125 @@
+import legacy from './legacy';
+import core from '@sentiance-react-native/core';
+import crashDetection from '@sentiance-react-native/crash-detection';
+
+var RNSentiance = {};
+RNSentiance.TransportMode = core.transportModes;
+
+const {
+  userLinkCallback,
+  getVersion,
+  getUserId,
+  addUserMetadataField,
+  addUserMetadataFields,
+  removeUserMetadataField,
+  getUserActivity,
+  listenUserActivityUpdates,
+  isTripOngoing,
+  updateSdkNotification,
+  addTripMetadata,
+  getInitState,
+  getSdkStatus,
+  getDiskQuotaLimit,
+  getDiskQuotaUsage,
+  disableBatteryOptimization,
+  getMobileQuotaLimit,
+  getMobileQuotaUsage,
+  getWiFiQuotaLimit,
+  getWiFiQuotaUsage,
+  listenTripTimeout
+} = core;
+
+const {
+  listenVehicleCrashEvents,
+  invokeDummyVehicleCrash,
+  isVehicleCrashDetectionSupported
+} = crashDetection;
+
+const {
+  init,
+  initWithUserLinkingEnabled,
+  reset,
+  start,
+  startWithStopDate,
+  stop,
+  startTrip,
+  stopTrip,
+  setValueForKey,
+  getValueForKey,
+  isThirdPartyLinked,
+  isNativeInitializationEnabled,
+  enableNativeInitialization,
+  disableNativeInitialization,
+  submitDetections,
+  getUserAccessToken,
+  addListener,
+  removeListeners
+} = legacy;
+
+// Core bindings
+RNSentiance.userLinkCallback = userLinkCallback;
+RNSentiance.getUserId = getUserId;
+RNSentiance.getVersion = getVersion;
+RNSentiance.getUserActivity = getUserActivity;
+RNSentiance.isTripOngoing = isTripOngoing;
+RNSentiance.addTripMetadata = addTripMetadata;
+RNSentiance.getInitState = getInitState;
+RNSentiance.getSdkStatus = getSdkStatus;
+RNSentiance.getDiskQuotaLimit = getDiskQuotaLimit;
+RNSentiance.getDiskQuotaUsage = getDiskQuotaUsage;
+RNSentiance.getMobileQuotaLimit = getMobileQuotaLimit;
+RNSentiance.getMobileQuotaUsage = getMobileQuotaUsage;
+RNSentiance.getWiFiQuotaLimit = getWiFiQuotaLimit;
+RNSentiance.getWiFiQuotaUsage = getWiFiQuotaUsage;
+RNSentiance.listenTripTimeout = listenTripTimeout;
+RNSentiance.addUserMetadataField = async (label, value) => {
+  await addUserMetadataField(label, value);
+  return Promise.resolve(true);
+};
+RNSentiance.addUserMetadataFields = async (metadata) => {
+  await addUserMetadataFields(metadata);
+  return Promise.resolve(true);
+};
+RNSentiance.removeUserMetadataField = async (label) => {
+  await removeUserMetadataField(label);
+  return Promise.resolve(true);
+};
+RNSentiance.listenUserActivityUpdates = async () => {
+  await listenUserActivityUpdates();
+  return Promise.resolve(true);
+};
+RNSentiance.updateSdkNotification = async (title, message) => {
+  await updateSdkNotification(title, message);
+  return Promise.resolve(true);
+};
+RNSentiance.disableBatteryOptimization = async () => {
+  await disableBatteryOptimization();
+  return Promise.resolve(true);
+};
+
+// Crash detection bindings
+RNSentiance.listenVehicleCrashEvents = listenVehicleCrashEvents;
+RNSentiance.invokeDummyVehicleCrash = invokeDummyVehicleCrash;
+RNSentiance.isVehicleCrashDetectionSupported = isVehicleCrashDetectionSupported;
+
+// Legacy bindings
+RNSentiance.init = init;
+RNSentiance.initWithUserLinkingEnabled = initWithUserLinkingEnabled;
+RNSentiance.reset = reset;
+RNSentiance.start = start;
+RNSentiance.startWithStopDate = startWithStopDate;
+RNSentiance.stop = stop;
+RNSentiance.startTrip = startTrip;
+RNSentiance.stopTrip = stopTrip;
+RNSentiance.setValueForKey = setValueForKey;
+RNSentiance.getValueForKey = getValueForKey;
+RNSentiance.isThirdPartyLinked = isThirdPartyLinked;
+RNSentiance.submitDetections = submitDetections;
+RNSentiance.getUserAccessToken = getUserAccessToken;
+RNSentiance.isNativeInitializationEnabled = isNativeInitializationEnabled;
+RNSentiance.enableNativeInitialization = enableNativeInitialization;
+RNSentiance.disableNativeInitialization = disableNativeInitialization;
+RNSentiance.addListener = addListener
+RNSentiance.removeListeners = removeListeners
+
+export default RNSentiance;