@sentiance-react-native/core 6.0.0-beta.10

package/android/src/main/java/com/sentiance/react/bridge/core/SentianceModule.java

@@ -0,0 +1,529 @@
+package com.sentiance.react.bridge.core;
+
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_GET_TOKEN_ERROR;
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_MISSING_PARAMS;
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_RESET_ERROR;
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_START_TRIP_ERROR;
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_STOP_TRIP_ERROR;
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_SUBMIT_DETECTIONS_ERROR;
+
+import android.annotation.SuppressLint;
+import android.app.Notification;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+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.base.AbstractSentianceModule;
+import com.sentiance.react.bridge.core.utils.SentianceUtils;
+import com.sentiance.react.bridge.core.utils.UserCreationCompletionHandler;
+import com.sentiance.sdk.InitState;
+import com.sentiance.sdk.SdkStatus;
+import com.sentiance.sdk.Sentiance;
+import com.sentiance.sdk.SubmitDetectionsError;
+import com.sentiance.sdk.Token;
+import com.sentiance.sdk.UserAccessTokenError;
+import com.sentiance.sdk.detectionupdates.UserActivity;
+import com.sentiance.sdk.reset.ResetError;
+import com.sentiance.sdk.trip.StartTripError;
+import com.sentiance.sdk.trip.StopTripError;
+import com.sentiance.sdk.trip.TransportMode;
+import com.sentiance.sdk.trip.TripTimeoutListener;
+import com.sentiance.sdk.trip.TripType;
+
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Map;
+
+public class SentianceModule extends AbstractSentianceModule {
+
+  private static final String NATIVE_MODULE_NAME = "SentianceCore";
+  private final Handler mHandler = new Handler(Looper.getMainLooper());
+  private final SentianceHelper sentianceHelper;
+  private final SentianceEmitter emitter;
+
+  public SentianceModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    sentianceHelper = SentianceHelper.getInstance(reactContext);
+    emitter = new SentianceEmitter(reactContext);
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NATIVE_MODULE_NAME;
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void userLinkCallback(final Boolean linkResult) {
+    mHandler.post(() -> sentianceHelper.userLinkCallback(linkResult));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void enableDetections(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+    sentianceHelper.enableDetections(promise);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void enableDetectionsWithExpiryDate(@Nullable final Double expiryEpochTimeMs, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+    Long expiryTime = expiryEpochTimeMs == null ? null : expiryEpochTimeMs.longValue();
+    sentianceHelper.enableDetections(expiryTime, promise);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void disableDetections(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+    sentianceHelper.disableDetections(promise);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void createUnlinkedUser(String appId, String secret, @Nullable String platformUrl, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+    sentianceHelper.createUnlinkedUser(appId, secret, platformUrl)
+      .addOnCompleteListener(new UserCreationCompletionHandler(promise));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void createLinkedUser(String appId, String secret, @Nullable String platformUrl, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+    sentianceHelper.createLinkedUser(appId, secret, platformUrl)
+      .addOnCompleteListener(new UserCreationCompletionHandler(promise));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void createLinkedUserWithAuthCode(String authCode, @Nullable String platformUrl, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+    sentianceHelper.createLinkedUser(authCode, platformUrl)
+      .addOnCompleteListener(new UserCreationCompletionHandler(promise));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void linkUser(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+    sentianceHelper.linkUser(promise);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void linkUserWithAuthCode(String authCode, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+    sentianceHelper.linkUser(authCode, promise);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void userExists(final Promise promise) {
+    promise.resolve(sdk.userExists());
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void isUserLinked(final Promise promise) {
+    promise.resolve(sdk.isUserLinked());
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void reset(final Promise promise) {
+    sdk.reset()
+      .addOnCompleteListener(pendingOperation -> {
+        if (pendingOperation.isSuccessful()) {
+          promise.resolve(SentianceConverter.convertResetResult(pendingOperation.getResult()));
+        } else {
+          ResetError error = pendingOperation.getError();
+          promise.reject(E_SDK_RESET_ERROR, SentianceConverter.stringifyResetError(error));
+        }
+      });
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getInitState(final Promise promise) {
+    InitState initState = sdk.getInitState();
+    promise.resolve(SentianceConverter.convertInitState(initState));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void startTrip(@Nullable ReadableMap metadata, int hint, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    Map<String, String> metadataMap = new HashMap<>();
+    if (metadata != null) {
+      for (Map.Entry<String, Object> entry : metadata.toHashMap().entrySet()) {
+        metadataMap.put(entry.getKey(), entry.getValue().toString());
+      }
+    }
+    final TransportMode transportModeHint = SentianceConverter.toTransportMode(hint);
+    sdk.startTrip(metadataMap, transportModeHint)
+      .addOnCompleteListener(pendingOperation -> {
+        if (pendingOperation.isSuccessful()) {
+          promise.resolve(SentianceConverter.createEmptyResult());
+        } else {
+          StartTripError error = pendingOperation.getError();
+          promise.reject(E_SDK_START_TRIP_ERROR,
+            SentianceConverter.stringifyStartTripError(error));
+        }
+      });
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void stopTrip(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+    sdk.stopTrip()
+      .addOnCompleteListener(pendingOperation -> {
+        if (pendingOperation.isSuccessful()) {
+          promise.resolve(SentianceConverter.createEmptyResult());
+        } else {
+          StopTripError error = pendingOperation.getError();
+          promise.reject(E_SDK_STOP_TRIP_ERROR,
+            SentianceConverter.stringifyStopTripError(error));
+        }
+      });
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getSdkStatus(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    SdkStatus sdkStatus = sdk.getSdkStatus();
+    promise.resolve(SentianceConverter.convertSdkStatus(sdkStatus));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getVersion(final Promise promise) {
+    String version = sdk.getVersion();
+    promise.resolve(version);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void isTripOngoing(String typeParam, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    if (typeParam == null) {
+      promise.reject(E_SDK_MISSING_PARAMS, "TripType is required");
+      return;
+    }
+    final TripType type = SentianceConverter.toTripType(typeParam);
+    Boolean isTripOngoing = sdk.isTripOngoing(type);
+    promise.resolve(isTripOngoing);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void requestUserAccessToken(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    sdk.requestUserAccessToken()
+      .addOnCompleteListener(pendingOperation -> {
+        if (pendingOperation.isSuccessful()) {
+          Token token = pendingOperation.getResult();
+          promise.resolve(SentianceConverter.convertToken(token));
+        } else {
+          UserAccessTokenError error = pendingOperation.getError();
+          promise.reject(E_SDK_GET_TOKEN_ERROR,
+            SentianceConverter.stringifyUserAccessTokenError(error));
+        }
+      });
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getUserId(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    String userId = sdk.getUserId();
+    promise.resolve(userId);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void addUserMetadataField(final String label, final String value, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    if (label == null || value == null) {
+      promise.reject(E_SDK_MISSING_PARAMS, "label and value are required");
+      return;
+    }
+
+    sdk.addUserMetadataField(label, value);
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void addTripMetadata(ReadableMap inputMetadata, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    final Map<String, String> metadata = SentianceConverter.convertReadableMapToMap(inputMetadata);
+    boolean result = sdk.addTripMetadata(metadata);
+    promise.resolve(result);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void addUserMetadataFields(ReadableMap inputMetadata, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    if (inputMetadata == null) {
+      promise.reject(E_SDK_MISSING_PARAMS, "metadata object is required");
+      return;
+    }
+
+    final Map<String, String> metadata = SentianceConverter.convertReadableMapToMap(inputMetadata);
+    sdk.addUserMetadataFields(metadata);
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void removeUserMetadataField(final String label, final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    if (label == null) {
+      promise.reject(E_SDK_MISSING_PARAMS, "label is required");
+      return;
+    }
+
+    sdk.removeUserMetadataField(label);
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void submitDetections(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    sdk.submitDetections()
+      .addOnCompleteListener(pendingOperation -> {
+        if (pendingOperation.isSuccessful()) {
+          promise.resolve(SentianceConverter.createEmptyResult());
+        } else {
+          SubmitDetectionsError error = pendingOperation.getError();
+          promise.reject(E_SDK_SUBMIT_DETECTIONS_ERROR, error.getReason().name());
+        }
+      });
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getWiFiQuotaLimit(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    long wifiQuotaLimit = sdk.getWiFiQuotaLimit();
+    promise.resolve(Long.toString(wifiQuotaLimit));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getWiFiQuotaUsage(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    long wifiQuotaUsage = sdk.getWiFiQuotaUsage();
+    promise.resolve(Long.toString(wifiQuotaUsage));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getMobileQuotaLimit(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    long mobileQuotaLimit = sdk.getMobileQuotaLimit();
+    promise.resolve(Long.toString(mobileQuotaLimit));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getMobileQuotaUsage(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    long mobileQuotaUsage = sdk.getMobileQuotaUsage();
+    promise.resolve(Long.toString(mobileQuotaUsage));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getDiskQuotaLimit(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    long diskQuotaLimit = sdk.getDiskQuotaLimit();
+    promise.resolve(Long.toString(diskQuotaLimit));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getDiskQuotaUsage(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    long diskQuotaUsage = sdk.getDiskQuotaUsage();
+    promise.resolve(Long.toString(diskQuotaUsage));
+  }
+
+  @SuppressLint("MissingPermission")
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void disableBatteryOptimization(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    sdk.disableBatteryOptimization();
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void listenUserActivityUpdates(Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    Sentiance.getInstance(reactContext).setUserActivityListener(emitter::sendUserActivityUpdate);
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void getUserActivity(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    UserActivity activity = Sentiance.getInstance(reactContext).getUserActivity();
+    promise.resolve(SentianceConverter.convertUserActivity(activity));
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void updateSdkNotification(final String title, final String message, Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    Notification notification = SentianceUtils.createNotificationFromManifestData(
+            new WeakReference<>(reactContext.getApplicationContext()),
+            title,
+            message);
+    if (notification != null) {
+      Sentiance.getInstance(reactContext)
+               .updateSdkNotification(notification);
+    }
+
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void setAppSessionDataCollectionEnabled(boolean enabled, Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    Sentiance.getInstance(reactContext).setAppSessionDataCollectionEnabled(enabled);
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void isAppSessionDataCollectionEnabled(Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    promise.resolve(Sentiance.getInstance(reactContext).isAppSessionDataCollectionEnabled());
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void listenSdkStatusUpdates(Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    Sentiance.getInstance(reactContext).setSdkStatusUpdateListener(sentianceHelper.getOnSdkStatusUpdateListener());
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void listenTripTimeout(Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    Sentiance.getInstance(reactContext)
+      .setTripTimeoutListener(emitter::sendOnTripTimedOutEvent);
+    promise.resolve(null);
+  }
+}
+

package/android/src/main/java/com/sentiance/react/bridge/core/SentiancePackage.java

@@ -0,0 +1,30 @@
+package com.sentiance.react.bridge.core;
+
+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 SentiancePackage implements ReactPackage {
+
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    SentianceModule sentianceModule = new SentianceModule(reactContext);
+    modules.add(sentianceModule);
+    return modules;
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/android/src/main/java/com/sentiance/react/bridge/core/UserLinker.java

@@ -0,0 +1,34 @@
+package com.sentiance.react.bridge.core;
+
+import androidx.annotation.NonNull;
+
+import java.util.concurrent.CountDownLatch;
+
+
+public class UserLinker implements com.sentiance.sdk.UserLinker {
+
+    private final SentianceEmitter mSentianceEmitter;
+    private boolean mUserLinkResult;
+    private CountDownLatch mCountDownLatch;
+
+    public UserLinker (SentianceEmitter sentianceEmitter) {
+        mSentianceEmitter = sentianceEmitter;
+    }
+
+    @Override
+    public boolean link(@NonNull String installId) {
+        mCountDownLatch = new CountDownLatch(1);
+        mSentianceEmitter.sendUserLinkEvent(installId);
+        try {
+            mCountDownLatch.await();
+            return mUserLinkResult;
+        } catch (InterruptedException e) {
+            return false;
+        }
+    }
+
+    public void setUserLinkResult(boolean userLinkResult) {
+        mUserLinkResult = userLinkResult;
+        mCountDownLatch.countDown();
+    }
+}

package/android/src/main/java/com/sentiance/react/bridge/core/base/AbstractSentianceEmitter.java

@@ -0,0 +1,59 @@
+package com.sentiance.react.bridge.core.base;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactNativeHost;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+public abstract class AbstractSentianceEmitter {
+
+  protected final Handler mHandler = new Handler(Looper.getMainLooper());
+  protected ReactContext reactContext;
+  protected ReactNativeHost reactNativeHost;
+
+  protected AbstractSentianceEmitter(Context context) {
+    ReactApplication reactApplication = ((ReactApplication) context.getApplicationContext());
+    reactNativeHost = reactApplication.getReactNativeHost();
+    reactContext = createReactContext();
+  }
+
+  protected ReactContext createReactContext() {
+    if (!reactNativeHost.getReactInstanceManager().hasStartedCreatingInitialContext())
+      reactNativeHost.getReactInstanceManager().createReactContextInBackground();
+    return reactNativeHost.getReactInstanceManager().getCurrentReactContext();
+  }
+
+  protected void sendEvent(final String key, final WritableMap map) {
+    if (reactContext != null && reactContext.hasActiveCatalystInstance()) {
+      this.reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(key, map);
+    } else {
+      // add delay
+      final Counter retry = new Counter(20);
+      mHandler.postDelayed(new Runnable() {
+        @Override
+        public void run() {
+          if (AbstractSentianceEmitter.this.reactContext == null)
+            AbstractSentianceEmitter.this.reactContext = createReactContext();
+          if (AbstractSentianceEmitter.this.reactContext != null && AbstractSentianceEmitter.this.reactContext.hasActiveCatalystInstance()) {
+            AbstractSentianceEmitter.this.reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(key, map);
+          } else if (retry.count-- > 0) {
+            mHandler.postDelayed(this, 500);
+          }
+        }
+      }, 500);
+    }
+  }
+
+  private static class Counter {
+    int count;
+
+    Counter(int count) {
+      this.count = count;
+    }
+  }
+}

package/android/src/main/java/com/sentiance/react/bridge/core/base/AbstractSentianceModule.java

@@ -0,0 +1,33 @@
+package com.sentiance.react.bridge.core.base;
+
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_NOT_INITIALIZED;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.sentiance.sdk.InitState;
+import com.sentiance.sdk.Sentiance;
+
+public abstract class AbstractSentianceModule extends ReactContextBaseJavaModule {
+
+  protected final ReactApplicationContext reactContext;
+  protected final Sentiance sdk;
+
+  public AbstractSentianceModule(ReactApplicationContext reactApplicationContext) {
+    super(reactApplicationContext);
+    reactContext = reactApplicationContext;
+    sdk = Sentiance.getInstance(reactContext);
+  }
+
+  protected boolean rejectIfNotInitialized(Promise promise) {
+    if (!isSdkInitialized()) {
+      promise.reject(E_SDK_NOT_INITIALIZED, "Sdk not initialized");
+      return true;
+    }
+    return false;
+  }
+
+  private boolean isSdkInitialized() {
+    return sdk.getInitState() == InitState.INITIALIZED;
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.sentiance.react.bridge.core.utils;
+
+public class ErrorCodes {
+  public static final String E_SDK_MISSING_PARAMS = "E_SDK_MISSING_PARAMS";
+  public static final String E_SDK_GET_TOKEN_ERROR = "E_SDK_GET_TOKEN_ERROR";
+  public static final String E_SDK_START_TRIP_ERROR = "E_SDK_START_TRIP_ERROR";
+  public static final String E_SDK_STOP_TRIP_ERROR = "E_SDK_STOP_TRIP_ERROR";
+  public static final String E_SDK_NOT_INITIALIZED = "E_SDK_NOT_INITIALIZED";
+  public static final String E_SDK_SUBMIT_DETECTIONS_ERROR = "E_SDK_SUBMIT_DETECTIONS_ERROR";
+  public static final String E_SDK_ENABLE_DETECTIONS_ERROR = "E_SDK_ENABLE_DETECTIONS_ERROR";
+  public static final String E_SDK_DISABLE_DETECTIONS_ERROR = "E_SDK_DISABLE_DETECTIONS_ERROR";
+  public static final String E_SDK_USER_LINK_ERROR = "E_SDK_USER_LINK_ERROR";
+  public static final String E_SDK_USER_LINK_AUTH_CODE_ERROR = "E_SDK_USER_LINK_AUTH_CODE_ERROR";
+  public static final String E_SDK_CREATE_USER_ERROR = "E_SDK_CREATE_USER_ERROR";
+  public static final String E_SDK_RESET_ERROR = "E_SDK_RESET_ERROR";
+}