hypertrack-sdk-react-native 13.2.2 → 13.3.0

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Mon Apr 08 21:33:49 EEST 2024
+gradle.version=7.2

package/android/.idea/gradle.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="testRunner" value="GRADLE" />
+        <option name="distributionType" value="DEFAULT_WRAPPED" />
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleHome" value="/usr/local/Cellar/gradle/8.2/libexec" />
+        <option name="gradleJvm" value="jbr-17" />
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>

package/android/.idea/misc.xml

@@ -0,0 +1,9 @@
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="jbr-17" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/build/classes" />
+  </component>
+  <component name="ProjectType">
+    <option name="id" value="Android" />
+  </component>
+</project>

package/android/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>

package/android/gradle.properties

@@ -1,3 +1,3 @@
 HyperTrackSdk_kotlinVersion=1.6.21
-HyperTrackSdk_HyperTrackSDKVersion=7.4.2
+HyperTrackSdk_HyperTrackSDKVersion=7.5.2
 android.useAndroidX=true

package/android/local.properties

@@ -0,0 +1,8 @@
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Mon Apr 08 21:32:54 EEST 2024
+sdk.dir=/opt/homebrew/share/android-commandlinetools

package/android/src/main/java/com/reactnativehypertracksdk/common/GeotagData.kt

@@ -1,6 +1,7 @@
 package com.reactnativehypertracksdk.common
 
 import android.location.Location
+import com.hypertrack.sdk.android.HyperTrack
 
 /**
  * The data that represents geotag to create
@@ -9,5 +10,7 @@ import android.location.Location
  */
 internal data class GeotagData(
     val data: Map<String, Any?>,
-    val expectedLocation: Location?
+    val expectedLocation: Location?,
+    val orderHandle: String?,
+    val orderStatus: HyperTrack.OrderStatus?,
 )

package/android/src/main/java/com/reactnativehypertracksdk/common/HyperTrackSdkWrapper.kt

@@ -1,16 +1,14 @@
 package com.reactnativehypertracksdk.common
 
-import com.hypertrack.sdk.*
 import com.hypertrack.sdk.android.HyperTrack
-import com.hypertrack.sdk.android.HyperTrack.metadata
 import com.hypertrack.sdk.android.Json
 import com.hypertrack.sdk.android.Result
 import com.reactnativehypertracksdk.common.Serialization.deserializeDynamicPublishableKey
-import com.reactnativehypertracksdk.common.Serialization.deserializeIsAvailable
-import com.reactnativehypertracksdk.common.Serialization.deserializeName
 import com.reactnativehypertracksdk.common.Serialization.deserializeGeotagData
+import com.reactnativehypertracksdk.common.Serialization.deserializeIsAvailable
 import com.reactnativehypertracksdk.common.Serialization.deserializeIsTracking
 import com.reactnativehypertracksdk.common.Serialization.deserializeMetadata
+import com.reactnativehypertracksdk.common.Serialization.deserializeName
 import com.reactnativehypertracksdk.common.Serialization.serializeDeviceId
 import com.reactnativehypertracksdk.common.Serialization.serializeDynamicPublishableKey
 import com.reactnativehypertracksdk.common.Serialization.serializeErrors
@@ -44,9 +42,22 @@ internal object HyperTrackSdkWrapper {
                             longitude = it.longitude
                         )
                     }
