react-native-move-sdk 0.1.4 → 0.2.0

package/src/index.ts

@@ -5,47 +5,60 @@ import {
   EmitterSubscription,
 } from 'react-native';
 
-export type AndroidSdkState = 'Error' | 'Uninitialised' | 'Ready' | 'Running';
-export type SdkState = 'error' | 'uninitialized' | 'ready' | 'running';
-
-export type NativeSdkState = AndroidSdkState | SdkState;
-
-export type TripState = 'unknown' | 'driving' | 'halt' | 'idle' | 'ignored';
-export type AuthState = 'unknown' | 'valid' | 'expired';
-
-export type AndroidTripState =
-  | 'UNKNOWN'
-  | 'DRIVING'
-  | 'HALT'
-  | 'IDLE'
-  | 'IGNORED';
-
-export type NativeTripState = AndroidTripState | TripState;
-
-export type AndroidAuthState = 'UNKNOWN' | 'VALID' | 'EXPIRED';
-export type IosAuthState = 'unknown' | 'valid' | 'expired';
-export type NativeAuthState = AndroidAuthState | IosAuthState;
-
-export type DrivingService = 'DistractionFreeDriving' | 'DrivingBehaviour';
-export type WalkingService = 'Location';
-export type OtherService = 'PointsOfInterest';
+export type SdkState = 'UNINITIALIZED' | 'READY' | 'RUNNING';
+export type TripState = 'UNKNOWN' | 'DRIVING' | 'HALT' | 'IDLE' | 'IGNORED';
+export type AuthState = 'UNKNOWN' | 'VALID' | 'EXPIRED';
+export type DrivingService = 'DISTRACTION_FREE_DRIVING' | 'DRIVING_BEHAVIOUR';
+export type WalkingService = 'LOCATION';
+export type OtherService = 'POINTS_OF_INTEREST';
 export type TimelineDetectionService =
   | 'DRIVING'
-  | 'BICYCLE'
+  | 'CYCLING'
   | 'WALKING'
