@os1-platform/dispatch-mobile 2.1.30 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@os1-platform/dispatch-mobile",
-  "version": "2.1.30",
+  "version": "3.0.1",
   "description": "Dispatch SDK React Native Package",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -51,7 +51,6 @@
   "author": "Amit Sanvedi <amit.sanvedi@delhivery.com> (https://github.com/FoxtrotPlatform/platform-coreos-dispatch-sdk)",
   "homepage": "https://github.com/FoxtrotPlatform/platform-coreos-dispatch-sdk/#readme",
   "devDependencies": {
-    "@delhivery/platform-coreos-mts-sdk": "2.0.10",
     "@apollo/client": "^3.5.6",
     "@babel/core": "^7.12.9",
     "@babel/preset-env": "^7.15.8",
@@ -129,7 +128,6 @@
     "typescript": "^4.4.4"
   },
   "peerDependencies": {
-    "@delhivery/platform-coreos-mts-sdk": "2.0.10",
     "@apollo/client": "^3.5.6",
     "@expo-google-fonts/ibm-plex-sans": "*",
     "@react-native-async-storage/async-storage": "^1.15.14",
@@ -258,7 +256,7 @@
       ]
     ]
   },
-  "dependencies": {    
+  "dependencies": {
     "@os1-platform/platform-coreos-execution-engine-sdk": "1.0.17",
     "@rjsf/core": "^2.0.0",
     "apollo-link-timeout": "^4.0.0",
@@ -277,4 +275,4 @@
     "rjsf-native": "^1.0.14",
     "toggle-switch-react-native": "^3.3.0"
   }
-}
+}

package/src/components/executiontasks/doodle/SignatureET.tsx

@@ -143,10 +143,12 @@ lineHeight: 24 }}>{props.title}</Text>
           )) ?? 'NULL';
         const dateTime = await callbackHandler.getDateTime();
         console.log('saveAndSubmit:dateTime: ', dateTime);