+                val orderHandle = geotag.orderHandle
+                val orderStatus = geotag.orderStatus
                 if (expectedLocation != null) {
-                    HyperTrack
-                        .addGeotag(geotagMetadata, expectedLocation)
+                    if (orderHandle != null || orderStatus != null) {
+                        if (orderHandle == null || orderStatus == null) {
+                            throw Error("orderHandle and orderStatus must be provided")
+                        }
+                        HyperTrack.addGeotag(
+                            orderHandle = orderHandle,
+                            orderStatus = orderStatus,
+                            expectedLocation = expectedLocation,
+                            metadata = geotagMetadata
+                        )
+                    } else {
+                        HyperTrack.addGeotag(geotagMetadata, expectedLocation)
+                    }
                         .let {
                             when (it) {
                                 is Result.Failure -> {
@@ -59,8 +70,18 @@ internal object HyperTrackSdkWrapper {
                             }
                         }
                 } else {
-                    HyperTrack
-                        .addGeotag(geotagMetadata)
+                    if (orderHandle != null || orderStatus != null) {
+                        if (orderHandle == null || orderStatus == null) {
+                            throw Error("orderHandle and orderStatus must be provided")
+                        }
+                        HyperTrack.addGeotag(
+                            orderHandle = orderHandle,
+                            orderStatus = orderStatus,
+                            metadata = geotagMetadata
+                        )
+                    } else {
+                        HyperTrack.addGeotag(geotagMetadata)
+                    }
                         .let { serializeLocationResult(it) }
                 }.let {
                     Success(it)

package/android/src/main/java/com/reactnativehypertracksdk/common/Serialization.kt

@@ -19,6 +19,33 @@ internal object Serialization {
         }
     }
 
+    fun deserializeGeotagData(map: Map<String, Any?>): WrapperResult<GeotagData> {
+        return parse(map) {
+            val data = it
+                .get<Map<String, Any?>>(KEY_GEOTAG_DATA)
+                .getOrThrow()
+            val expectedLocationData = it
+                .getOptional<Map<String, Any?>>(KEY_GEOTAG_EXPECTED_LOCATION)
+                .getOrThrow()
+            val expectedLocation = expectedLocationData?.let {
+                deserializeLocation(it).getOrThrow()
+            }
+            val orderHandle = it
+                .getOptional<String>(KEY_GEOTAG_ORDER_HANDLE)
+                .getOrThrow()
+            val orderStatusData = it
+                .getOptional<Map<String, Any?>>(KEY_GEOTAG_ORDER_STATUS)
+                .getOrThrow()
+            val orderStatus = orderStatusData?.let { deserializeOrderStatus(it).getOrThrow() }
+            GeotagData(
+                data = data,
+                expectedLocation = expectedLocation,
+                orderHandle = orderHandle,
+                orderStatus = orderStatus
+            )
+        }
+    }
+
     fun deserializeIsAvailable(isAvailable: Map<String, Any?>): WrapperResult<Boolean> {
         return parse(isAvailable) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_IS_AVAILABLE)
@@ -55,19 +82,6 @@ internal object Serialization {
         }
     }
 
-    fun deserializeGeotagData(map: Map<String, Any?>): WrapperResult<GeotagData> {
-        return parse(map) {
-            val data = it
-                .get<Map<String, Any?>>(KEY_GEOTAG_DATA)
-                .getOrThrow()
-            val locationData = it
-                .getOptional<Map<String, Any?>>(KEY_GEOTAG_EXPECTED_LOCATION)
-                .getOrThrow()
-            val location = locationData?.let { deserializeLocation(it).getOrThrow() }
-            GeotagData(data, location)
-        }
-    }
-
     fun serializeDeviceId(deviceId: String): Map<String, Any?> {
         return mapOf(
             KEY_TYPE to TYPE_DEVICE_ID,
@@ -121,20 +135,6 @@ internal object Serialization {
         )
     }
 
-    fun serializeMetadata(metadata: Map<String, Any?>): Map<String, Any?> {
-        return mapOf(
-            KEY_TYPE to TYPE_METADATA,
-            KEY_VALUE to metadata
-        )
-    }
-
-    fun serializeName(name: String): Map<String, Any?> {
-        return mapOf(
-            KEY_TYPE to TYPE_NAME,
-            KEY_VALUE to name
-        )
-    }
-
     fun serializeLocateResult(
         locationResult: Result<HyperTrack.Location, Set<HyperTrack.Error>>
     ): Map<String, Any?> {
@@ -181,18 +181,31 @@ internal object Serialization {
         )
     }
 
-    private fun serializeLocationWithDeviation(
-        locationWithDeviation: HyperTrack.LocationWithDeviation,
-    ): Map<String, Any?> {
+    fun serializeLocation(location: HyperTrack.Location): Map<String, Any?> {
         return mapOf(
-            KEY_TYPE to TYPE_LOCATION_WITH_DEVIATION,
+            KEY_TYPE to TYPE_LOCATION,
             KEY_VALUE to mapOf(
-                KEY_LOCATION to serializeLocation(locationWithDeviation.location),
-                KEY_DEVIATION to locationWithDeviation.deviation
+                KEY_LATITUDE to location.latitude,
+                KEY_LONGITUDE to location.longitude
             )
         )
     }
 
+
+    fun serializeMetadata(metadata: Map<String, Any?>): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_METADATA,
+            KEY_VALUE to metadata
+        )
+    }
+
+    fun serializeName(name: String): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_NAME,
+            KEY_VALUE to name
+        )
+    }
+
     private fun deserializeLocation(map: Map<String, Any?>): WrapperResult<Location> {
         return parse(map) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_LOCATION)
