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

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

@@ -0,0 +1,364 @@
+package com.sentiance.react.bridge.core;
+
+import android.location.Location;
+
+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 com.sentiance.sdk.DetectionStatus;
+import com.sentiance.sdk.DisableDetectionsResult;
+import com.sentiance.sdk.EnableDetectionsError;
+import com.sentiance.sdk.EnableDetectionsFailureReason;
+import com.sentiance.sdk.EnableDetectionsResult;
+import com.sentiance.sdk.InitState;
+import com.sentiance.sdk.SdkStatus;
+import com.sentiance.sdk.Token;
+import com.sentiance.sdk.UserAccessTokenError;
+import com.sentiance.sdk.UserAccessTokenFailureReason;
+import com.sentiance.sdk.authentication.UserLinkingError;
+import com.sentiance.sdk.authentication.UserLinkingResult;
+import com.sentiance.sdk.detectionupdates.UserActivity;
+import com.sentiance.sdk.detectionupdates.UserActivityType;
+import com.sentiance.sdk.reset.ResetError;
+import com.sentiance.sdk.reset.ResetResult;
+import com.sentiance.sdk.trip.StartTripError;
+import com.sentiance.sdk.trip.StartTripFailureReason;
+import com.sentiance.sdk.trip.StopTripError;
+import com.sentiance.sdk.trip.StopTripFailureReason;
+import com.sentiance.sdk.trip.TransportMode;
+import com.sentiance.sdk.trip.TripType;
+import com.sentiance.sdk.usercreation.UserCreationError;
+import com.sentiance.sdk.usercreation.UserCreationResult;
+import com.sentiance.sdk.usercreation.UserInfo;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class SentianceConverter {
+
+  public static WritableMap createEmptyResult() {
+    return Arguments.createMap();
+  }
+
+  public static Map<String, String> convertReadableMapToMap(ReadableMap inputMap) {
+    Map<String, String> map = new HashMap<String, String>();
+    ReadableMapKeySetIterator iterator = inputMap.keySetIterator();
+    while (iterator.hasNextKey()) {
+      String key = iterator.nextKey();
+      try {
+        map.put(key, String.valueOf(inputMap.getString(key)));
+      } catch (Exception ignored) {
+
+      }
+    }
+    return map;
+  }
+
+  public static TripType toTripType(final String type) {
+    if (type.equals("sdk") || type.equals("TRIP_TYPE_SDK")) {
+      return TripType.SDK_TRIP;
+    } else if (type.equals("external") || type.equals("TRIP_TYPE_EXTERNAL")) {
+      return TripType.EXTERNAL_TRIP;
+    } else {
+      return TripType.ANY;
+    }
+  }
+
+  public static TransportMode toTransportMode(int t) {
+    switch (t) {
+      case 2:
+        return TransportMode.CAR;
+      case 3:
+        return TransportMode.BICYCLE;
+      case 4:
+        return TransportMode.ON_FOOT;
+      case 5:
+        return TransportMode.TRAIN;
+      case 6:
+        return TransportMode.TRAM;
+      case 7:
+        return TransportMode.BUS;
+      case 8:
+        return TransportMode.PLANE;
+      case 9:
+        return TransportMode.BOAT;
+      case 10:
+        return TransportMode.METRO;
+      case 11:
+        return TransportMode.RUNNING;
+      default:
+        return null;
+    }
+  }
+
+  public static String convertInitState(InitState initState) {
+    switch (initState) {
+      case NOT_INITIALIZED:
+        return "NOT_INITIALIZED";
+      case INIT_IN_PROGRESS:
+        return "INIT_IN_PROGRESS";
+      case INITIALIZED:
+        return "INITIALIZED";
+      case RESETTING:
+        return "RESETTING";
+      default:
+        return "UNRECOGNIZED_STATE";
+    }
+  }
+
+  public static WritableMap convertToken(Token token) {
+    WritableMap map = Arguments.createMap();
+    try {
+      map.putString("tokenId", token.getTokenId());
+      map.putString("expiryDate", String.valueOf(token.getExpiryDate()));
+    } catch (Exception ignored) {
+    }
+
+    return map;
+  }
+
+  public static WritableMap convertUserCreationResult(UserCreationResult result) {
+    WritableMap map = Arguments.createMap();
+    UserInfo userInfo = result.getUserInfo();
+    try {
+      Token token = userInfo.getToken();
+      map.putString("userId", userInfo.getUserId());
+      map.putString("tokenId", token.getTokenId());
+      map.putString("tokenExpiryDate", token.getExpiryDate().toString());
+      map.putBoolean("isTokenExpired", token.isExpired());
+    } catch (Exception ignored) {
+    }
+
+    return map;
+  }
+
+  public static WritableMap convertUserLinkingResult(UserLinkingResult result) {
+    WritableMap map = Arguments.createMap();
+    UserInfo userInfo = result.getUserInfo();
+    try {
+      Token token = userInfo.getToken();
+      map.putString("userId", userInfo.getUserId());
+      map.putString("tokenId", token.getTokenId());
+      map.putString("tokenExpiryDate", token.getExpiryDate().toString());
+      map.putBoolean("isTokenExpired", token.isExpired());
+    } catch (Exception ignored) {
+    }
+
+    return map;
+  }
+
+  public static WritableMap convertInstallId(String installId) {
+    WritableMap map = Arguments.createMap();
+    try {
+      map.putString("installId", installId);
+    } catch (Exception ignored) {
+    }
+    return map;
+  }
+
+  public static WritableMap convertSdkStatus(SdkStatus status) {
+    WritableMap map = Arguments.createMap();
+    try {
+      map.putString("startStatus", status.startStatus.name());
+      map.putString("detectionStatus", status.detectionStatus.name());
+      map.putBoolean("canDetect", status.canDetect);
+      map.putBoolean("isRemoteEnabled", status.isRemoteEnabled);
+      map.putString("locationPermission", status.locationPermission.toString());
+      map.putBoolean("isActivityRecognitionPermGranted", status.isActivityRecognitionPermGranted);
+      map.putString("locationSetting", status.locationSetting.name());
+      map.putBoolean("isAirplaneModeEnabled", status.isAirplaneModeEnabled);
+      map.putBoolean("isLocationAvailable", status.isLocationAvailable);
+      map.putBoolean("isAccelPresent", status.isAccelPresent);
+      map.putBoolean("isGyroPresent", status.isGyroPresent);
+      map.putBoolean("isGpsPresent", status.isGpsPresent);
+      map.putBoolean("isGooglePlayServicesMissing", status.isGooglePlayServicesMissing);
+      map.putBoolean("isBatteryOptimizationEnabled", status.isBatteryOptimizationEnabled);
+      map.putBoolean("isBatterySavingEnabled", status.isBatterySavingEnabled);
+      map.putBoolean("isBackgroundProcessingRestricted", status.isBackgroundProcessingRestricted);
+      map.putBoolean("isPreciseLocationAuthorizationGranted", status.isPreciseLocationPermGranted);
+      map.putBoolean("isSchedulingExactAlarmsPermitted", status.isSchedulingExactAlarmsPermitted);
+      map.putString("wifiQuotaStatus", status.wifiQuotaStatus.toString());
+      map.putString("mobileQuotaStatus", status.mobileQuotaStatus.toString());
+      map.putString("diskQuotaStatus", status.diskQuotaStatus.toString());
+    } catch (Exception ignored) {
+    }
+
+    return map;
+  }
+
+  public static WritableMap convertUserActivity(UserActivity activity) {
+    WritableMap map = Arguments.createMap();
+    try {
+      map.putString("type", convertUserActivityType(activity.getActivityType()));
+
+      //Trip Info
+      if (activity.getTripInfo() != null) {
+        WritableMap tripInfoMap = Arguments.createMap();
+        String tripType = convertTripType(activity.getTripInfo().getTripType());
+        tripInfoMap.putString("type", tripType);
+        map.putMap("tripInfo", tripInfoMap);
+      }
+
+      //Stationary Info
+      if (activity.getStationaryInfo() != null) {
+        WritableMap stationaryInfoMap = Arguments.createMap();
+        if (activity.getStationaryInfo().getLocation() != null) {
+          WritableMap locationMap = convertLocation(activity.getStationaryInfo().getLocation());
+          stationaryInfoMap.putMap("location", locationMap);
+        }
+        map.putMap("stationaryInfo", stationaryInfoMap);
+      }
+
+    } catch (Exception ignored) {
+    }
+
+    return map;
+  }
+
+  public static WritableMap convertLocation(Location location) {
+    WritableMap locationMap = Arguments.createMap();
+
+    locationMap.putString("latitude", String.valueOf(location.getLatitude()));
+    locationMap.putString("longitude", String.valueOf(location.getLongitude()));
+    locationMap.putString("accuracy", String.valueOf(location.getAccuracy()));
+    locationMap.putString("altitude", String.valueOf(location.getAltitude()));
+    locationMap.putString("provider", location.getProvider());
+
+    return locationMap;
+
+  }
+
+  public static String convertTripType(TripType tripType) {
+    switch (tripType) {
+      case ANY:
+        return "ANY";
+      case EXTERNAL_TRIP:
+        return "TRIP_TYPE_EXTERNAL";
+      case SDK_TRIP:
+        return "TRIP_TYPE_SDK";
+      default:
+        return "TRIP_TYPE_UNRECOGNIZED";
+    }
+  }
+
+  public static String convertUserActivityType(UserActivityType activityType) {
+    switch (activityType) {
+      case TRIP:
+        return "USER_ACTIVITY_TYPE_TRIP";
+      case STATIONARY:
+        return "USER_ACTIVITY_TYPE_STATIONARY";
+      case UNKNOWN:
+        return "USER_ACTIVITY_TYPE_UNKNOWN";
+      default:
+        return "USER_ACTIVITY_TYPE_UNRECOGNIZED";
+    }
+  }
+
+  public static WritableMap convertEnableDetectionsResult(EnableDetectionsResult enableDetectionsResult) {
+    return convertDetectionsResult(enableDetectionsResult.getSdkStatus(),
+      enableDetectionsResult.getDetectionStatus());
+  }
+
+  public static WritableMap convertDisableDetectionsResult(DisableDetectionsResult disableDetectionsResult) {
+    return convertDetectionsResult(disableDetectionsResult.getSdkStatus(),
+      disableDetectionsResult.getDetectionStatus());
+  }
+
+  public static WritableMap convertResetResult(ResetResult resetResult) {
+    WritableMap result = Arguments.createMap();
+    result.putString("initState", resetResult.getInitState().name());
+    return result;
+  }
+
+  private static WritableMap convertDetectionsResult(SdkStatus sdkStatus, DetectionStatus detectionStatus) {
+    WritableMap result = Arguments.createMap();
+    WritableMap sdkStatusMap = convertSdkStatus(sdkStatus);
+
+    result.putMap("sdkStatus", sdkStatusMap);
+    result.putString("detectionStatus", detectionStatus.toString());
+
+    return result;
+  }
+
+  public static String stringifyEnableDetectionsError(EnableDetectionsError error) {
+    EnableDetectionsFailureReason reason = error.getReason();
+    String details = "";
+    switch (reason) {
+      case NO_USER:
+        details = "No Sentiance user present on the device.";
+        break;
+      case PAST_EXPIRY_DATE:
+        details = "Expiry date is in past.";
+        break;
+      case USER_DISABLED_REMOTELY:
+        details = "The user is disabled remotely.";
+        break;
+    }
+    return String.format("Reason: %s - %s", reason.name(), details);
+  }
+
+  public static String stringifyUserLinkingError(UserLinkingError error) {
+    return String.format("Reason: %s - %s", error.getReason().name(), error.getDetails());
+  }
+
+  public static String stringifyUserCreationError(UserCreationError error) {
+    return String.format("Reason: %s - %s", error.getReason().name(), error.getDetails());
+  }
+
+  public static String stringifyResetError(ResetError error) {
+    return String.format("%s - caused by: %s", error.getReason().name(), error.getException());
+  }
+
+  public static String stringifyStartTripError(StartTripError error) {
+    StartTripFailureReason reason = error.getReason();
+    String details = "";
+    switch (reason) {
+      case NO_USER:
+        details = "No Sentiance user present on the device.";
+        break;
+      case DETECTIONS_DISABLED:
+        details = "Detections are disabled. Enable them first before starting a trip.";
+        break;
+      case DETECTIONS_BLOCKED:
+        details = "Detections are enabled but not running. Check the SDK's status to find out why.";
+        break;
+      case TRIP_ALREADY_STARTED:
+        details = "An external trip is already started. To start a new trip, call `stopTrip()` first.";
+        break;
+      case USER_DISABLED_REMOTELY:
+        details = "The user is disabled remotely.";
+        break;
+    }
+    return String.format("Reason: %s - %s", reason.name(), details);
+  }
+
+  public static String stringifyStopTripError(StopTripError error) {
+    StopTripFailureReason reason = error.getReason();
+    String details = "";
+    switch (reason) {
+      case NO_ONGOING_TRIP:
+        details = "There is no ongoing external trip.";
+        break;
+    }
+    return String.format("Reason: %s - %s", reason.name(), details);
+  }
+
+  public static String stringifyUserAccessTokenError(UserAccessTokenError error) {
+    UserAccessTokenFailureReason reason = error.getReason();
+    String details = "";
+    switch (reason) {
+      case NO_USER:
+        details = "No Sentiance user is present on device.";
+        break;
+      case NETWORK_ERROR:
+        details = "A network error occurred. This can happen when the existing token is expired, " +
+          "and it was not possible to contact the Sentiance Platform to refresh it.";
+        break;
+      case USER_DISABLED_REMOTELY:
+        details = "The user is disabled remotely.";
+        break;
+    }
+    return String.format("Reason: %s - %s", reason.name(), details);
+  }
+}

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