-  | 'PUBLIC_TRANSPORT';
+  | 'PUBLIC_TRANSPORT'
+  | 'AUTOMATIC_IMPACT_DETECTION'
+  | 'POINTS_OF_INTEREST';
+
+export type ErrorReasons =
+  | 'BACKGROUND_LOCATION_PERMISSION_MISSING'
+  | 'LOCATION_PERMISSION_MISSING'
+  | 'MOTION_PERMISSION_MISSING'
+  | 'BATTERY_OPTIMIZATION'
+  | 'BATTERY_PERMISSION_MISSING'
+  | 'BLUETOOTH_PERMISSION_MISSING';
+
+export type ErrorListService =
+  | 'DRIVING[]'
+  | 'DRIVING[DRIVING_BEHAVIOUR]'
+  | 'DRIVING[DISTRACTION_FREE_DRIVING]'
+  | 'DRIVING[DRIVING_BEHAVIOUR, DISTRACTION_FREE_DRIVING]'
+  | 'DRIVING[DISTRACTION_FREE_DRIVING, DRIVING_BEHAVIOUR]'
+  | 'WALKING[]'
+  | 'WALKING[LOCATION]'
+  | 'CYCLING'
+  | 'PUBLIC_TRANSPORT'
+  | 'AUTOMATIC_IMPACT_DETECTION'
+  | 'POINTS_OF_INTEREST';
+
+export type ErrorListItem = {
+  reasons: Array<ErrorReasons>;
+  service?: ErrorListService;
+};
+
+export type ErrorListType = Array<ErrorListItem>;
+
 export type MoveSdkConfig = {
   timelineDetectionServices: TimelineDetectionService[];
   drivingServices: DrivingService[];
   walkingServices: WalkingService[];
-  otherServices: OtherService[];
+  otherServices?: OtherService[];
 };
 
 export type MoveSdkAuth = {
-  contractId: string;
+  userId: string;
   accessToken: string;
   refreshToken: string;
-  productId: number;
+  projectId: number;
 };
 
 export type NotificationConfig = {
@@ -64,81 +77,46 @@ export type MoveSdkAndroidConfig = {
 
 export type ListenerSubscription = EmitterSubscription;
 
-export type ConfigurationError =
-  | 'authinvalid'
-  | 'configmismatch'
-  | 'serviceunreachable';
-
-export type IosConfigurationError =
-  | 'serviceUnreachable'
-  | 'authInvalid'
-  | 'configMismatch';
-
-export type AndroidConfigurationError =
-  | 'ServiceUnreachable'
-  | 'AuthInvalid'
-  | 'ConfigMismatch';
-
-export type NativeConfigurationError =
-  | IosConfigurationError
-  | AndroidConfigurationError;
-
 export type AuthStateEvent = {
   state: AuthState;
   accessToken?: string;
   refreshToken?: string;
 };
 
-const { DolphinSdk: NativeMoveSdk } = NativeModules;
+const { MoveSdk: NativeMoveSdk } = NativeModules;
 const eventEmitter = new NativeEventEmitter(NativeMoveSdk);
 
 export default class MoveSdk {
-  static ERROR: SdkState = 'error';
-  static READY: SdkState = 'ready';
-  static RUNNING: SdkState = 'running';
-  static UNINITIALIZED: SdkState = 'uninitialized';
-
-  static AUTH_INVALID: ConfigurationError = 'authinvalid';
-  static AUTH_EXPIRED: AuthState = 'expired';
-  static AUTH_VALID: AuthState = 'valid';
-
-  static UNKNOWN: TripState = 'unknown';
-  static DRIVING: TripState = 'driving';
-  static HALT: TripState = 'halt';
-  static IDLE: TripState = 'idle';
-  static IGNORED: TripState = 'ignored';
-
-  static sdkStateFromNative(nativeSdkState: NativeSdkState): SdkState | null {
-    let stateString = nativeSdkState?.toLowerCase() as SdkState;
-
-    if (stateString?.includes('(')) {
-      stateString = stateString
-        ?.substring(0, stateString?.indexOf('('))
-        .toLowerCase() as SdkState;
-    }
-
-    switch (stateString) {
-      case 'uninitialized':
-        return MoveSdk.UNINITIALIZED;
+  static READY: SdkState = 'READY';
+  static RUNNING: SdkState = 'RUNNING';
+  static UNINITIALIZED: SdkState = 'UNINITIALIZED';
 
-      case 'ready':
-        return MoveSdk.READY;
+  static AUTH_EXPIRED: AuthState = 'EXPIRED';
+  static AUTH_VALID: AuthState = 'VALID';
+  static AUTH_UNKNOWN: AuthState = 'UNKNOWN';
 
-      case 'running':
-        return MoveSdk.RUNNING;
+  static UNKNOWN: TripState = 'UNKNOWN';
+  static DRIVING: TripState = 'DRIVING';
+  static HALT: TripState = 'HALT';
+  static IDLE: TripState = 'IDLE';
+  static IGNORED: TripState = 'IGNORED';
 
-      case 'error':
-        return MoveSdk.ERROR;
-      default:
-        return null;
+  static sdkStateFromNative(sdkState: SdkState): SdkState {
+    if (
+      [
+        MoveSdk.UNINITIALIZED,
+        MoveSdk.READY,
+        MoveSdk.RUNNING,
+        MoveSdk.UNINITIALIZED,
+      ].includes(sdkState)
+    ) {
+      return sdkState;
     }
-  }
 
-  static tripStateFromNative(
-    nativeTripState: NativeTripState
-  ): TripState | null {
-    const state = nativeTripState?.toLowerCase() as TripState;
+    return MoveSdk.UNINITIALIZED;
+  }
 
+  static tripStateFromNative(nativeTripState: TripState): TripState {
     if (
       [
         MoveSdk.UNKNOWN,
@@ -146,50 +124,35 @@ export default class MoveSdk {
         MoveSdk.HALT,
         MoveSdk.IDLE,
         MoveSdk.IGNORED,
-      ].includes(state)
+      ].includes(nativeTripState)
     ) {
-      return state;
+      return nativeTripState;
     }
 
-    return null;
+    return MoveSdk.UNKNOWN;
   }
 
-  static authStateFromNative(
-    nativeAuthState: NativeAuthState
-  ): AuthState | null {
-    const state = nativeAuthState?.toLowerCase() as AuthState;
-
-    if ([MoveSdk.AUTH_VALID, MoveSdk.AUTH_EXPIRED].includes(state)) {
-      return state;
+  static authStateFromNative(nativeAuthState: AuthState): AuthState {
+    if ([MoveSdk.AUTH_VALID, MoveSdk.AUTH_EXPIRED].includes(nativeAuthState)) {
+      return nativeAuthState;
     }
 
-    return null;
-  }
-
-  static configurationErrorFromNative(
-    nativeInitError: NativeConfigurationError
-  ) {
-    const state = nativeInitError?.toLowerCase() as ConfigurationError;
-    return state;
+    return MoveSdk.AUTH_UNKNOWN;
   }
 
-  static initialize(
+  static async setup(
     config: MoveSdkConfig,
     auth: MoveSdkAuth,
     android: MoveSdkAndroidConfig
-  ) {
-    const {
-      timelineDetectionServices,
-      drivingServices,
-      walkingServices,
-      otherServices,
-    } = config;
+  ): Promise<void> {
+    const { timelineDetectionServices, drivingServices, walkingServices } =
+      config;
 
-    const { contractId, productId, accessToken, refreshToken } = auth;
+    const { userId, projectId, accessToken, refreshToken } = auth;
 
     let platformParams: Array<string | boolean> = [];
     if (Platform.OS === 'android') {
-      const { notifications, allowMockLocations } = android;
+      const { notifications } = android;
 
       const { tripNotification, recognitionNotification } = notifications;
 
@@ -210,27 +173,31 @@ export default class MoveSdk {
         tripNotification.channel.id,
         tripNotification.channel.name,
         tripNotification.channel.description,
-        allowMockLocations,
       ];
     }
 
-    NativeMoveSdk.initialize(
-      contractId,
+    return await NativeMoveSdk.setup(
+      userId,
       accessToken,
       refreshToken,
-      productId,
+      projectId,
       // Config
       timelineDetectionServices,
       drivingServices,
       walkingServices,
-      otherServices,
+
       // Platform config
       ...platformParams
-    ).catch((e) => {
-      throw new Error(
-        `Initialization failed, Exception occured with message ${e.message}`
-      );
-    });
+    );
+  }
+
+  static allowMockLocations(allowMockLocations: boolean) {
+    NativeMoveSdk.allowMockLocations(allowMockLocations);
+  }
+
+  /* Deprecated */
+  static init() {
+    NativeMoveSdk.init();
   }
 
   static resolveError() {
@@ -238,14 +205,18 @@ export default class MoveSdk {
   }
 
   static updateAuth(auth: MoveSdkAuth) {
-    const { contractId, productId, accessToken, refreshToken } = auth;
-    NativeMoveSdk.updateAuth(contractId, accessToken, refreshToken, productId);
+    const { userId, projectId, accessToken, refreshToken } = auth;
+    NativeMoveSdk.updateAuth(userId, accessToken, refreshToken, projectId);
   }
 
   static startAutomaticDetection() {
     NativeMoveSdk.startAutomaticDetection();
   }
 
+  static stopAutomaticDetection() {
+    NativeMoveSdk.stopAutomaticDetection();
+  }
+
   static forceTripRecognition() {
     NativeMoveSdk.forceTripRecognition();
   }
@@ -266,79 +237,61 @@ export default class MoveSdk {
     }
   }
 
-  static stopAutomaticDetection() {
-    NativeMoveSdk.stopAutomaticDetection();
+  static async synchronizeUserData(): Promise<boolean> {
+    return await NativeMoveSdk.synchronizeUserData();
   }
 
-  static synchronizeUserData(): Promise<boolean> {
-    return new Promise((resolve, _reject) => {
-      NativeMoveSdk.synchronizeUserData().then((value: boolean) =>
-        resolve(value)
-      );
-    });
+  static async getAuthState(): Promise<AuthState> {
+    const authState = await NativeMoveSdk.getAuthState();
+    return MoveSdk.authStateFromNative(authState);
   }
 
-  static shutdown() {
-    NativeMoveSdk.shutdown();
+  static async getState(): Promise<SdkState> {
+    const state = await NativeMoveSdk.getState();
+    return MoveSdk.sdkStateFromNative(state);
   }
 
-  static getAuthState(): Promise<AuthState | null> {
-    return new Promise((resolve, _reject) => {
-      NativeMoveSdk.getAuthState().then((nativeState: NativeAuthState) =>
-        resolve(MoveSdk.authStateFromNative(nativeState))
-      );
-    });
+  static async getTripState(): Promise<TripState> {
+    const tripState = await NativeMoveSdk.getTripState();
+    return MoveSdk.tripStateFromNative(tripState);
   }
 
-  static getState(): Promise<SdkState | null> {
-    return new Promise((resolve, _reject) => {
-      NativeMoveSdk.getState().then((nativeState: NativeSdkState) =>
-        resolve(MoveSdk.sdkStateFromNative(nativeState))
-      );
-    });
+  static async getErrors(): Promise<ErrorListType> {
+    return await NativeMoveSdk.getErrors();
   }
 
-  static getTripState(): Promise<TripState | null> {
-    return new Promise((resolve, _reject) => {
-      NativeMoveSdk.getTripState().then((nativeState: NativeTripState) =>
-        resolve(MoveSdk.tripStateFromNative(nativeState))
-      );
-    });
+  static async getWarnings(): Promise<ErrorListType> {
+    return await NativeMoveSdk.getWarnings();
+  }
+
+  static async initiateAssistanceCall(): Promise<boolean> {
+    return await NativeMoveSdk.initiateAssistanceCall();
+  }
+
+  static setAssistanceMetaData(data: string) {
+    NativeMoveSdk.setAssistanceMetaData(data);
   }
 
   static addTripStateListener(
-    tripStateChanged: (state: TripState | null) => void
+    tripStateChanged: (state: TripState) => void
   ): ListenerSubscription {
-    return eventEmitter.addListener('DolphinSdk-TripState', (event) =>
+    return eventEmitter.addListener('MOVE_SDK_TRIP_STATE', (event) =>
       tripStateChanged(MoveSdk.tripStateFromNative(event.state))
     );
   }
 
-  static addSDKStateListener(
-    sdkStateChanged: (event: { state: SdkState | null }) => void
+  static addSdkStateListener(
+    sdkStateChanged: (state: SdkState) => void
   ): ListenerSubscription {
-    return eventEmitter.addListener('DolphinSdk-State', (event) => {
-      const transformedEvent = {
-        ...event,
-        state: MoveSdk.sdkStateFromNative(event.state),
-      };
-
-      sdkStateChanged(transformedEvent);
+    return eventEmitter.addListener('MOVE_SDK_STATE', (event) => {
+      sdkStateChanged(MoveSdk.sdkStateFromNative(event.state));
     });
   }
 
-  static addInitErrorListener(
-    initErrorReceived: (error: ConfigurationError) => void
-  ): ListenerSubscription {
-    return eventEmitter.addListener('DolphinSdk-InitError', (event) =>
-      initErrorReceived(MoveSdk.configurationErrorFromNative(event.error))
-    );
-  }
-
   static addAuthStateListener(
     authStateChanged: (event: AuthStateEvent) => void
   ): ListenerSubscription {
-    return eventEmitter.addListener('DolphinSdk-AuthState', (event) => {
+    return eventEmitter.addListener('MOVE_SDK_AUTH_STATE', (event) => {
       const transformedEvent = {
         ...event,
         state: MoveSdk.authStateFromNative(event.state),
@@ -347,10 +300,26 @@ export default class MoveSdk {
     });
   }
 
+  static addErrorsListener(
+    errorsReceived: (event: ErrorListType) => void
+  ): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_ERRORS', (event) => {
+      errorsReceived(event.errors);
+    });
+  }
+
+  static addWarningsListener(
+    warningsReceived: (event: ErrorListType) => void
+  ): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_WARNINGS', (event) => {
+      warningsReceived(event.warnings);
+    });
+  }
+
   static addAppEventListener(
     appEventReceived: (event: string) => void
   ): ListenerSubscription {
-    return eventEmitter.addListener('DolphinSdk-AppEvent', (event) => {
+    return eventEmitter.addListener('MOVE_SDK_APP_EVENT', (event) => {
       appEventReceived(event);
     });
   }
@@ -369,14 +338,22 @@ export default class MoveSdk {
     NativeMoveSdk.ignoreCurrentTrip();
   }
 
+  static requestMotionPermission() {
+    if (Platform.OS === 'ios') {
+      NativeMoveSdk.requestMotionPermission();
+    } else {
+      console.warn('MoveSdk.requestMotionPermission() is iOS only.');
+    }
+  }
+
+  static shutdown() {
+    NativeMoveSdk.shutdown();
+  }
+
   // **** PERMISSIONS MODULE START *****
 
-  static canDrawOverlays(): Promise<boolean> {
-    return new Promise((resolve, _reject) => {
-      NativeMoveSdk.canDrawOverlays().then((result: boolean) =>
-        resolve(result)
-      );
-    });
+  static async canDrawOverlays(): Promise<boolean> {
+    return await NativeMoveSdk.isAppIgnoringBatteryOptimization();
   }
 
   static requestDrawOverlaysPermission() {
@@ -389,12 +366,8 @@ export default class MoveSdk {
     }
   }
 
-  static isAppIgnoringBatteryOptimization(): Promise<boolean> {
-    return new Promise((resolve, _reject) => {
-      NativeMoveSdk.isAppIgnoringBatteryOptimization().then((result: boolean) =>
-        resolve(result)
-      );
-    });
+  static async isAppIgnoringBatteryOptimization(): Promise<boolean> {
+    return await NativeMoveSdk.isAppIgnoringBatteryOptimization();
   }
 
   static requestAppIgnoringBatteryOptimization() {