@@ -214,6 +227,34 @@ internal object Serialization {
         }
     }
 
+    private fun deserializeOrderStatus(
+        map: Map<String, Any?>
+    ): WrapperResult<HyperTrack.OrderStatus> {
+        return parse(map) {
+            when (it.get<String>(KEY_TYPE).getOrThrow()) {
+                TYPE_GEOTAG_ORDER_STATUS_CLOCK_IN -> HyperTrack.OrderStatus.ClockIn
+                TYPE_GEOTAG_ORDER_STATUS_CLOCK_OUT -> HyperTrack.OrderStatus.ClockOut
+                TYPE_GEOTAG_ORDER_STATUS_CUSTOM -> HyperTrack.OrderStatus.Custom(
+                    it.get<String>(KEY_VALUE).getOrThrow()
+                )
+
+                else -> throw Error("Unknown order status: $map")
+            }
+        }
+    }
+
+    private fun serializeLocationWithDeviation(
+        locationWithDeviation: HyperTrack.LocationWithDeviation,
+    ): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_LOCATION_WITH_DEVIATION,
+            KEY_VALUE to mapOf(
+                KEY_LOCATION to serializeLocation(locationWithDeviation.location),
+                KEY_DEVIATION to locationWithDeviation.deviation
+            )
+        )
+    }
+
     private fun serializeFailure(failure: List<Map<String, Any?>>): Map<String, Any?> {
         return mapOf(
             KEY_TYPE to TYPE_RESULT_FAILURE,
@@ -235,17 +276,6 @@ internal object Serialization {
         )
     }
 
-    fun serializeLocation(location: HyperTrack.Location): Map<String, Any?> {
-        return mapOf(
-            KEY_TYPE to TYPE_LOCATION,
-            KEY_VALUE to mapOf(
-                KEY_LATITUDE to location.latitude,
-                KEY_LONGITUDE to location.longitude
-            )
-        )
-    }
-
-
     private fun serializeLocationError(locationError: HyperTrack.LocationError): Map<String, Any?> {
         return when (locationError) {
             HyperTrack.LocationError.NotRunning -> {
@@ -369,11 +399,17 @@ internal object Serialization {
     private const val TYPE_LOCATION_ERROR_NOT_RUNNING = "notRunning"
     private const val TYPE_LOCATION_ERROR_STARTING = "starting"
 
+    private const val TYPE_GEOTAG_ORDER_STATUS_CLOCK_IN = "orderStatusClockIn"
+    private const val TYPE_GEOTAG_ORDER_STATUS_CLOCK_OUT = "orderStatusClockOut"
+    private const val TYPE_GEOTAG_ORDER_STATUS_CUSTOM = "orderStatusCustom"
+
     private const val KEY_LATITUDE = "latitude"
     private const val KEY_LONGITUDE = "longitude"
 
-    const val KEY_DEVIATION = "deviation"
-    const val KEY_GEOTAG_DATA = "data"
-    const val KEY_GEOTAG_EXPECTED_LOCATION = "expectedLocation"
-    const val KEY_LOCATION = "location"
+    private const val KEY_DEVIATION = "deviation"
+    private const val KEY_GEOTAG_DATA = "data"
+    private const val KEY_GEOTAG_EXPECTED_LOCATION = "expectedLocation"
+    private const val KEY_GEOTAG_ORDER_HANDLE = "orderHandle"
+    private const val KEY_GEOTAG_ORDER_STATUS = "orderStatus"
+    private const val KEY_LOCATION = "location"
 }

package/hypertrack-sdk-react-native.podspec

@@ -18,7 +18,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency 'HyperTrack', '5.4.1'
+  s.dependency 'HyperTrack', '5.5.1'
 
   # Don't install the dependencies when we run `pod install` in the old architecture.
   if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then

package/ios/common/GeotagData.swift

@@ -3,9 +3,18 @@ import HyperTrack
 struct GeotagData {
     let data: [String: Any]
     let expectedLocation: HyperTrack.Location?
+    let orderHandle: String?
+    let orderStatus: HyperTrack.OrderStatus?
 
-    init(data: [String: Any], expectedLocation: HyperTrack.Location?) {
+    init(
+        data: [String: Any],
+        expectedLocation: HyperTrack.Location?,
+        orderHandle: String?,
+        orderStatus: HyperTrack.OrderStatus?
+    ) {
         self.data = data
         self.expectedLocation = expectedLocation
+        self.orderHandle = orderHandle
+        self.orderStatus = orderStatus
     }
 }

package/ios/common/HyperTrackSDKWrapper.swift

@@ -14,12 +14,41 @@ enum FailureResult: Error {
 func addGeotag(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
     return deserializeGeotagData(args).flatMap { geotagData in
         if let metadata: HyperTrack.JSON.Object = toJSON(geotagData.data) {
+            let expectedLocation = geotagData.expectedLocation
+            let orderHandle = geotagData.orderHandle
+            let orderStatus = geotagData.orderStatus
+
             if let expectedLocation = geotagData.expectedLocation {
-                let result = HyperTrack.addGeotag(metadata, expectedLocation: expectedLocation)
-                return .success(.dict(serializeLocationWithDeviationResult(result)))
+                if orderHandle != nil || orderStatus != nil {
+                    if orderHandle == nil || orderStatus == nil {
+                        return .failure(.error("orderHandle and orderStatus must be provided"))
+                    }
+                    let result = HyperTrack.addGeotag(
+                        orderHandle: orderHandle!,
+                        orderStatus: orderStatus!,
+                        metadata: metadata,
+                        expectedLocation: expectedLocation
+                    )
+                    return .success(.dict(serializeLocationWithDeviationResult(result)))
+                } else {
+                    let result = HyperTrack.addGeotag(metadata, expectedLocation: expectedLocation)
+                    return .success(.dict(serializeLocationWithDeviationResult(result)))
+                }
             } else {
-                let result = HyperTrack.addGeotag(metadata)
-                return .success(.dict(serializeLocationResult(result)))
+                if orderHandle != nil || orderStatus != nil {
+                    if orderHandle == nil || orderStatus == nil {
+                        return .failure(.error("orderHandle and orderStatus must be provided"))
+                    }
+                    let result = HyperTrack.addGeotag(
+                        orderHandle: orderHandle!,
+                        orderStatus: orderStatus!,
+                        metadata: metadata
+                    )
+                    return .success(.dict(serializeLocationResult(result)))
+                } else {
+                    let result = HyperTrack.addGeotag(metadata)
+                    return .success(.dict(serializeLocationResult(result)))
+                }
             }
         } else {
             return .failure(.error("Failed to deserialize geotag metadata"))

package/ios/common/Serialization.swift

@@ -32,16 +32,41 @@ func deserializeGeotagData(
     guard let data = args[keyGeotagData] as? [String: Any] else {
         return .failure(.fatalError(getParseError(args, key: keyGeotagData)))
     }
+    let orderHandle = args["orderHandle"] as? String
+    let orderStatusData = args["orderStatus"] as? [String: Any]
+    let orderStatusResult: Result<HyperTrack.OrderStatus, FailureResult>? = if let orderStatusData = orderStatusData {
+        deserializeOrderStatus(orderStatusData)
+    } else {
+        nil
+    }
+    if case let .failure(failure) = orderStatusResult {
+        return .failure(failure)
+    }
+    let orderStatus: HyperTrack.OrderStatus? = if case let .success(orderStatus) = orderStatusResult {
+        orderStatus
+    } else {
+        nil
+    }
     if let expectedLocationData = args[keyExpectedLocation] as? [String: Any] {
         let expectedLocation = deserializeLocation(expectedLocationData)
         switch expectedLocation {
         case let .failure(failure):
             return .failure(failure)
         case let .success(expectedLocation):
-            return .success(.init(data: data, expectedLocation: expectedLocation))
+            return .success(.init(
+                data: data,
+                expectedLocation: expectedLocation,
+                orderHandle: orderHandle,
+                orderStatus: orderStatus
+            ))
         }
     } else {
-        return .success(.init(data: data, expectedLocation: nil))
+        return .success(.init(
+            data: data,
+            expectedLocation: nil,
+            orderHandle: orderHandle,
+            orderStatus: orderStatus
+        ))
     }
 }
 
@@ -101,6 +126,25 @@ func deserializeName(_ data: [String: Any]) -> Result<String, FailureResult> {
     return .success(value)
 }
 
+func deserializeOrderStatus(_ data: [String: Any]) -> Result<HyperTrack.OrderStatus, FailureResult> {
+    guard let type = data[keyType] as? String else {
+        return .failure(.fatalError(getParseError(data, key: keyType)))
+    }
+    switch type {
+    case "orderStatusClockIn":
+        return .success(.clockIn)
+    case "orderStatusClockOut":
+        return .success(.clockOut)
+    case "orderStatusCustom":
+        guard let value = data[keyValue] as? String else {
+            return .failure(.fatalError(getParseError(data, key: keyValue)))
+        }
+        return .success(.custom(value))
+    default:
+        return .failure(.fatalError(getParseError(data, key: keyType)))
+    }
+}
+
 func serializeDeviceID(_ deviceID: String) -> [String: Any] {
     return [
         keyType: "deviceID",

package/lib/commonjs/HyperTrack/HyperTrack.js

@@ -28,11 +28,32 @@ class HyperTrack {
   /**
    * Adds a new geotag
    *
+   * @param {string} orderHandle - Order handle
+   * @param {OrderStatus} orderStatus - Order status
    * @param {Object} data - Geotag data JSON
    * @returns current location if success or LocationError if failure
    */
 
   /**
+   * Adds a new geotag with expected location
+   *
+   * @param {string} orderHandle - Order handle
+   * @param {OrderStatus} orderStatus - Order status
+   * @param {Object} data - Geotag data JSON
+   * @param {Location} expectedLocation - Expected location
+   * @returns location with deviation if success or LocationError if failure
+   */
+
+  /**
+   * @deprecated
+   * Adds a new geotag
+   *
+   * @param {Object} data - Geotag data JSON
+   * @returns current location if success or LocationError if failure
+   */
+
+  /**
+   * @deprecated
    * Adds a new geotag with expected location
    *
    * @param {Object} data - Geotag data JSON
@@ -41,30 +62,59 @@ class HyperTrack {
    */
 
   static async addGeotag(...args) {
+    if (args.length === 3 && typeof args[0] === 'string' && HyperTrack.isOrderStatus(args[1]) && typeof args[2] === 'object') {
+      // addGeotag(orderHandle: string, orderStatus: OrderStatus, data: Object)
+      return HyperTrackSdk.addGeotag({
+        orderHandle: args[0],
+        orderStatus: args[1],
+        data: args[2],
+        expectedLocation: undefined
+      }).then(locationResponse => {
+        return this.deserializeLocationResponse(locationResponse);
+      });
+    }
+    if (args.length === 4 && typeof args[0] === 'string' && HyperTrack.isOrderStatus(args[1]) && typeof args[2] === 'object' && HyperTrack.isLocation(args[3])) {
+      // addGeotag(orderHandle: string, orderStatus: OrderStatus, data: Object, expectedLocation: Location)
+      return HyperTrackSdk.addGeotag({
+        orderHandle: args[0],
+        orderStatus: args[1],
+        data: args[2],
+        expectedLocation: {
+          type: 'location',
+          value: {
+            latitude: args[3].latitude,
+            longitude: args[3].longitude
+          }
+        }
+      }).then(locationResponse => {
+        return this.deserializeLocationWithDeviationResponse(locationResponse);
+      });
+    }
     if (args.length === 1 && typeof args[0] === 'object') {
+      // addGeotag(data: Object)
       return HyperTrackSdk.addGeotag({
         data: args[0],
         expectedLocation: undefined
       }).then(locationResponse => {
         return this.deserializeLocationResponse(locationResponse);
       });
-    } else if (args.length === 2 && typeof args[0] === 'object' && HyperTrack.isLocation(args[1])) {
-      let expectedLocation = args[1];
+    }
+    if (args.length === 2 && typeof args[0] === 'object' && HyperTrack.isLocation(args[1])) {
+      // addGeotag(data: Object, expectedLocation: Location)
       return HyperTrackSdk.addGeotag({
         data: args[0],
         expectedLocation: {
           type: 'location',
           value: {
-            latitude: expectedLocation.latitude,
-            longitude: expectedLocation.longitude
+            latitude: args[1].latitude,
+            longitude: args[1].longitude
           }
         }
       }).then(locationResponse => {
         return this.deserializeLocationWithDeviationResponse(locationResponse);
       });
-    } else {
-      throw new Error('Invalid arguments');
     }
+    throw new Error(`Invalid addGeotag() arguments: ${JSON.stringify(args)}`);
   }
 
   /**
@@ -421,6 +471,11 @@ class HyperTrack {
   static isLocation(obj) {
     return 'latitude' in obj && typeof obj.latitude === 'number' && 'longitude' in obj && typeof obj.longitude === 'number';
   }
+
+  /** @ignore */
+  static isOrderStatus(obj) {
+    return 'type' in obj && obj.type.startsWith('orderStatus');
+  }
 }
 exports.default = HyperTrack;
 _defineProperty(HyperTrack, "locateSubscription", void 0);