@@ -0,0 +1,46 @@
+package com.sentiance.react.bridge.core;
+
+import static com.sentiance.react.bridge.core.SentianceConverter.convertInstallId;
+import static com.sentiance.react.bridge.core.SentianceConverter.convertSdkStatus;
+import static com.sentiance.react.bridge.core.SentianceConverter.convertUserActivity;
+
+import android.content.Context;
+
+import com.facebook.react.bridge.Arguments;
+import com.sentiance.react.bridge.core.base.AbstractSentianceEmitter;
+import com.sentiance.sdk.SdkStatus;
+import com.sentiance.sdk.detectionupdates.UserActivity;
+
+public class SentianceEmitter extends AbstractSentianceEmitter {
+  private static final String USER_LINK = "SENTIANCE_USER_LINK_EVENT";
+  private static final String STATUS_UPDATE = "SENTIANCE_STATUS_UPDATE_EVENT";
+  private static final String USER_ACTIVITY_UPDATE = "SENTIANCE_USER_ACTIVITY_UPDATE_EVENT";
+  private static final String ON_DETECTIONS_ENABLED = "SENTIANCE_ON_DETECTIONS_ENABLED_EVENT";
+  private static final String ON_TRIP_TIMED_OUT = "SENTIANCE_ON_TRIP_TIMED_OUT_EVENT";
+
+  public SentianceEmitter(Context context) {
+    super(context);
+  }
+
+  void sendUserLinkEvent(String installId) {
+    sendEvent(USER_LINK, convertInstallId(installId));
+  }
+
+  public void sendStatusUpdateEvent(SdkStatus status) {
+    sendEvent(STATUS_UPDATE, convertSdkStatus(status));
+  }
+
+  void sendUserActivityUpdate(UserActivity userActivity) {
+    sendEvent(USER_ACTIVITY_UPDATE, convertUserActivity(userActivity));
+  }
+
+  void sendOnDetectionsEnabledEvent(SdkStatus status) {
+    sendEvent(ON_DETECTIONS_ENABLED, convertSdkStatus(status));
+  }
+
+  void sendOnTripTimedOutEvent() {
+    sendEvent(ON_TRIP_TIMED_OUT, Arguments.createMap());
+  }
+}
+
+

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