-
-        let lat = LocationManager.getInstance().getLastLocation().latitude;
-        let lng = LocationManager.getInstance().getLastLocation().longitude;
-        let accuracy = LocationManager.getInstance().getLastLocation().accuracy;
+        let lastLocation = await LocationManager.getInstance().getLastLocation();
+        console.log("signatureET:lastLocation:",JSON.stringify(lastLocation));
+  
+        let lat = lastLocation.latitude;
+        let lng = lastLocation.longitude;
+        let accuracy = lastLocation.accuracy;
 
         let insertID = await insertDocumentInDB(
           fileName,

package/src/components/executiontasks/imageCapture/ImageCapture.tsx

@@ -304,6 +304,9 @@ const ImageCapture = (props: any) => {
       imgArray = imagesDummy;
       const dateTime = await callbackHandler.getDateTime();
       console.log('captureImage:dateTime: ', dateTime);
+       let lastLocation = await LocationManager.getInstance().getLastLocation();
+       console.log("captureImage:lastLocation:",JSON.stringify(lastLocation));
+
       imgArray[index] = {
         id: CaptureUtils.getImagesFileName(),
         // @ts-ignore
@@ -311,9 +314,9 @@ const ImageCapture = (props: any) => {
         url: '',
         timestamp: Date.now(),
         dateTime: dateTime,
-        lat: LocationManager.getInstance().getLastLocation().latitude,
-        lng: LocationManager.getInstance().getLastLocation().longitude,
-        accuracy: LocationManager.getInstance().getLastLocation().accuracy,
+        lat: lastLocation.latitude,
+        lng: lastLocation.longitude,
+        accuracy: lastLocation.accuracy,
       };
       setImagesDummy([...imgArray])
       console.log("images211:", JSON.stringify(imgArray));

package/src/index.tsx

@@ -1,11 +1,6 @@
 import Storage from './utils/storage';
 import type * as ETaskSchema from './components/executiontasks/ExecutionTasksIndex';
 import * as ExecutionTask from './components/executiontasks/ExecutionTasksIndex';
-import type {
-  MTSInitRequest,
-  MTSStartRequest,
-} from '@delhivery/platform-coreos-mts-sdk';
-import * as MtsSdk from '@delhivery/platform-coreos-mts-sdk';
 import NativeSyncManager from './manager/syncmanager/NativeSyncManager';
 import type { DocumentRow, EventRow } from './manager/syncmanager/DBConfig';
 import { SyncMethod, DispatchSyncType } from './manager/syncmanager/DBConfig';
@@ -81,8 +76,6 @@ export type { ETaskSchema };
 export { ExecutionTask, CancelOrderDialog };
 export { DispatchSDKManager };
 //
-export type { MTSStartRequest, MTSInitRequest };
-export { MtsSdk };
 export { Helper };
 //sentry function export
 export { SentryAnalyticsSingleton, fireEventWithScreenName, SeverityLevelValue, ScreenNameSdkConstants, SentryEventNameSdkConstants, DispatchAndUserData, SentryEvent };

package/src/manager/location/LocationManager.ts

@@ -1,20 +1,37 @@
 import * as Location from 'expo-location';
 import { Accuracy, LocationObject } from 'expo-location';
 import Logger, { LOG_TYPE } from '../../utils/Logger';
+import { EmitterSubscription, Platform } from 'react-native';
+import PermissionModule from '../../native/PermissionModule';
+import LocationModule, { LocationType } from '../../native/LocationModule';
 
 export default class LocationManager {
   private static instance: LocationManager;
-  private lastLocation: LocationObject | null = null;
+  private lastLocationAndroid: LocationType | null = null;
+  private lastLocationiOS: LocationType | null = null;
   private stopUpdate: { remove(): void } | undefined;
+  private subscription: EmitterSubscription | null = null;
 
   public async checkForLocationPermissions(): Promise<boolean> {
-    let permissionResponse = await Location.getForegroundPermissionsAsync();
-    if (permissionResponse.status === 'granted') {
-      this.startUpdates();
-      return true;
-    } else {
-      let { status } = await Location.requestForegroundPermissionsAsync();
-      if (status === 'granted') {
+    console.log("checkForLocationPermissions");
+    if (Platform.OS === 'ios') {
+      // old code checking for permissions using expo-location
+      // let permissionResponse = await Location.getForegroundPermissionsAsync();
+      // if (permissionResponse.status === 'granted') {
+      //   this.startUpdates();
+      //   return true;
+      // } else {
+      //   let { status } = await Location.requestForegroundPermissionsAsync();
+      //   if (status === 'granted') {
+      //     this.startUpdates();
+      //     return true;
+      //   } else {
+      //     this.stopLocationUpdates();
+      //     return false;
+      //   }
+      // }
+      let foregroundPermission = await PermissionModule.requestForegroundPermissions();
+      if (foregroundPermission) {
         this.startUpdates();
         return true;
       } else {
@@ -22,6 +39,17 @@ export default class LocationManager {
         return false;
       }
     }
+    if (Platform.OS === 'android') {
+      let foregroundPermission = await PermissionModule.requestForegroundPermissions();
+      if (foregroundPermission) {
+        this.startUpdates();
+        return true;
+      } else {
+        this.stopLocationUpdates();
+        return false;
+      }
+    }
+    return true;
   }
 
   public static getInstance(): LocationManager {
@@ -30,50 +58,74 @@ export default class LocationManager {
     }
     return LocationManager.instance;
   }
+
   public startUpdates() {
-    Location.watchPositionAsync(
-      {
-        accuracy: Accuracy.Highest,
-        timeInterval: 10000, // in millis
-        distanceInterval: 10, //in metres
-      },
-      (location) => {
+    if (Platform.OS === 'android') {
+      LocationModule.startLocationUpdates();
+      this.subscription = LocationModule.addLocationListener((location) => {
+        console.log('Location updated:', location);
         if (location != null) {
-          this.lastLocation = location;
+          this.lastLocationAndroid = location
         }
-      }
-    )
-      .then((r) => {
-        this.stopUpdate = r;
-      })
-      .catch((error) => {
-        Logger.getInstance().logEvent(
-          'LOCATION_MANAGER',
-          error.message,
-          LOG_TYPE.SDK_WARNING
-        );
       });
+    }
+
+    if (Platform.OS === 'ios') {
+      console.log("startUpdates");
+      LocationModule.startLocationUpdates();
+      // this.subscription = LocationModule.addLocationListener((location) => {
+      //   console.log('Location updated:', location);
+      //   if (location != null) {
+      //     this.lastLocationiOS = location
+      //   }
+      // });
+    }
   }
-  public getLastLocation(): DLocation {
-    if (this.lastLocation != null && this.lastLocation.coords != null) {
-      let accuracy = '';
-      if (this.lastLocation.coords.accuracy !== null) {
-        let accuracyVal = Math.round(this.lastLocation.coords.accuracy);
-        accuracy = accuracyVal.toString();
-      }
+
+  public async getLastLocation(): Promise<DLocation> {
+    if (Platform.OS === 'android' && this.lastLocationAndroid != null) {
+      console.log("lastLocationAndroid:", this.lastLocationAndroid);
       return {
-        latitude: this.lastLocation.coords.latitude.toString(),
-        longitude: this.lastLocation.coords.longitude.toString(),
-        accuracy: accuracy,
+        latitude: this.lastLocationAndroid.latitude.toString(),
+        longitude: this.lastLocationAndroid.longitude.toString(),
+        accuracy: this.lastLocationAndroid.accuracy.toString(),
       };
-    } else {
-      return { latitude: 'null', longitude: 'null', accuracy: 'null' };
     }
+    if (Platform.OS === 'ios') {
+      this.lastLocationiOS = await LocationModule.getLastLocation();
+      console.log("lastLocationiOS:", this.lastLocationiOS);
+      if(this.lastLocationiOS){
+        return {
+          latitude: this.lastLocationiOS.latitude.toString(),
+          longitude: this.lastLocationiOS.longitude.toString(),
+          accuracy: this.lastLocationiOS.accuracy.toString(),
+        };
+      }
+    }
+    return {
+      latitude: 'null',
+      longitude: 'null',
+      accuracy: 'null',
+    };
   }
+
+
   public stopLocationUpdates() {
     try {
-      if (this.stopUpdate) this.stopUpdate.remove();
-    } catch (error: any) {}
+      // code for android
+      if (Platform.OS === 'android') {
+        if (this.subscription) {
+          LocationModule.removeLocationListener(this.subscription);
+        }
+      }
+
+      // code for ios
+      if (Platform.OS === 'ios') {
+        if (this.subscription) {
+          LocationModule.removeLocationListener(this.subscription);
+        }
+      }
+    } catch (error: any) { }
   }
 }
 

package/src/native/LocationModule.ts

@@ -0,0 +1,52 @@
+import { NativeModules, NativeEventEmitter, EmitterSubscription } from 'react-native';
+
+const { LocationModule } = NativeModules;
+const locationEventEmitter = new NativeEventEmitter(LocationModule);
+
+const startLocationUpdates = async (): Promise<void> => {
+    try {
+        await LocationModule.startLocationUpdates();
+    } catch (error) {
+        console.error(error);
+    }
+};
+
+const stopLocationUpdates = async (): Promise<void> => {
+    try {
+        await LocationModule.stopLocationUpdates();
+    } catch (error) {
+        console.error(error);
+    }
+};
+
+const getLastLocation = async (): Promise<any> => {
+    try {
+        return LocationModule.getLastLocation();
+    } catch (error) {
+        console.error(error);
+        return null
+    }
+}
+
+
+export interface LocationType {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+}
+
+const addLocationListener = (callback: (location: LocationType) => void): EmitterSubscription => {
+    return locationEventEmitter.addListener('locationUpdated', callback);
+};
+
+const removeLocationListener = (subscription: EmitterSubscription): void => {
+    subscription.remove();
+};
+
+export default {
+    startLocationUpdates,
+    stopLocationUpdates,
+    addLocationListener,
+    removeLocationListener,
+    getLastLocation,
+};

package/src/native/PermissionModule.ts

@@ -0,0 +1,21 @@
+import { NativeModules } from 'react-native';
+
+const { PermissionsModule } = NativeModules;
+
+interface PermissionsModuleType {
+    requestForegroundPermissions: () => Promise<boolean>;
+    requestBackgroundPermissions: () => Promise<boolean>;
+}
+
+const requestForegroundPermissions = async (): Promise<boolean> => {
+    return PermissionsModule.requestForegroundPermissions();
+};
+
+const requestBackgroundPermissions = async (): Promise<boolean> => {
+    return PermissionsModule.requestBackgroundPermissions();
+};
+
+export default {
+    requestForegroundPermissions,
+    requestBackgroundPermissions,
+} as PermissionsModuleType;

package/src/utils/ExecTaskUtils.ts

@@ -19,7 +19,7 @@ export async function getBaseETResponse(
   mergedObjectiveIds: Array<string>,
   taskId: ExecutionTaskID
 ): Promise<BaseETResponse> {
- let lastLocation = LocationManager.getInstance().getLastLocation();
+ let lastLocation = await LocationManager.getInstance().getLastLocation();
  console.log("getBaseETResponse:lastLocation:",JSON.stringify(lastLocation))
 
   let cache = DispatchSdkCache.getInstance();
@@ -146,12 +146,12 @@ export function onTaskStart(
   const keys = DispatchSdkCache.KEYS;
   const cache = DispatchSdkCache.getInstance();
   (async () => {
-    let lastLocation = LocationManager.getInstance().getLastLocation();
+    let lastLocation = await LocationManager.getInstance().getLastLocation();
+    console.log("onTaskStart:lastLocation:",JSON.stringify(lastLocation));
     let location = {
       latitude: lastLocation.latitude,
       longitude: lastLocation.longitude,
     }
-    console.log("onTaskStart:lastLocation:",location)
     await cache.setKeyInCache(keys.TASK_START_TIME, Date.now().toString());
     await cache.setKeyInCache(keys.CURRENT_WORKING_TASK_ID, eventData.taskId);
     await cache.setObjectInCache(keys.TASK_START_LOCATION, location);

package/src/utils/SdkUtils.ts

@@ -7,6 +7,7 @@ import * as Location from 'expo-location';
 import NetworkUtil from './NetworkUtil';
 import { BaseError } from '../errors/BaseError';
 import ErrorCodes from '../errors/ErrorCodes';
+import PermissionModule from '../native/PermissionModule';
 
 const { DispatchSdkUtils } = NativeModules;
 
@@ -129,8 +130,16 @@ export default class SdkUtils {
   }
 
   public static async checkMandatory() {
-    if (Platform.OS === 'ios') return;
-    // if (Platform.OS === 'ios') return true;
+    if (Platform.OS === 'ios'){
+      const foregroundLocation = await PermissionModule.requestForegroundPermissions();
+      if (!(foregroundLocation)) {
+        throw new BaseError(
+          ErrorCodes.LOCATION_OR_GPS_NOT_ENABLED,
+          'Location or GPS not enabled'
+        );
+      }
+      return;
+    }
     const dateTimeCheck = await (
       DispatchSdkUtils as DispatchUtilsInterface
     ).isAutomaticDateTimeEnabled();
@@ -143,9 +152,10 @@ export default class SdkUtils {
     if (Platform.OS === 'android') {
       await Location.enableNetworkProviderAsync();
       let locationServicesCheck = await Location.hasServicesEnabledAsync();
-      const foregroundLocation =
-        await Location.requestForegroundPermissionsAsync();
-      const bgLocation = await Location.requestBackgroundPermissionsAsync();
+      const foregroundLocation = await PermissionModule.requestForegroundPermissions();
+      // await Location.requestForegroundPermissionsAsync(); //permission code using expo module
+      const bgLocation = await PermissionModule.requestBackgroundPermissions();
+      // await Location.requestBackgroundPermissionsAsync(); //permission code using expo module
       if (!(locationServicesCheck && foregroundLocation && bgLocation)) {
         throw new BaseError(
           ErrorCodes.LOCATION_OR_GPS_NOT_ENABLED,