react-native-move-sdk 2.6.9 → 2.7.1-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-move-sdk",
-  "version": "2.6.9",
+  "version": "2.7.1-alpha",
   "description": "React Native library for MOVE SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -46,20 +46,20 @@
     "@commitlint/config-conventional": "^11.0.0",
     "@react-native-community/eslint-config": "^2.0.0",
     "@release-it/conventional-changelog": "^2.0.0",
-    "@types/react": "^16.9.19",
-    "@types/react-native": "0.62.13",
+    "@types/react": "^18.2.48",
+    "@types/react-native": "^0.73.0",
     "commitlint": "^11.0.0",
-    "eslint": "^7.2.0",
+    "eslint": "^8.57.0",
     "eslint-config-prettier": "^7.0.0",
     "eslint-plugin-prettier": "^3.1.3",
     "flow-remove-types": "^2.177.0",
     "pod-install": "^0.1.0",
     "prettier": "^2.0.5",
-    "react": "16.13.1",
-    "react-native": "0.63.3",
+    "react": "^18.2.0",
+    "react-native": "^0.73.2",
     "react-native-builder-bob": "^0.17.1",
     "release-it": "^14.2.2",
-    "typescript": "^4.1.3"
+    "typescript": "^5.3.3"
   },
   "peerDependencies": {
     "react": "*",
@@ -115,7 +115,8 @@
     "singleQuote": true,
     "tabWidth": 2,
     "trailingComma": "es5",
-    "useTabs": false
+    "useTabs": false,
+    "printWidth": 200
   },
   "react-native-builder-bob": {
     "source": "src",
@@ -131,5 +132,7 @@
       ]
     ]
   },
-  "dependencies": {}
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.21.0"
+  }
 }

package/react-native-move-sdk.podspec

@@ -18,5 +18,5 @@ Pod::Spec.new do |s|
   s.source_files  = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency 'React'
-  s.dependency 'DolphinMoveSDK', '2.6.9.276'
+  s.dependency 'MoveSDK', '2.7.0.280'
 end

package/src/MoveSdk.ts

