@os1-platform/dispatch-mobile 3.0.0 → 3.0.1

package/android/.idea/caches/deviceStreaming.xml

@@ -14,6 +14,17 @@
           <option name="screenX" value="720" />
           <option name="screenY" value="1280" />
         </PersistentDeviceSelectionData>
+        <PersistentDeviceSelectionData>
+          <option name="api" value="34" />
+          <option name="brand" value="OPPO" />
+          <option name="codename" value="OP573DL1" />
+          <option name="id" value="OP573DL1" />
+          <option name="manufacturer" value="OPPO" />
+          <option name="name" value="CPH2557" />
+          <option name="screenDensity" value="480" />
+          <option name="screenX" value="1080" />
+          <option name="screenY" value="2400" />
+        </PersistentDeviceSelectionData>
         <PersistentDeviceSelectionData>
           <option name="api" value="28" />
           <option name="brand" value="DOCOMO" />

package/android/build.gradle

@@ -127,4 +127,5 @@ dependencies {
   api 'com.facebook.react:react-native:+'
   implementation 'com.google.android.material:material:1.4.0'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation 'com.google.android.gms:play-services-location:20.0.0'
 }

package/android/src/main/AndroidManifest.xml

@@ -1,6 +1,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.dispatchsdk">
 
+  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
   <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
   <uses-permission android:name="android.permission.WAKE_LOCK" />
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

package/android/src/main/java/com/dispatchsdk/DispatchSdkPackage.kt

@@ -1,9 +1,11 @@
 package com.dispatchsdk
 
+import com.dispatchsdk.location.LocationModule
 import com.dispatchsdk.sharedPref.SharedPreferenceModule
 import com.dispatchsdk.signaturePad.RSSignatureCaptureViewManager
 import com.dispatchsdk.sync.SyncModule
 import com.dispatchsdk.utils.DispatchSdkUtils
+import com.dispatchsdk.permissions.PermissionsModule
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
@@ -15,7 +17,9 @@ class DispatchSdkPackage : ReactPackage {
     return listOf(
       SyncModule(reactContext),
       DispatchSdkUtils(reactContext),
-      SharedPreferenceModule(reactContext)
+      SharedPreferenceModule(reactContext),
+      PermissionsModule(reactContext),
+      LocationModule(reactContext)
     )
   }
 

package/android/src/main/java/com/dispatchsdk/location/LocationModule.kt

