react-native-move-sdk 0.1.0

package/src/index.ts

@@ -0,0 +1,407 @@
+import {
+  NativeModules,
+  NativeEventEmitter,
+  Platform,
+  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 TimelineDetectionService =
+  | 'DRIVING'
+  | 'BICYCLE'
+  | 'WALKING'
+  | 'PUBLIC_TRANSPORT';
+export type MoveSdkConfig = {
+  timelineDetectionServices: TimelineDetectionService[];
+  drivingServices: DrivingService[];
+  walkingServices: WalkingService[];
+  otherServices: OtherService[];
+};
+
+export type MoveSdkAuth = {
+  contractId: string;
+  accessToken: string;
+  refreshToken: string;
+  productId: number;
+};
+
+export type NotificationConfig = {
+  title: string;
+  text: string;
+  channel: { id: string; name: string; description: string };
+};
+
+export type MoveSdkAndroidConfig = {
+  notifications: {
+    recognitionNotification: NotificationConfig;
+    tripNotification: NotificationConfig;
+  };
+  allowMockLocations: boolean;
+};
+
+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 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;
+
+      case 'ready':
+        return MoveSdk.READY;
+
+      case 'running':
+        return MoveSdk.RUNNING;
+
+      case 'error':
+        return MoveSdk.ERROR;
+      default:
+        return null;
+    }
+  }
+
+  static tripStateFromNative(
+    nativeTripState: NativeTripState
+  ): TripState | null {
+    const state = nativeTripState?.toLowerCase() as TripState;
+
+    if (
+      [
+        MoveSdk.UNKNOWN,
+        MoveSdk.DRIVING,
+        MoveSdk.HALT,
+        MoveSdk.IDLE,
+        MoveSdk.IGNORED,
+      ].includes(state)
+    ) {
+      return state;
+    }
+
+    return null;
+  }
+
+  static authStateFromNative(
+    nativeAuthState: NativeAuthState
+  ): AuthState | null {
+    const state = nativeAuthState?.toLowerCase() as AuthState;
+
+    if ([MoveSdk.AUTH_VALID, MoveSdk.AUTH_EXPIRED].includes(state)) {
+      return state;
+    }
+
+    return null;
+  }
+
+  static configurationErrorFromNative(
+    nativeInitError: NativeConfigurationError
+  ) {
+    const state = nativeInitError?.toLowerCase() as ConfigurationError;
+    return state;
+  }
+
+  static initialize(
+    config: MoveSdkConfig,
+    auth: MoveSdkAuth,
+    android: MoveSdkAndroidConfig
+  ) {
+    const {
+      timelineDetectionServices,
+      drivingServices,
+      walkingServices,
+      otherServices,
+    } = config;
+
+    const { contractId, productId, accessToken, refreshToken } = auth;
+
+    let platformParams: Array<string | boolean> = [];
+    if (Platform.OS === 'android') {
+      const { notifications, allowMockLocations } = android;
+
+      const { tripNotification, recognitionNotification } = notifications;
+
+      if (!tripNotification || !recognitionNotification) {
+        throw new Error(
+          'MOVE SDK needs notification configuration for Android'
+        );
+      }
+
+      platformParams = [
+        recognitionNotification.title,
+        recognitionNotification.text,
+        recognitionNotification.channel.id,
+        recognitionNotification.channel.name,
+        recognitionNotification.channel.description,
+        tripNotification.title,
+        tripNotification.text,
+        tripNotification.channel.id,
+        tripNotification.channel.name,
+        tripNotification.channel.description,
+        allowMockLocations,
+      ];
+    }
+
+    NativeMoveSdk.initialize(
+      contractId,
+      accessToken,
+      refreshToken,
+      productId,
+      // Config
+      timelineDetectionServices,
+      drivingServices,
+      walkingServices,
+      otherServices,
+      // Platform config
+      ...platformParams
+    ).catch((e) => {
+      throw new Error(
+        `Initialization failed, Exception occured with message ${e.message}`
+      );
+    });
+  }
+
+  static resolveError() {
+    NativeMoveSdk.resolveError();
+  }
+
+  static updateAuth(auth: MoveSdkAuth) {
+    const { contractId, productId, accessToken, refreshToken } = auth;
+    NativeMoveSdk.updateAuth(contractId, accessToken, refreshToken, productId);
+  }
+
+  static startAutomaticDetection() {
+    NativeMoveSdk.startAutomaticDetection();
+  }
+
+  static forceTripRecognition() {
+    NativeMoveSdk.forceTripRecognition();
+  }
+
+  static keepInForeground(enabled: boolean) {
+    if (Platform.OS === 'android') {
+      NativeMoveSdk.keepInForeground(enabled);
+    } else {
+      console.warn('MoveSdk.keepInForeground() is Android OS only.');
+    }
+  }
+
+  static keepActive(enabled: boolean) {
+    if (Platform.OS === 'android') {
+      NativeMoveSdk.keepActive(enabled);
+    } else {
+      console.warn('MoveSdk.keepActive() is Android OS only.');
+    }
+  }
+
+  static stopAutomaticDetection() {
+    NativeMoveSdk.stopAutomaticDetection();
+  }
+
+  static synchronizeUserData() {
+    NativeMoveSdk.synchronizeUserData();
+  }
+
+  static shutdown() {
+    NativeMoveSdk.shutdown();
+  }
+
+  static getAuthState(): Promise<AuthState | null> {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.getAuthState().then((nativeState: NativeAuthState) =>
+        resolve(MoveSdk.authStateFromNative(nativeState))
+      );
+    });
+  }
+
+  static getState(): Promise<SdkState | null> {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.getState().then((nativeState: NativeSdkState) =>
+        resolve(MoveSdk.sdkStateFromNative(nativeState))
+      );
+    });
+  }
+
+  static getTripState(): Promise<TripState | null> {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.getTripState().then((nativeState: NativeTripState) =>
+        resolve(MoveSdk.tripStateFromNative(nativeState))
+      );
+    });
+  }
+
+  static addTripStateListener(
+    tripStateChanged: (state: TripState | null) => void
+  ): ListenerSubscription {
+    return eventEmitter.addListener('DolphinSdk-TripState', (event) =>
+      tripStateChanged(MoveSdk.tripStateFromNative(event.state))
+    );
+  }
+
+  static addSDKStateListener(
+    sdkStateChanged: (event: { state: SdkState | null }) => void
+  ): ListenerSubscription {
+    return eventEmitter.addListener('DolphinSdk-State', (event) => {
+      const transformedEvent = {
+        ...event,
+        state: MoveSdk.sdkStateFromNative(event.state),
+      };
+
+      sdkStateChanged(transformedEvent);
+    });
+  }
+
+  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) => {
+      const transformedEvent = {
+        ...event,
+        state: MoveSdk.authStateFromNative(event.state),
+      };
+      authStateChanged(transformedEvent);
+    });
+  }
+
+  static addAppEventListener(
+    appEventReceived: (event: string) => void
+  ): ListenerSubscription {
+    return eventEmitter.addListener('DolphinSdk-AppEvent', (event) => {
+      appEventReceived(event);
+    });
+  }
+
+  static version(): string {
+    return Platform.OS === 'android'
+      ? NativeMoveSdk.getConstants().version
+      : 'Unknown';
+  }
+
+  static finishCurrentTrip() {
+    NativeMoveSdk.finishCurrentTrip();
+  }
+
+  static ignoreCurrentTrip() {
+    NativeMoveSdk.ignoreCurrentTrip();
+  }
+
+  // **** PERMISSIONS MODULE START *****
+
+  static canDrawOverlays(): Promise<boolean> {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.canDrawOverlays().then((result: boolean) =>
+        resolve(result)
+      );
+    });
+  }
+
+  static requestDrawOverlaysPermission() {
+    if (Platform.OS === 'android') {
+      NativeMoveSdk.requestDrawOverlaysPermission();
+    } else {
+      console.warn(
+        'MoveSdk.requestAppIgnoringBatteryOptimization() is Android OS only.'
+      );
+    }
+  }
+
+  static isAppIgnoringBatteryOptimization(): Promise<boolean> {
+    return new Promise((resolve, _reject) => {
+      NativeMoveSdk.isAppIgnoringBatteryOptimization().then((result: boolean) =>
+        resolve(result)
+      );
+    });
+  }
+
+  static requestAppIgnoringBatteryOptimization() {
+    if (Platform.OS === 'android') {
+      NativeMoveSdk.requestAppIgnoringBatteryOptimization();
+    } else {
+      console.warn(
+        'MoveSdk.requestAppIgnoringBatteryOptimization() is Android OS only.'
+      );
+    }
+  }
+
+  // **** PERMISSIONS MODULE END *****
+}