@@ -0,0 +1,450 @@
+import { NativeModules, NativeEventEmitter, Platform, EmitterSubscription } from 'react-native';
+
+export type SdkState = 'UNINITIALIZED' | 'READY' | 'RUNNING';
+export type TripState = 'UNKNOWN' | 'DRIVING' | 'HALT' | 'IDLE' | 'IGNORED';
+export type AuthState = 'UNKNOWN' | 'VALID' | 'EXPIRED' | 'INVALID';
+export type DrivingService = 'DISTRACTION_FREE_DRIVING' | 'DRIVING_BEHAVIOUR' | 'DEVICE_DISCOVERY';
+export type WalkingService = 'WALKING_LOCATION';
+export type OtherService = 'POINTS_OF_INTEREST';
+export type TimelineDetectionService = 'DRIVING' | 'CYCLING' | 'WALKING' | 'PLACES' | 'PUBLIC_TRANSPORT' | 'AUTOMATIC_IMPACT_DETECTION' | 'ASSISTANCE_CALL' | 'POINTS_OF_INTEREST';
+
+export type ErrorReasons =
+  | 'BACKGROUND_LOCATION_PERMISSION_MISSING'
+  | 'LOCATION_PERMISSION_MISSING'
+  | 'MOTION_PERMISSION_MISSING'
+  | 'ACTIVITY_PERMISSION_MISSING'
+  | 'BATTERY_PERMISSION_MISSING'
+  | 'UNAUTHORIZED'
+  | 'INTERNET_PERMISSION_MISSING'
+  | 'PHONE_PERMISSION_MISSING'
+  | 'OVERLAY_PERMISSION_MISSING'
+  | 'NOTIFICATION_MISSING'
+  | 'ACCELEROMETER_MISSING'
+  | 'GOOGLE_PLAY_LOCATION_ACCURACY_MISSING'
+  | 'PRECISE_LOCATION_PERMISSION_MISSING';
+
+export type WarningReasons =
+  | 'BACKGROUND_LOCATION_PERMISSION_MISSING'
+  | 'MOTION_PERMISSION_MISSING'
+  | 'ACTIVITY_PERMISSION_MISSING'
+  | 'BATTERY_OPTIMIZATION'
+  | 'BLUETOOTH_TURNED_OFF'
+  | 'BLUETOOTH_SCAN_PERMISSION_MISSING'
+  | 'BLUETOOTH_CONNECT_PERMISSION_MISSING'
+  | 'GOOGLE_PLAY_LOCATION_ACCURACY_MISSING'
+  | 'NOTIFICATION_PERMISSION_MISSING'
+  | 'FINE_LOCATION_PERMISSION_MISSING'
+  | 'BLUETOOTH_PERMISSION_MISSING'
+  | 'GPS_OFF'
+  | 'OFFLINE';
+
+export type IssueListService = TimelineDetectionService | DrivingService | WalkingService;
+
+export type IssueListItem<ReasonsType> = {
+  reasons: Array<ReasonsType>;
+  service?: IssueListService;
+};
+
+export type ErrorListType = Array<IssueListItem<ErrorReasons>>;
+
+export type WarningListType = Array<IssueListItem<WarningReasons>>;
+
+export type ShutdownReturnType = 'NETWORK_ERROR' | 'SUCCESS' | 'UNINITIALIZED';
+
+export type MoveSdkConfig = {
+  timelineDetectionServices: Array<TimelineDetectionService>;
+  drivingServices: Array<DrivingService>;
+  walkingServices: Array<WalkingService>;
+};
+
+export type MoveSdkDeviceDiscovery = {
+  startDelay?: number;
+  duration?: number;
+  interval?: number;
+  stopScanOnFirstDiscovered?: boolean;
+};
+
+export type MoveSdkOptions = {
+  motionPermissionMandatory?: boolean;
+  backgroundLocationPermissionMandatory?: boolean;
+  useBackendConfig?: boolean;
+  deviceDiscovery?: MoveSdkDeviceDiscovery;
+};
+
+export type MoveSdkAuth = {
+  userId: string;
+  accessToken: string;
+  refreshToken: string;
+  projectId: number;
+};
+
+export type NotificationConfig = {
+  title: string;
+  text: string;
+  channel: { id: string; name: string; description: string };
+};
+
+export type MoveSdkAndroidConfig = {
+  notifications: {
+    recognitionNotification: NotificationConfig;
+    tripNotification: NotificationConfig;
+  };
+};
+
+export type ListenerSubscription = EmitterSubscription;
+
+export type AuthStateEvent = {
+  state: AuthState;
+  accessToken?: string;
+  refreshToken?: string;
+};
+
+export type MoveSdkDeviceFilter = 'beacon' | 'paired';
+
+export type MoveSdkDevice = {
+  name: string;
+  data: string;
+  id: string;
+};
+
+export type MoveScanResult = {
+  isDiscovered: boolean;
+  device: MoveSdkDevice;
+  name: string;
+};
+
+const { MoveSdk: NativeMoveSdk } = NativeModules;
+const eventEmitter = new NativeEventEmitter(NativeMoveSdk);
+
+export default class MoveSdk {
+  static READY: SdkState = 'READY';
+  static RUNNING: SdkState = 'RUNNING';
+  static UNINITIALIZED: SdkState = 'UNINITIALIZED';
+
+  static AUTH_EXPIRED: AuthState = 'EXPIRED';
+  static AUTH_VALID: AuthState = 'VALID';
+  static AUTH_UNKNOWN: AuthState = 'UNKNOWN';
+  static AUTH_INVALID: AuthState = 'INVALID';
+
+  static UNKNOWN: TripState = 'UNKNOWN';
+  static DRIVING: TripState = 'DRIVING';
+  static HALT: TripState = 'HALT';
+  static IDLE: TripState = 'IDLE';
+  static IGNORED: TripState = 'IGNORED';
+
+  static sdkStateFromNative(sdkState: SdkState): SdkState {
+    if ([MoveSdk.UNINITIALIZED, MoveSdk.READY, MoveSdk.RUNNING, MoveSdk.UNINITIALIZED].includes(sdkState)) {
+      return sdkState;
+    }
+
+    return MoveSdk.UNINITIALIZED;
+  }
+
+  static tripStateFromNative(nativeTripState: TripState): TripState {
+    if ([MoveSdk.UNKNOWN, MoveSdk.DRIVING, MoveSdk.HALT, MoveSdk.IDLE, MoveSdk.IGNORED].includes(nativeTripState)) {
+      return nativeTripState;
+    }
+
+    return MoveSdk.UNKNOWN;
+  }
+
+  static authStateFromNative(nativeAuthState: AuthState): AuthState {
+    if ([MoveSdk.AUTH_VALID, MoveSdk.AUTH_EXPIRED, MoveSdk.AUTH_INVALID].includes(nativeAuthState)) {
+      return nativeAuthState;
+    }
+
+    return MoveSdk.AUTH_UNKNOWN;
+  }
+
+  static async setup(config: MoveSdkConfig, auth: MoveSdkAuth, android: MoveSdkAndroidConfig, options?: MoveSdkOptions): Promise<void> {
+    const { timelineDetectionServices, drivingServices, walkingServices } = config;
+
+    const { userId, projectId, accessToken, refreshToken } = auth;
+
+    let platformParams: Array<string | boolean> = [];
+    if (Platform.OS === 'android') {
+      const { notifications } = 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,
+      ];
+    }
+
+    return await NativeMoveSdk.setup(
+      userId,
+      accessToken,
+      refreshToken,
+      projectId,
+      // Config
+      timelineDetectionServices,
+      drivingServices,
+      walkingServices,
+      options,
+      // Platform config
+      ...platformParams
+    );
+  }
+
+  static allowMockLocations(allowMockLocations: boolean) {
+    NativeMoveSdk.allowMockLocations(allowMockLocations);
+  }
+
+  /* Deprecated */
+  static init() {
+    NativeMoveSdk.init();
+  }
+
+  static resolveError() {
+    NativeMoveSdk.resolveError();
+  }
+
+  static async updateAuth(auth: MoveSdkAuth): Promise<void> {
+    const { userId, projectId, accessToken, refreshToken } = auth;
+    return await NativeMoveSdk.updateAuth(userId, accessToken, refreshToken, projectId);
+  }
+
+  static startAutomaticDetection() {
+    NativeMoveSdk.startAutomaticDetection();
+  }
+
+  static stopAutomaticDetection() {
+    NativeMoveSdk.stopAutomaticDetection();
+  }
+
+  static forceTripRecognition(duration: number = 60000) {
+    NativeMoveSdk.forceTripRecognition(duration);
+  }
+
+  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 async synchronizeUserData(): Promise<boolean> {
+    return await NativeMoveSdk.synchronizeUserData();
+  }
+
+  static async getAuthState(): Promise<AuthState> {
+    const authState = await NativeMoveSdk.getAuthState();
+    return MoveSdk.authStateFromNative(authState);
+  }
+
+  static async getState(): Promise<SdkState> {
+    const state = await NativeMoveSdk.getState();
+    return MoveSdk.sdkStateFromNative(state);
+  }
+
+  static async getTripState(): Promise<TripState> {
+    const tripState = await NativeMoveSdk.getTripState();
+    return MoveSdk.tripStateFromNative(tripState);
+  }
+
+  static async getErrors(): Promise<ErrorListType> {
+    return await NativeMoveSdk.getErrors();
+  }
+
+  static async getWarnings(): Promise<WarningListType> {
+    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) => void): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_TRIP_STATE', (event) => tripStateChanged(MoveSdk.tripStateFromNative(event.state)));
+  }
+
+  static addTripStartListener(tripStartTriggered: (start: Date) => void): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_TRIP_START', (start) => tripStartTriggered(new Date(Number(start))));
+  }
+
+  static addSdkStateListener(sdkStateChanged: (state: SdkState) => void): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_STATE', (event) => {
+      sdkStateChanged(MoveSdk.sdkStateFromNative(event.state));
+    });
+  }
+
+  static addAuthStateListener(authStateChanged: (event: AuthStateEvent) => void): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_AUTH_STATE', (event) => {
+      const transformedEvent = {
+        ...event,
+        state: MoveSdk.authStateFromNative(event.state),
+      };
+      authStateChanged(transformedEvent);
+    });
+  }
+
+  static addErrorsListener(errorsReceived: (errors: ErrorListType) => void): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_ERRORS', (event) => {
+      errorsReceived(event.errors);
+    });
+  }
+
+  static addWarningsListener(warningsReceived: (warnings: WarningListType) => void): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_WARNINGS', (event) => {
+      warningsReceived(event.warnings);
+    });
+  }
+
+  static addAppEventListener(appEventReceived: (event: string) => void): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_APP_EVENT', (event) => {
+      appEventReceived(event);
+    });
+  }
+
+  static addRemoteConfigChangeListener(configChangeReceived: (config: Array<IssueListService>) => void): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_CONFIG_UPDATE', (config) => {
+      configChangeReceived(config);
+    });
+  }
+
+  static version(): string {
+    return Platform.OS === 'android' ? NativeMoveSdk.getConstants().version : 'Unknown';
+  }
+
+  static finishCurrentTrip() {
+    NativeMoveSdk.finishCurrentTrip();
+  }
+
+  static ignoreCurrentTrip() {
+    NativeMoveSdk.ignoreCurrentTrip();
+  }
+
+  static requestMotionPermission() {
+    if (Platform.OS === 'ios') {
+      NativeMoveSdk.requestMotionPermission();
+    } else {
+      console.warn('MoveSdk.requestMotionPermission() is iOS only.');
+    }
+  }
+
+  static async shutdown(force: boolean = true): Promise<ShutdownReturnType> {
+    return await NativeMoveSdk.shutdown(force);
+  }
+
+  static async getDeviceQualifier(): Promise<string | null> {
+    return NativeMoveSdk.getDeviceQualifier();
+  }
+
+  static async geocode(latitude: number, longitude: number): Promise<string> {
+    return await NativeMoveSdk.geocode(latitude, longitude);
+  }
+
+  static async isAuthValid(): Promise<boolean> {
+    return await NativeMoveSdk.isAuthValid();
+  }
+
+  // **** PERMISSIONS MODULE START *****
+
+  static async canDrawOverlays(): Promise<boolean> {
+    return await NativeMoveSdk.canDrawOverlays();
+  }
+
+  static requestDrawOverlaysPermission() {
+    if (Platform.OS === 'android') {
+      NativeMoveSdk.requestDrawOverlaysPermission();
+    } else {
+      console.warn('MoveSdk.requestDrawOverlaysPermission() is Android OS only.');
+    }
+  }
+
+  static async isAppIgnoringBatteryOptimization(): Promise<boolean> {
+    return await NativeMoveSdk.isAppIgnoringBatteryOptimization();
+  }
+
+  static requestAppIgnoringBatteryOptimization() {
+    if (Platform.OS === 'android') {
+      NativeMoveSdk.requestAppIgnoringBatteryOptimization();
+    } else {
+      console.warn('MoveSdk.requestAppIgnoringBatteryOptimization() is Android OS only.');
+    }
+  }
+
+  // **** PERMISSIONS MODULE END *****
+
+  static startScanningDevices(sdkDevicesDetected: (state: Array<MoveSdkDevice>) => void, filter: MoveSdkDeviceFilter[] = ['paired'], uuid?: string, manufacturerId?: number): ListenerSubscription {
+    const subscription = eventEmitter.addListener('MOVE_SDK_DEVICES', (devices) => {
+      sdkDevicesDetected(devices);
+    });
+    const subscriptionRemove = subscription.remove;
+    subscription.remove = () => {
+      NativeMoveSdk.stopScanningDevices();
+      subscriptionRemove();
+    };
+
+    NativeMoveSdk.startScanningDevices(filter, uuid, manufacturerId ?? -1);
+    return subscription;
+  }
+
+  static async getRegisteredDevices(): Promise<Array<MoveSdkDevice>> {
+    return await NativeMoveSdk.getRegisteredDevices();
+  }
+
+  static async registerDevices(devices: Array<MoveSdkDevice>): Promise<boolean> {
+    return await NativeMoveSdk.registerDevices(devices);
+  }
+
+  static async unregisterDevices(devices: Array<MoveSdkDevice>): Promise<boolean> {
+    return await NativeMoveSdk.unregisterDevices(devices);
+  }
+
+  static requestBluetoothAlwaysUsagePermission(): void {
+    NativeMoveSdk.requestBluetoothAlwaysUsagePermission();
+  }
+
+  static addDeviceDiscoveryListener(onScanResult: (state: Array<MoveScanResult>) => void): ListenerSubscription {
+    return eventEmitter.addListener('MOVE_SDK_SCAN_RESULT', (results) => {
+      onScanResult(results);
+    });
+  }
+
+  static setTimer(callback: () => void, delay: number = 60000): string {
+    if (Platform.OS === 'android') {
+      const key = Date.now().toString();
+      NativeMoveSdk.setTimer(delay, key, callback);
+      return key;
+    } else {
+      console.warn('MoveSdk.setTimer() is Android OS only.');
+      return '';
+    }
+  }
+
+  static cancelTimer(key: string) {
+    if (Platform.OS === 'android') {
+      NativeMoveSdk.cancelTimer(key);
+    } else {
+      console.warn('MoveSdk.cancelTimer() is Android OS only.');
+    }
+  }
+}