@@ -0,0 +1,79 @@
+package com.dispatchsdk.location
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.location.Location
+import android.os.Looper
+import androidx.core.app.ActivityCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import com.google.android.gms.location.*
+
+class LocationModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    private val fusedLocationClient: FusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(reactContext)
+    private var locationCallback: LocationCallback? = null
+    private var lastLocation: Location? = null
+
+    override fun getName(): String {
+        return "LocationModule"
+    }
+
+    @ReactMethod
+    fun startLocationUpdates(promise: Promise) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("Activity doesn't exist")
+            return
+        }
+
+        if (ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
+            ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+            promise.reject("Permissions not granted")
+            return
+        }
+
+        val locationRequest = LocationRequest.create().apply {
+            interval = 10000 // 10 seconds
+            fastestInterval = 10000 // 10 seconds
+            priority = LocationRequest.PRIORITY_HIGH_ACCURACY
+            smallestDisplacement = 10f // 10 meters
+        }
+
+        locationCallback = object : LocationCallback() {
+            override fun onLocationResult(locationResult: LocationResult) {
+                locationResult.lastLocation?.let { location ->
+                    lastLocation = location
+                    // Send location update to JavaScript
+                    val params = Arguments.createMap()
+                    params.putDouble("latitude", location.latitude)
+                    params.putDouble("longitude", location.longitude)
+                    params.putDouble("accuracy", location.accuracy.toDouble())
+                    sendEvent("locationUpdated", params)
+                }
+            }
+        }
+
+        try {
+            fusedLocationClient.requestLocationUpdates(locationRequest, locationCallback!!, Looper.getMainLooper())
+            promise.resolve("Location updates started")
+        } catch (e: Exception) {
+            promise.reject("Error starting location updates", e)
+        }
+    }
+
+    @ReactMethod
+    fun stopLocationUpdates(promise: Promise) {
+        locationCallback?.let {
+            fusedLocationClient.removeLocationUpdates(it)
+            promise.resolve("Location updates stopped")
+        } ?: run {
+            promise.reject("Location updates not started")
+        }
+    }
+
+    private fun sendEvent(eventName: String, params: WritableMap) {
+        reactApplicationContext
+            .getJSModule(RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+}

package/android/src/main/java/com/dispatchsdk/permissions/PermissionModule.kt

@@ -0,0 +1,90 @@
+package com.dispatchsdk.permissions
+
+import android.Manifest
+import android.app.Activity
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.activity.ComponentActivity
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.annotation.RequiresApi
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.*
+
+class PermissionsModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    companion object {
+        private const val REQUEST_CODE_FOREGROUND = 1
+        private const val REQUEST_CODE_BACKGROUND = 2
+    }
+
+    private var foregroundPromise: Promise? = null
+    private var backgroundPromise: Promise? = null
+
+    override fun getName(): String {
+        return "PermissionsModule"
+    }
+
+    private val requestForegroundPermissionLauncher = (reactContext.currentActivity as? ComponentActivity)?.registerForActivityResult(
+        ActivityResultContracts.RequestPermission()
+    ) { isGranted: Boolean ->
+        foregroundPromise?.let {
+            if (isGranted) {
+                it.resolve(true)
+            } else {
+                it.reject("Permission denied")
+            }
+            foregroundPromise = null
+        }
+    }
+
+    private val requestBackgroundPermissionLauncher =
+        (reactContext.currentActivity as? ComponentActivity)?.registerForActivityResult(
+            ActivityResultContracts.RequestPermission()
+        ) { isGranted: Boolean ->
+            backgroundPromise?.let {
+                if (isGranted) {
+                    it.resolve(true)
+                } else {
+                    it.reject("Permission denied")
+                }
+                backgroundPromise = null
+            }
+        }
+
+    @ReactMethod
+    fun requestForegroundPermissions(promise: Promise) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("Activity doesn't exist")
+            return
+        }
+
+        if (ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
+            promise.resolve(true)
+        } else {
+            foregroundPromise = promise
+            requestForegroundPermissionLauncher?.launch(Manifest.permission.ACCESS_FINE_LOCATION)
+        }
+    }
+
+    @ReactMethod
+    fun requestBackgroundPermissions(promise: Promise) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("Activity doesn't exist")
+            return
+        }
+
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            // For devices running Android versions below Q, background location permission is not needed.
+            promise.resolve(true)
+            return
+        }
+
+        if (ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED) {
+            promise.resolve(true)
+        } else {
+            backgroundPromise = promise
+            requestBackgroundPermissionLauncher?.launch(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+        }
+    }
+}

package/ios/EventEmitter.swift