@@ -0,0 +1,207 @@
+package com.sentiance.react.bridge.core;
+
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_DISABLE_DETECTIONS_ERROR;
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_ENABLE_DETECTIONS_ERROR;
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_USER_LINK_AUTH_CODE_ERROR;
+import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_USER_LINK_ERROR;
+
+import android.app.Notification;
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Promise;
+import com.sentiance.react.bridge.core.utils.SentianceUtils;
+import com.sentiance.sdk.DisableDetectionsResult;
+import com.sentiance.sdk.EnableDetectionsError;
+import com.sentiance.sdk.EnableDetectionsResult;
+import com.sentiance.sdk.OnSdkStatusUpdateHandler;
+import com.sentiance.sdk.SdkStatus;
+import com.sentiance.sdk.SdkStatusUpdateListener;
+import com.sentiance.sdk.Sentiance;
+import com.sentiance.sdk.authentication.UserLinkingError;
+import com.sentiance.sdk.init.InitializationFailureReason;
+import com.sentiance.sdk.init.InitializationResult;
+import com.sentiance.sdk.init.SentianceOptions;
+import com.sentiance.sdk.pendingoperation.PendingOperation;
+import com.sentiance.sdk.usercreation.UserCreationError;
+import com.sentiance.sdk.usercreation.UserCreationOptions;
+import com.sentiance.sdk.usercreation.UserCreationResult;
+
+import java.lang.ref.WeakReference;
+import java.util.Date;
+
+public class SentianceHelper {
+  private static SentianceHelper sentianceHelper;
+
+  private final SentianceEmitter emitter;
+  private final WeakReference<Context> weakContext;
+  private final UserLinker userLinker;
+
+  private final OnSdkStatusUpdateHandler onSdkStatusUpdateHandler = this::onSdkStatusUpdated;
+
+  private final SdkStatusUpdateListener onSdkStatusUpdateListener = this::onSdkStatusUpdated;
+
+  SdkStatusUpdateListener getOnSdkStatusUpdateListener() {
+    return onSdkStatusUpdateListener;
+  }
+
+
+  protected SentianceHelper(Context context) {
+    emitter = new SentianceEmitter(context);
+    weakContext = new WeakReference<>(context);
+    userLinker = new UserLinker(emitter);
+  }
+
+  public static SentianceHelper getInstance(Context context) {
+    if (sentianceHelper == null) {
+      synchronized (SentianceHelper.class) {
+        sentianceHelper = new SentianceHelper(context);
+      }
+    }
+    return sentianceHelper;
+  }
+
+  private void onSdkStatusUpdated(@NonNull SdkStatus status) {
+    emitter.sendStatusUpdateEvent(status);
+  }
+
+  void userLinkCallback(final Boolean linkResult) {
+    userLinker.setUserLinkResult(linkResult);
+  }
+
+  public InitializationResult initializeSDK() {
+    return initializeSDK(false);
+  }
+
+  public InitializationResult initializeSDK(boolean isAppSessionDataCollectionEnabled) {
+    Context context = weakContext.get();
+    if (context == null) {
+      return new InitializationResult(
+        false, InitializationFailureReason.EXCEPTION_OR_ERROR, new Exception("Context is null"));
+    }
+    Notification notification = SentianceUtils.createNotificationFromManifestData(weakContext);
+    if (notification == null) {
+      return new InitializationResult(false, InitializationFailureReason.EXCEPTION_OR_ERROR,
+              new Throwable("null context while creating notification"));
+    }
+    Sentiance sentiance = Sentiance.getInstance(context);
+
+    SentianceOptions options = new SentianceOptions.Builder(context)
+      .setNotification(notification, SentianceUtils.getSentianceNotificationId(weakContext))
+      .collectAppSessionData(isAppSessionDataCollectionEnabled)
+      .build();
+    InitializationResult result = sentiance.initialize(options);
+    if (result.isSuccessful()) {
+      sentiance.setSdkStatusUpdateListener(onSdkStatusUpdateListener);
+    }
+    return result;
+  }
+
+  PendingOperation<UserCreationResult, UserCreationError> createLinkedUser(String authCode, String platformUrl) {
+    UserCreationOptions.Builder builder = new UserCreationOptions.Builder(authCode);
+    if (platformUrl != null) {
+      builder.setPlatformUrl(platformUrl);
+    }
+    return getSentiance().createUser(builder.build());
+  }
+
+  PendingOperation<UserCreationResult, UserCreationError> createUnlinkedUser(String appId, String secret,
+                                                                             String platformUrl) {
+    UserCreationOptions.Builder builder = new UserCreationOptions.Builder(appId, secret, UserLinker.NO_OP);
+    if (platformUrl != null) {
+      builder.setPlatformUrl(platformUrl);
+    }
+
+    return getSentiance().createUser(builder.build());
+  }
+
+  PendingOperation<UserCreationResult, UserCreationError> createLinkedUser(String appId, String secret,
+                                                                           String platformUrl) {
+    UserCreationOptions.Builder builder = new UserCreationOptions.Builder(appId, secret, userLinker   );
+    if (platformUrl != null) {
+      builder.setPlatformUrl(platformUrl);
+    }
+    return getSentiance().createUser(builder.build());
+  }
+
+  void enableDetections(@Nullable final Promise promise) {
+    enableDetections(null, promise);
+  }
+
+  void enableDetections(@Nullable Long stopTime, @Nullable final Promise promise) {
+    Sentiance sentiance = getSentiance();
+    Date stopDate = null;
+
+    if (stopTime != null) {
+      stopDate = new Date(stopTime);
+    }
+
+    sentiance.enableDetections(stopDate)
+      .addOnCompleteListener(pendingOperation -> {
+        if (pendingOperation.isSuccessful()) {
+          EnableDetectionsResult result = pendingOperation.getResult();
+          emitter.sendOnDetectionsEnabledEvent(result.getSdkStatus());
+          if (promise != null) {
+            promise.resolve(SentianceConverter.convertEnableDetectionsResult(result));
+          }
+        } else {
+          EnableDetectionsError error = pendingOperation.getError();
+          if (promise != null) {
+            promise.reject(E_SDK_ENABLE_DETECTIONS_ERROR,
+              SentianceConverter.stringifyEnableDetectionsError(error));
+          }
+        }
+      });
+  }
+
+  void disableDetections(final Promise promise) {
+    Sentiance sentiance = getSentiance();
+    sentiance.disableDetections()
+            .addOnCompleteListener(pendingOperation -> {
+              if (pendingOperation.isSuccessful()) {
+                DisableDetectionsResult result = pendingOperation.getResult();
+                promise.resolve(SentianceConverter.convertDisableDetectionsResult(result));
+              } else {
+                promise.reject(E_SDK_DISABLE_DETECTIONS_ERROR, "");
+              }
+            });
+  }
+
+  void linkUser(final Promise promise) {
+    Sentiance sentiance = getSentiance();
+    sentiance.linkUser(userLinker)
+      .addOnCompleteListener(pendingOperation -> {
+        if (pendingOperation.isSuccessful()) {
+          promise.resolve(SentianceConverter.convertUserLinkingResult(pendingOperation.getResult()));
+        } else {
+          UserLinkingError error = pendingOperation.getError();
+          promise.reject(E_SDK_USER_LINK_ERROR,
+            SentianceConverter.stringifyUserLinkingError(error));
+        }
+      });
+  }
+
+  void linkUser(String authCode, final Promise promise) {
+    Sentiance sentiance = getSentiance();
+    sentiance.linkUser(authCode)
+      .addOnCompleteListener(pendingOperation -> {
+        if (pendingOperation.isSuccessful()) {
+          promise.resolve(SentianceConverter.convertUserLinkingResult(pendingOperation.getResult()));
+        } else {
+          UserLinkingError error = pendingOperation.getError();
+          promise.reject(E_SDK_USER_LINK_AUTH_CODE_ERROR,
+            SentianceConverter.stringifyUserLinkingError(error));
+        }
+      });
+  }
+
+  private Sentiance getSentiance() {
+    Context context = weakContext.get();
+    if (context == null) {
+      throw new IllegalStateException("Context is null.");
+    }
+    return Sentiance.getInstance(context);
+  }
+}