package/src/components/LazyMoveSdk.tsx

@@ -0,0 +1,81 @@
+import React, { Suspense, useEffect, useRef, useState } from 'react';
+import { AppState, AppStateStatus, Platform, View } from 'react-native';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+import MoveSdk, { TripState } from '../MoveSdk';
+
+type LazyMoveSdkProps = {
+  children: React.ReactNode;
+  delayToRemoveUiInBackgroundMs?: number;
+};
+
+export default function LazyMoveSdk({ children, delayToRemoveUiInBackgroundMs = 30000 }: LazyMoveSdkProps) {
+  const prevState = useRef('terminated');
+  const [currentMode, setCurrentMode] = useState(AppState.currentState);
+  const [tripState, setTripState] = useState<TripState>();
+  const [removeUi, setRemoveUi] = useState(false);
+
+  useEffect(() => {
+    let timer: ReturnType<typeof setTimeout> | null | number | string = null;
+    const appStateSubscription = AppState.addEventListener('change', (state: AppStateStatus) => {
+      setCurrentMode(state);
+      prevState.current = state;
+    });
+    const tripStateSubscription = MoveSdk.addTripStateListener(setTripState);
+
+    const checkStatesAndSetTimerToRemoveUi = async () => {
+      const removeUiInBackgroundTimeoutId = await AsyncStorage.getItem('@removeUiInBackgroundTimeoutId');
+      if (currentMode === 'background' && tripState === MoveSdk.DRIVING && !removeUiInBackgroundTimeoutId && timer === null) {
+        if (Platform.OS === 'android') {
+          timer = MoveSdk.setTimer(() => setRemoveUi(true), delayToRemoveUiInBackgroundMs);
+        } else {
+          timer = setTimeout(() => setRemoveUi(true), delayToRemoveUiInBackgroundMs);
+        }
+        if (timer) {
+          AsyncStorage.setItem('@removeUiInBackgroundTimeoutId', timer.toString());
+        }
+      }
+      if (currentMode === 'active' && removeUiInBackgroundTimeoutId) {
+        if (Platform.OS === 'android') {
+          MoveSdk.cancelTimer(removeUiInBackgroundTimeoutId);
+        } else {
+          clearTimeout(+removeUiInBackgroundTimeoutId);
+        }
+        timer = null;
+        await AsyncStorage.removeItem('@removeUiInBackgroundTimeoutId');
+      }
+    };
+    checkStatesAndSetTimerToRemoveUi();
+
+    return () => {
+      appStateSubscription.remove();
+      tripStateSubscription.remove();
+      if (timer) {
+        if (Platform.OS === 'android') {
+          MoveSdk.cancelTimer(timer as string);
+        } else {
+          clearTimeout(timer as number);
+        }
+        timer = null;
+      }
+    };
+  }, [currentMode, tripState, delayToRemoveUiInBackgroundMs]);
+
+  useEffect(() => {
+    if (currentMode === 'active' && removeUi) {
+      setRemoveUi(false);
+    }
+  }, [currentMode, removeUi]);
+
+  const startedInBackground =
+    (prevState.current === 'terminated' && currentMode === 'background') ||
+    (prevState.current === 'terminated' && currentMode === 'unknown') ||
+    (prevState.current === 'background' && currentMode === 'background');
+
+  // DON'T RENDER UI IF APP STARTED IN BACKGROUND OR APP IS IN BACKGROUND AND TRIP STARTS
+  if (startedInBackground || removeUi) {
+    return <View />;
+  }
+
+  return <Suspense fallback={<View />}>{children}</Suspense>;
+}