@@ -9,13 +9,25 @@
 import UIKit
 
 class EventEmitter{
+    
     public static var sharedInstance = EventEmitter()
+    
     private static var eventEmitter: RNEventEmitter!
+    
     private init() {}
+    
     func registerEventEmitter(eventEmitter: RNEventEmitter) {
         EventEmitter.eventEmitter = eventEmitter
     }
-    func dispatch(name: String, body: [String:Any]?) {
+    
+    func dispatch(name: String, body: Any?) {
         EventEmitter.eventEmitter.sendEvent(withName: name, body: body)
     }
+    
+    /// All Events which must be support by React Native.
+    lazy var allEvents: [String] = {
+        var allEventNames: [String] = ["locationUpdated"]
+        return allEventNames
+    }()
+    
 }

package/ios/LocationManager.swift

@@ -0,0 +1,143 @@
+//
+//  LocationManager.swift
+//  MySDK
+//
+//  Created by Apple on 21/02/23.
+//
+
+import Foundation
+import CoreLocation
+
+
+public class LocationManager: NSObject,CLLocationManagerDelegate {
+    private var locationManager: CLLocationManager?
+    private var permissionEnabled: Bool = false
+    var completePermisisonRequestBlock: ((Bool) -> Void)? = nil
+    var lastLocationData = [String: Double]()
+    
+    struct Static
+    {
+        static var instance: LocationManager?
+    }
+    var startSyncBool:Bool = false
+    
+    override init(){
+        super.init()
+        setupLocationManager()
+    }
+    
+    
+    public class var sharedInstance: LocationManager
+    {
+        if Static.instance == nil
+        {
+            Static.instance = LocationManager()
+        }
+        debugPrint("Yes I called inside shared instance")
+        return Static.instance!
+    }
+    
+    
+    private func setupLocationManager(){
+        if(self.locationManager == nil){
+            DispatchQueue.main.async {
+                self.lastLocationData["latitude"] = 0.0
+                self.lastLocationData["longitude"] = 0.0
+                self.lastLocationData["accuracy"] = 0.0
+                self.locationManager = CLLocationManager()
+                self.locationManager?.delegate = self
+                self.locationManager?.allowsBackgroundLocationUpdates = true
+                self.locationManager?.pausesLocationUpdatesAutomatically = false
+                self.locationManager?.desiredAccuracy = kCLLocationAccuracyBestForNavigation
+                self.locationManager?.distanceFilter = 10
+            }
+        }
+        
+    }
+    
+    public func getLastLocation()->[String:Double]{
+        return self.lastLocationData
+    }
+    public func locationPermissionEnabled() -> Bool{
+        return self.permissionEnabled
+    }
+    
+    private func callPermissionCallBack(permissionStatus: Bool){
+        if let completionBlock = self.completePermisisonRequestBlock {
+            completionBlock(permissionStatus);
+        }
+    }
+    public func requestLocationPermissions(){
+        if CLLocationManager.locationServicesEnabled() {
+            let currentStatus = self.locationManager?.authorizationStatus
+            switch currentStatus {
+            case .notDetermined, .restricted, .denied:
+                self.permissionEnabled = false
+                self.callPermissionCallBack(permissionStatus: self.permissionEnabled)
+                self.completePermisisonRequestBlock = nil
+                break
+            case .authorizedWhenInUse, .authorizedAlways:
+                self.permissionEnabled = true
+                self.callPermissionCallBack(permissionStatus: self.permissionEnabled)
+                self.completePermisisonRequestBlock = nil
+                break
+            case .none:
+                self.permissionEnabled = false
+                self.locationManager?.requestWhenInUseAuthorization()
+                break
+            @unknown default:
+                debugPrint("restricted not")
+            }
+        } else {
+            self.permissionEnabled = false
+            self.callPermissionCallBack(permissionStatus: self.permissionEnabled)
+            self.completePermisisonRequestBlock = nil
+        }
+    }
+    
+    public func startLocationUpdates(){
+        self.locationManager?.startUpdatingLocation()
+    }
+    
+    public func stopLocationUpdates(){
+        self.locationManager?.stopUpdatingLocation()
+    }
+    
+    private func sendEvent(locationData:[String:Double]){
+        // EventEmitter.sharedInstance.dispatch(name: "locationUpdated", body: locationData)
+    }
+    
+    public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        debugPrint("locationManager:didUpdateLocations:\(locations)")
+        if let lastLocation = locations.last{
+            let coordinate: CLLocationCoordinate2D = lastLocation.coordinate
+            self.lastLocationData["latitude"] = coordinate.latitude
+            self.lastLocationData["longitude"] = coordinate.longitude
+            if(lastLocation.horizontalAccuracy > 0){
+                self.lastLocationData["accuracy"] = lastLocation.horizontalAccuracy
+            }else if(lastLocation.verticalAccuracy > 0){
+                self.lastLocationData["accuracy"] = lastLocation.verticalAccuracy
+            }
+            self.sendEvent(locationData: self.lastLocationData)
+            debugPrint("locationManager:didUpdateLocations:lastLocationData:\(self.lastLocationData)")
+        }
+    }
+    
+    public func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        debugPrint("locationManager:didFailWithError:\(error.localizedDescription)")
+    }
+    
+    public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        if manager.authorizationStatus == .authorizedWhenInUse || manager.authorizationStatus == .authorizedAlways{
+            self.permissionEnabled = true
+            self.callPermissionCallBack(permissionStatus: self.permissionEnabled)
+            self.completePermisisonRequestBlock = nil
+        }else{
+            self.permissionEnabled = false
+            self.callPermissionCallBack(permissionStatus: self.permissionEnabled)
+            self.completePermisisonRequestBlock = nil
+        }
+    }
+    
+}
+

package/ios/LocationModule.m

@@ -0,0 +1,19 @@
+//
+//  LocationModule.m
+//  DispatchSdk
+//
+//  Created by apple on 26/12/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(LocationModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(startLocationUpdates:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(stopLocationUpdates:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getLastLocation:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+
+
+@end

package/ios/LocationModule.swift

@@ -0,0 +1,32 @@
+
+@objc(LocationModule)
+
+class LocationModule: RNEventEmitter{
+
+    @objc(startLocationUpdates:withRejecter:)
+    func startLocationUpdates(resolve: RCTPromiseResolveBlock, withRejecter reject: RCTPromiseRejectBlock) -> Void {
+        LocationManager.sharedInstance.startLocationUpdates()
+        resolve(true)
+    }
+    
+    @objc(stopLocationUpdates:withRejecter:)
+    func stopLocationUpdates(resolve: RCTPromiseResolveBlock, withRejecter reject: RCTPromiseRejectBlock) -> Void {
+        LocationManager.sharedInstance.stopLocationUpdates()
+        resolve(true)
+    }
+    
+    @objc(getLastLocation:withRejecter:)
+    func getLastLocation(resolve: RCTPromiseResolveBlock, withRejecter reject: RCTPromiseRejectBlock) -> Void {
+        let location = LocationManager.sharedInstance.getLastLocation()
+        resolve(location)
+    }
+    
+    /// Explicitly override supportedEvents to satisfy RCTEventEmitter requirements
+      @objc override func supportedEvents() -> [String] {
+          return super.supportedEvents() // Delegate to RNEventEmitter
+      }
+}
+
+
+
+

