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

package/lib/index.d.ts

@@ -0,0 +1,197 @@
+declare module "sentiance-react-native-core" {
+  import {EmitterSubscription} 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 TripType = "TRIP_TYPE_SDK" | "TRIP_TYPE_EXTERNAL";
+
+  export enum TransportMode {
+    UNKNOWN = 1,
+    CAR,
+    BICYCLE,
+    ON_FOOT,
+    TRAIN,
+    TRAM,
+    BUS,
+    PLANE,
+    BOAT,
+    METRO,
+    RUNNING,
+  }
+
+  export interface UserInfo {
+    userId: string,
+    tokenId: string,
+    tokenExpiryDate: string,
+    isTokenExpired: boolean
+  }
+
+  export interface UserLinkingResult {
+    userInfo: UserInfo
+  }
+
+  export interface CreateUserResult {
+    userInfo: UserInfo
+  }
+
+  export interface UserCreationOptions {
+    appId: string,
+    appSecret: string,
+    authCode: string,
+    platformUrl: string,
+    linker: (installId: string) => boolean
+  }
+
+  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 ResetResult {
+    initState: string
+  }
+
+  export interface SdkStatus {
+    startStatus: string;
+    canDetect: boolean;
+    isRemoteEnabled: boolean;
+    isAccelPresent: boolean;
+    isGyroPresent: boolean;
+    isGpsPresent: boolean;
+    wifiQuotaStatus: string;
+    mobileQuotaStatus: string;
+    diskQuotaStatus: string;
+    locationPermission: LocationPermission;
+    userExists: boolean;
+    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 EnableDisableDetectionsResult {
+    sdkStatus: SdkStatus,
+    detectionStatus: string
+  }
+
+  export interface SentianceCore {
+    userLinkCallback(linkResult: boolean): void;
+
+    userExists(): Promise<boolean>;
+
+    enableDetections(): Promise<EnableDisableDetectionsResult>;
+
+    enableDetectionsWithExpiryDate(expiryEpochTimeMs: number | null): Promise<EnableDisableDetectionsResult>;
+
+    disableDetections(): Promise<EnableDisableDetectionsResult>;
+
+    reset(): Promise<ResetResult>;
+
+    isUserLinked(): Promise<boolean>;
+
+    getVersion(): Promise<string>;
+
+    getUserId(): Promise<string>;
+
+    requestUserAccessToken(): Promise<UserAccessToken>;
+
+    addUserMetadataField(label: string, value: string): Promise<void>;
+
+    addUserMetadataFields(label: MetadataObject): Promise<void>;
+
+    removeUserMetadataField(label: string): Promise<void>;
+
+    getUserActivity(): Promise<UserActivity>;
+
+    listenUserActivityUpdates(): Promise<void>;
+
+    listenTripTimeout(): Promise<void>;
+
+    startTrip(metadata: MetadataObject | null, hint: TransportMode): Promise<void>;
+
+    stopTrip(): Promise<void>;
+
+    isTripOngoing(type: TripType): Promise<boolean>;
+
+    submitDetections(): Promise<void>;
+
+    updateSdkNotification(title: string, message: string): Promise<void>;
+
+    addTripMetadata(metadata: MetadataObject): Promise<boolean>;
+
+    setAppSessionDataCollectionEnabled(enabled: boolean): Promise<void>;
+
+    isAppSessionDataCollectionEnabled(): Promise<boolean>;
+
+    getInitState(): Promise<SdkInitState>;
+
+    getSdkStatus(): Promise<SdkStatus>;
+
+    getWiFiQuotaLimit(): Promise<string>;
+
+    getWiFiQuotaUsage(): Promise<string>;
+
+    getMobileQuotaLimit(): Promise<string>;
+
+    getMobileQuotaUsage(): Promise<string>;
+
+    getDiskQuotaLimit(): Promise<string>;
+
+    getDiskQuotaUsage(): Promise<string>;
+
+    disableBatteryOptimization(): Promise<void>;
+
+    createUser(options: UserCreationOptions): Promise<CreateUserResult>;
+
+    linkUser(): Promise<UserLinkingResult>;
+
+    linkUserWithAuthCode(authCode: string): Promise<UserLinkingResult>;
+
+    addSdkStatusUpdateListener(onSdkStatusUpdated: (sdkStatus: SdkStatus) => void): Promise<EmitterSubscription>;
+
+    addTripTimeoutListener(onTripTimedOut: () => void): Promise<EmitterSubscription>;
+
+    addSdkUserActivityUpdateListener(onUserActivityUpdated: (userActivity: UserActivity) => void): Promise<EmitterSubscription>;
+  }
+
+  const SentianceCore: SentianceCore;
+  export default SentianceCore;
+}

package/lib/index.js

@@ -0,0 +1,221 @@
+import core from './core';
+import Platform from 'react-native';
+
+const enableDetections = () => core.enableDetections();
+const enableDetectionsWithExpiryDate = (expiryTime) => core.enableDetectionsWithExpiryDate(expiryTime);
+const disableDetections = () => core.disableDetections();
+const getInitState = () => core.getInitState();
+const userLinkCallback = (userLinkResult) => core.userLinkCallback(userLinkResult);
+const userExists = () => core.userExists();
+const isUserLinked = () => core.isUserLinked();
+const getVersion = () => core.getVersion();
+const getUserId = () => core.getUserId();
+const requestUserAccessToken = () => core.requestUserAccessToken();
+const addUserMetadataField = (label, value) => core.addUserMetadataField(label, value);
+const addUserMetadataFields = (metadata) => core.addUserMetadataFields(metadata);
+const removeUserMetadataField = (label) => core.removeUserMetadataField(label);
+const getUserActivity = () => core.getUserActivity();
+const listenUserActivityUpdates = () => core.listenUserActivityUpdates();
+const listenTripTimeout = () => core.listenTripTimeout();
+const isTripOngoing = (tripType) => core.isTripOngoing(tripType);
+const updateSdkNotification = (title, message) => core.updateSdkNotification(title, message);
+const addTripMetadata = (metadata) => core.addTripMetadata(metadata);
+const setAppSessionDataCollectionEnabled = (enabled) => core.setAppSessionDataCollectionEnabled(enabled);
+const isAppSessionDataCollectionEnabled = () => core.isAppSessionDataCollectionEnabled();
+const getSdkStatus = () => core.getSdkStatus();
+const getDiskQuotaLimit = () => core.getDiskQuotaLimit();
+const getDiskQuotaUsage = () => core.getDiskQuotaUsage();
+const disableBatteryOptimization = () => core.disableBatteryOptimization();
+const getMobileQuotaLimit = () => core.getMobileQuotaLimit();
+const getMobileQuotaUsage = () => core.getMobileQuotaUsage();
+const getWiFiQuotaLimit = () => core.getWiFiQuotaLimit();
+const getWiFiQuotaUsage = () => core.getWiFiQuotaUsage();
+const linkUserWithAuthCode = (authCode) => core.linkUserWithAuthCode(authCode);
+const NO_OP_LINKER = {}
+
+var startTrip
+var stopTrip
+var submitDetections
+var reset
+
+if (Platform.OS === 'ios') {
+  startTrip = (metadata, hint) => core.startTripNewApi(metadata, hint);
+  stopTrip = () => core.stopTripNewApi();
+  submitDetections = () => core.submitDetectionsNewApi();
+  reset = () => core.resetNewApi();
+}
+else {
+  startTrip = (metadata, hint) => core.startTrip(metadata, hint);
+  stopTrip = () => core.stopTrip();
+  submitDetections = () => core.submitDetections();
+  reset = () => core.reset();
+}
+
+const linkUser = async (linker) => {
+  await core._addUserLinkListener(linker);
+  return core.linkUser();
+};
+
+/**
+ * @typedef {Object} UserCreationOptions
+ * @property {String} authCode - Auth Code
+ * @property {String} platformUrl - Sentiance Platform URL
+ * @property {String} appId - APP ID
+ * @property {String} appSecret - APP Secret
+ * @property {Function} linker (data) => result - Function to handle the user linking
+ *
+ * const userCreationOptions = {
+ *  authCode: "<AUTH_CODE>"
+ * }
+ *
+ * createUser(userCreationOptions);
+ *
+ * Or with appId / appSecret (Not recommended)
+ *
+ * const userCreationOptions = {
+ *    linker : (installId) => {
+ *      return linkUser(installId);
+ *    },
+ *    appId : "<APP_ID>",
+ *    appSecret: "<APP_SECRET>"
+ *  }
+ *
+ *  createUser(userCreationOptions);
+ * 
+ * Or unlinked user with appId / appSecret (Not recommended)
+ *
+ * const userCreationOptions = {
+ *    linker : NO_OP_LINKER,
+ *    appId : "<APP_ID>",
+ *    appSecret: "<APP_SECRET>"
+ *  }
+ *
+ * createUser(userCreationOptions);
+ */
+
+
+/**
+ * Creates a Sentiance user if one does not yet exist, and links it to your app's user on the Sentiance platform.
+ * This method requires an initialized SDK, otherwise it throws a runtime exception.
+ *
+ * @param {UserCreationOptions} userCreationOptions
+ *
+ * @example
+ * const userCreationOptions = {
+ *  authCode: "<AUTH_CODE>"
+ * }
+ *
+ * createUser(userCreationOptions);
+ *
+ * Or with appId / appSecret (Not recommended)
+ *
+ * const userCreationOptions = {
+ *    linker : (installId) => {
+ *      return linkUser(installId);
+ *    },
+ *    appId : "<APP_ID>",
+ *    appSecret: "<APP_SECRET>"
+ *  }
+ *
+ * createUser(userCreationOptions);
+ * 
+ * Or unlinked user with appId / appSecret (Not recommended)
+ *
+ * const userCreationOptions = {
+ *    linker : NO_OP_LINKER,
+ *    appId : "<APP_ID>",
+ *    appSecret: "<APP_SECRET>"
+ *  }
+ *
+ * createUser(userCreationOptions);
+ */
+const createUser = async (userCreationOptions) => {
+
+  const appId = userCreationOptions.appId;
+  const appSecret = userCreationOptions.appSecret;
+  const authCode = userCreationOptions.authCode;
+  const platformUrl = userCreationOptions.platformUrl;
+  const linker = userCreationOptions.linker;
+
+  if (!appId && !appSecret && !authCode) {
+    return Promise.reject('Invalid userCreationOptions passed, please set authCode or appId/appSecret with a linker to create user');
+  }
+
+  if (authCode) {
+    return core.createLinkedUserWithAuthCode(authCode, platformUrl);
+  } 
+  else if (linker) {
+    if (linker === NO_OP_LINKER) {
+      return core.createUnlinkedUser(appId, appSecret, platformUrl);
+    } else {
+      await core._addUserLinkListener(linker);
+      return core.createLinkedUser(appId, appSecret, platformUrl);
+    }
+  }
+  else {
+    return Promise.reject('Invalid userCreationOptions passed, no authcode or linker specified.');
+  }
+}
+
+const addSdkStatusUpdateListener = core._addSdkStatusUpdateListener;
+const addSdkUserActivityUpdateListener = core._addSdkUserActivityUpdateListener;
+const addTripTimeoutListener = core._addTripTimeoutListener;
+
+const transportModes = {};
+(function (transportModes) {
+  transportModes[transportModes["UNKNOWN"] = 1] = "UNKNOWN";
+  transportModes[transportModes["CAR"] = 2] = "CAR";
+  transportModes[transportModes["BICYCLE"] = 3] = "BICYCLE";
+  transportModes[transportModes["ON_FOOT"] = 4] = "ON_FOOT";
+  transportModes[transportModes["TRAIN"] = 5] = "TRAIN";
+  transportModes[transportModes["TRAM"] = 6] = "TRAM";
+  transportModes[transportModes["BUS"] = 7] = "BUS";
+  transportModes[transportModes["PLANE"] = 8] = "PLANE";
+  transportModes[transportModes["BOAT"] = 9] = "BOAT";
+  transportModes[transportModes["METRO"] = 10] = "METRO";
+  transportModes[transportModes["RUNNING"] = 11] = "RUNNING";
+})(transportModes);
+
+module.exports = {
+  userLinkCallback,
+  userExists,
+  enableDetections,
+  enableDetectionsWithExpiryDate,
+  reset,
+  isUserLinked,
+  getVersion,
+  getUserId,
+  requestUserAccessToken,
+  addUserMetadataField,
+  addUserMetadataFields,
+  removeUserMetadataField,
+  getUserActivity,
+  listenUserActivityUpdates,
+  startTrip,
+  stopTrip,
+  isTripOngoing,
+  submitDetections,
+  updateSdkNotification,
+  addTripMetadata,
+  setAppSessionDataCollectionEnabled,
+  isAppSessionDataCollectionEnabled,
+  disableDetections,
+  getInitState,
+  getSdkStatus,
+  getDiskQuotaLimit,
+  getDiskQuotaUsage,
+  getMobileQuotaLimit,
+  getMobileQuotaUsage,
+  getWiFiQuotaLimit,
+  getWiFiQuotaUsage,
+  disableBatteryOptimization,
+  createUser,
+  linkUser,
+  linkUserWithAuthCode,
+  addSdkStatusUpdateListener,
+  addSdkUserActivityUpdateListener,
+  addTripTimeoutListener,
+  listenTripTimeout,
+  transportModes,
+  NO_OP_LINKER
+};

package/lib/utils.js

@@ -0,0 +1 @@
+export const varToString = varObj => Object.keys(varObj)[0];

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@sentiance-react-native/core",
+  "version": "6.0.0-beta.10",
+  "description": "React Native Sentiance core library",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "lint": "npx eslint lib/index.d.ts"
+  },
+  "keywords": [
+    "react-native",
+    "core",
+    "sentiance"
+  ],
+  "peerDependencies": {
+    "react-native": ">=0.60"
+  },
+  "author": "",
+  "license": "",
+  "homepage": "https://github.com/sentiance/react-native-sentiance/sentiance#readme",
+  "repository": "github:sentiance/react-native-sentiance",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sdkVersions": {
+    "android": {
+      "minSdk": 23,
+      "targetSdk": 31,
+      "compileSdk": 31,
+      "buildTools": "30.0.3",
+      "sentiance": "6.0.0-beta6"
+    },
+    "ios": {
+      "sentiance": "6.0.0-beta10"
+    }
+  }
+}