package/ios/PermissionsModule.m

@@ -0,0 +1,21 @@
+//
+//  PermissionModule.m
+//  DispatchSdk
+//
+//  Created by apple on 26/12/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(PermissionsModule, NSObject)
+
+RCT_EXTERN_METHOD(requestForegroundPermissions:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(requestBackgroundPermissions:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+@end

package/ios/PermissionsModule.swift

@@ -0,0 +1,24 @@
+
+import CoreLocation
+@objc(PermissionsModule)
+class PermissionsModule: NSObject{
+
+    @objc(requestForegroundPermissions:withRejecter:)
+    func requestForegroundPermissions(resolve: @escaping RCTPromiseResolveBlock, withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
+        LocationManager.sharedInstance.completePermisisonRequestBlock = { (response) -> Void in
+            resolve(response)
+        }
+        LocationManager.sharedInstance.requestLocationPermissions();
+    }
+    @objc(requestBackgroundPermissions:withRejecter:)
+    func requestBackgroundPermissions(resolve: @escaping RCTPromiseResolveBlock, withRejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
+        LocationManager.sharedInstance.completePermisisonRequestBlock = { (response) -> Void in
+            resolve(response)
+        }
+        LocationManager.sharedInstance.requestLocationPermissions();
+    }
+}
+
+
+
+

package/ios/RNEventEmitter.m

@@ -1,15 +1,9 @@
-//
-//  RNEventEmitter.m
-//  TiresKicked
-//
-//  Created by Apple on 07/11/22.
-//  Copyright © 2022 Facebook. All rights reserved.
-//
-
 #import <Foundation/Foundation.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
 
 @interface RCT_EXTERN_MODULE(RNEventEmitter, RCTEventEmitter)
 
+RCT_EXTERN_METHOD(supportedEvents)
+
 @end

package/ios/RNEventEmitter.swift

@@ -1,24 +1,18 @@
-//
-//  RNEventEmitter.swift
-//  TiresKicked
-//
-//  Created by Apple on 07/11/22.
-//  Copyright © 2022 Facebook. All rights reserved.
-//
-
 import Foundation
-import React
+
 @objc(RNEventEmitter)
 open class RNEventEmitter: RCTEventEmitter {
- override init() {
-    super.init()
-    EventEmitter.sharedInstance.registerEventEmitter(eventEmitter: self)
-  }
-  open override func supportedEvents() -> [String]! {
-      return [EventsConstant.START.rawValue]
-  }
     
-  public override static func requiresMainQueueSetup() -> Bool { return false
-      
-  }
+    override init() {
+        super.init()
+        EventEmitter.sharedInstance.registerEventEmitter(eventEmitter: self)
+    }
+    
+    /// Base overide for RCTEventEmitter.
+    ///
+    /// - Returns: all supported events
+    @objc open override func supportedEvents() -> [String] {
+        return EventEmitter.sharedInstance.allEvents
+    }
+    
 }

package/lib/commonjs/components/executiontasks/doodle/SignatureET.js

@@ -116,9 +116,11 @@ const SignatureET = props => {
         const folderName = (await _DispatchSdkCache.default.getInstance().getKeyFromCache(_DispatchSdkCache.default.KEYS.FMS_FOLDER)) ?? 'NULL';
         const dateTime = await _callbacksHandler.default.getDateTime();
         console.log('saveAndSubmit:dateTime: ', dateTime);
-        let lat = _LocationManager.default.getInstance().getLastLocation().latitude;
-        let lng = _LocationManager.default.getInstance().getLastLocation().longitude;
-        let accuracy = _LocationManager.default.getInstance().getLastLocation().accuracy;
+        let lastLocation = await _LocationManager.default.getInstance().getLastLocation();
+        console.log("signatureET:lastLocation:", JSON.stringify(lastLocation));
+        let lat = lastLocation.latitude;
+        let lng = lastLocation.longitude;
+        let accuracy = lastLocation.accuracy;
         let insertID = await (0, _SyncManagerUtils.insertDocumentInDB)(fileName, folderName,
         // JSON.stringify(props.jobIDs),
         // JSON.stringify(props.objRefs),