hypertrack-sdk-react-native 13.4.0 → 13.5.0

package/android/gradle.properties

@@ -1,3 +1,3 @@
 HyperTrackSdk_kotlinVersion=1.6.21
-HyperTrackSdk_HyperTrackSDKVersion=7.6.0
+HyperTrackSdk_HyperTrackSDKVersion=7.7.0
 android.useAndroidX=true

package/android/src/main/java/com/reactnativehypertracksdk/HyperTrackReactNativePlugin.kt

@@ -1,16 +1,23 @@
 package com.reactnativehypertracksdk
 
-import com.facebook.react.bridge.*
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.hypertrack.sdk.*
 import com.hypertrack.sdk.android.HyperTrack
-import com.reactnativehypertracksdk.common.*
+import com.reactnativehypertracksdk.common.HyperTrackSdkWrapper
 import com.reactnativehypertracksdk.common.Serialization.serializeErrors
 import com.reactnativehypertracksdk.common.Serialization.serializeIsAvailable
 import com.reactnativehypertracksdk.common.Serialization.serializeIsTracking
 import com.reactnativehypertracksdk.common.Serialization.serializeLocateResult
 import com.reactnativehypertracksdk.common.Serialization.serializeLocationResult
+import com.reactnativehypertracksdk.common.Serialization.serializeOrders
+import com.reactnativehypertracksdk.common.Success
 
 @ReactModule(name = HyperTrackReactNativePlugin.NAME)
 class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
@@ -40,15 +47,28 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
             EVENT_ERRORS -> {
                 emitEvent(EVENT_ERRORS, serializeErrors(HyperTrack.errors).toWriteableArray())
             }
+
             EVENT_IS_AVAILABLE -> {
-                emitEvent(EVENT_IS_AVAILABLE, serializeIsAvailable(HyperTrack.isAvailable).toWritableMap())
+                emitEvent(
+                    EVENT_IS_AVAILABLE,
+                    serializeIsAvailable(HyperTrack.isAvailable).toWritableMap(),
+                )
             }
+
             EVENT_IS_TRACKING -> {
-                emitEvent(EVENT_IS_TRACKING, serializeIsTracking(HyperTrack.isTracking).toWritableMap())
+                emitEvent(
+                    EVENT_IS_TRACKING,
+                    serializeIsTracking(HyperTrack.isTracking).toWritableMap(),
+                )
             }
+
             EVENT_LOCATION -> {
-                emitEvent(EVENT_LOCATION, serializeLocationResult(HyperTrack.location).toWritableMap())
+                emitEvent(
+                    EVENT_LOCATION,
+                    serializeLocationResult(HyperTrack.location).toWritableMap(),
+                )
             }
+
             else -> Unit
         }
         // Keep: Required for RN built in Event Emitter Calls.
@@ -111,6 +131,11 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
         HyperTrackSdkWrapper.getName().toPromise(promise)
     }
 
+    @ReactMethod
+    fun getOrders(promise: Promise) {
+        HyperTrackSdkWrapper.getOrders().toPromise(promise)
+    }
+
     @ReactMethod
     fun getWorkerHandle(promise: Promise) {
         HyperTrackSdkWrapper.getWorkerHandle().toPromise(promise)
@@ -181,6 +206,12 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
             }.also {
                 result.add(it)
             }
+
+            HyperTrack.subscribeToOrders {
+                emitEvent(EVENT_ORDERS, serializeOrders(it.values).toWritableMap())
+            }.also {
+                result.add(it)
+            }
         }
     }
 
@@ -209,6 +240,7 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
         private const val EVENT_IS_TRACKING = "isTracking"
         private const val EVENT_LOCATE = "locate"
         private const val EVENT_LOCATION = "location"
+        private const val EVENT_ORDERS = "orders"
 
         const val NAME = "HyperTrackReactNativePlugin"
     }

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

@@ -21,6 +21,7 @@ import com.reactnativehypertracksdk.common.Serialization.serializeLocationSucces
 import com.reactnativehypertracksdk.common.Serialization.serializeLocationWithDeviationSuccess
 import com.reactnativehypertracksdk.common.Serialization.serializeMetadata
 import com.reactnativehypertracksdk.common.Serialization.serializeName
+import com.reactnativehypertracksdk.common.Serialization.serializeOrders
 import com.reactnativehypertracksdk.common.Serialization.serializeWorkerHandle
 
 typealias Serialized = Map<String, Any?>
@@ -139,6 +140,12 @@ internal object HyperTrackSdkWrapper {
         )
     }
 
+    fun getOrders(): WrapperResult<Serialized> {
+        return Success(
+            serializeOrders(HyperTrack.orders.values),
+        )
+    }
+
     fun getWorkerHandle(): WrapperResult<Serialized> {
         return Success(
             serializeWorkerHandle(HyperTrack.workerHandle),

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

@@ -16,6 +16,7 @@ internal enum class SdkMethod {
     getLocation,
     getMetadata,
     getName,
+    getOrders,
     getWorkerHandle,
     locate,
     setDynamicPublishableKey,

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

@@ -18,15 +18,15 @@ internal object Serialization {
         }
     }
 
-    fun deserializeGeotagData(map: Map<String, Any?>): WrapperResult<GeotagData> {
+    fun deserializeGeotagData(map: Serialized): WrapperResult<GeotagData> {
         return parse(map) {
             val data =
                 it
-                    .get<Map<String, Any?>>(KEY_GEOTAG_DATA)
+                    .get<Serialized>(KEY_GEOTAG_DATA)
                     .getOrThrow()
             val expectedLocationData =
                 it
-                    .getOptional<Map<String, Any?>>(KEY_GEOTAG_EXPECTED_LOCATION)
+                    .getOptional<Serialized>(KEY_GEOTAG_EXPECTED_LOCATION)
                     .getOrThrow()
             val expectedLocation =
                 expectedLocationData?.let {
@@ -34,12 +34,12 @@ internal object Serialization {
                 }
             val orderHandleData =
                 it
-                    .getOptional<Map<String, Any?>>(KEY_GEOTAG_ORDER_HANDLE)
+                    .getOptional<Serialized>(KEY_GEOTAG_ORDER_HANDLE)
                     .getOrThrow()
             val orderHandle = orderHandleData?.let { deserializeOrderHandle(it).getOrThrow() }
             val orderStatusData =
                 it
-                    .getOptional<Map<String, Any?>>(KEY_GEOTAG_ORDER_STATUS)
+                    .getOptional<Serialized>(KEY_GEOTAG_ORDER_STATUS)
                     .getOrThrow()
             val orderStatus = orderStatusData?.let { deserializeOrderStatus(it).getOrThrow() }
             GeotagData(
@@ -51,7 +51,7 @@ internal object Serialization {
         }
     }
 
-    fun deserializeIsAvailable(isAvailable: Map<String, Any?>): WrapperResult<Boolean> {
+    fun deserializeIsAvailable(isAvailable: Serialized): WrapperResult<Boolean> {
         return parse(isAvailable) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_IS_AVAILABLE)
             it
@@ -60,7 +60,7 @@ internal object Serialization {
         }
     }
 
-    fun deserializeIsTracking(isTracking: Map<String, Any?>): WrapperResult<Boolean> {
+    fun deserializeIsTracking(isTracking: Serialized): WrapperResult<Boolean> {
         return parse(isTracking) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_IS_TRACKING)
             it
@@ -69,16 +69,16 @@ internal object Serialization {
         }
     }
 
-    fun deserializeMetadata(metadata: Map<String, Any?>): WrapperResult<Map<String, Any?>> {
+    fun deserializeMetadata(metadata: Serialized): WrapperResult<Serialized> {
         return parse(metadata) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_METADATA)
             it
-                .get<Map<String, Any?>>(KEY_VALUE)
+                .get<Serialized>(KEY_VALUE)
                 .getOrThrow()
         }
     }
 
-    fun deserializeName(name: Map<String, Any?>): WrapperResult<String> {
+    fun deserializeName(name: Serialized): WrapperResult<String> {
         return parse(name) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_NAME)
             it
@@ -87,7 +87,7 @@ internal object Serialization {
         }
     }
 
-    fun deserializeWorkerHandle(map: Map<String, Any?>): WrapperResult<String> {
+    fun deserializeWorkerHandle(map: Serialized): WrapperResult<String> {
         return parse(map) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_WORKER_HANDLE)
             it
@@ -96,7 +96,7 @@ internal object Serialization {
         }
     }
 
-    fun serializeDeviceId(deviceId: String): Map<String, Any?> {
+    fun serializeDeviceId(deviceId: String): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_DEVICE_ID,
             KEY_VALUE to deviceId,
@@ -136,21 +136,21 @@ internal object Serialization {
         }
     }
 
-    fun serializeIsAvailable(isAvailable: Boolean): Map<String, Any?> {
+    fun serializeIsAvailable(isAvailable: Boolean): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_IS_AVAILABLE,
             KEY_VALUE to isAvailable,
         )
     }
 
-    fun serializeIsTracking(isTracking: Boolean): Map<String, Any?> {
+    fun serializeIsTracking(isTracking: Boolean): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_IS_TRACKING,
             KEY_VALUE to isTracking,
         )
     }
 
-    fun serializeLocateResult(locationResult: Result<HyperTrack.Location, Set<HyperTrack.Error>>): Map<String, Any?> {
+    fun serializeLocateResult(locationResult: Result<HyperTrack.Location, Set<HyperTrack.Error>>): Serialized {
         return when (locationResult) {
             is Result.Failure -> {
                 serializeFailure(serializeErrors(locationResult.failure))
@@ -162,7 +162,7 @@ internal object Serialization {
         }
     }
 
-    fun serializeLocationResult(locationResult: Result<HyperTrack.Location, HyperTrack.LocationError>): Map<String, Any?> {
+    fun serializeLocationResult(locationResult: Result<HyperTrack.Location, HyperTrack.LocationError>): Serialized {
         return when (locationResult) {
             is Result.Failure -> {
                 serializeLocationErrorFailure(locationResult.failure)
@@ -174,15 +174,15 @@ internal object Serialization {
         }
     }
 
-    fun serializeLocationErrorFailure(locationError: HyperTrack.LocationError): Map<String, Any?> {
+    fun serializeLocationErrorFailure(locationError: HyperTrack.LocationError): Serialized {
         return serializeFailure(serializeLocationError(locationError))
     }
 
-    fun serializeLocationSuccess(location: HyperTrack.Location): Map<String, Any?> {
+    fun serializeLocationSuccess(location: HyperTrack.Location): Serialized {
         return serializeSuccess(serializeLocation(location))
     }
 
-    fun serializeLocationWithDeviationSuccess(locationWithDeviation: HyperTrack.LocationWithDeviation): Map<String, Any?> {
+    fun serializeLocationWithDeviationSuccess(locationWithDeviation: HyperTrack.LocationWithDeviation): Serialized {
         return serializeSuccess(
             serializeLocationWithDeviation(
                 locationWithDeviation,
@@ -190,44 +190,47 @@ 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,
-                ),
-        )
-    }
-
-    fun serializeMetadata(metadata: Map<String, Any?>): Map<String, Any?> {
+    fun serializeMetadata(metadata: Serialized): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_METADATA,
             KEY_VALUE to metadata,
         )
     }
 
-    fun serializeName(name: String): Map<String, Any?> {
+    fun serializeName(name: String): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_NAME,
             KEY_VALUE to name,
         )
     }
 
-    fun serializeWorkerHandle(workerHandle: String): Map<String, Any?> {
+    fun serializeOrders(orders: Collection<HyperTrack.Order>): Serialized {
+        return mapOf(
+            KEY_TYPE to TYPE_ORDERS,
+            KEY_VALUE to
+                orders.mapIndexed { index, order ->
+                    mapOf(
+                        KEY_ORDER_HANDLE to order.orderHandle,
+                        KEY_ORDER_INDEX to index,
+                        KEY_ORDER_IS_INSIDE_GEOFENCE to serializeIsInsideGeofence(order.isInsideGeofence),
+                    )
+                },
+        )
+    }
+
+    fun serializeWorkerHandle(workerHandle: String): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_WORKER_HANDLE,
             KEY_VALUE to workerHandle,
         )
     }
 
-    private fun deserializeLocation(map: Map<String, Any?>): WrapperResult<Location> {
+    private fun deserializeLocation(map: Serialized): WrapperResult<Location> {
         return parse(map) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_LOCATION)
             val value =
                 it
-                    .get<Map<String, Any?>>(KEY_VALUE)
+                    .get<Serialized>(KEY_VALUE)
                     .getOrThrow()
             parse(value) { parser ->
                 val latitude =
@@ -246,7 +249,7 @@ internal object Serialization {
         }
     }
 
-    private fun deserializeOrderHandle(map: Map<String, Any?>): WrapperResult<String> {
+    private fun deserializeOrderHandle(map: Serialized): WrapperResult<String> {
         return parse(map) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_ORDER_HANDLE)
             it
@@ -255,7 +258,7 @@ internal object Serialization {
         }
     }
 
-    private fun deserializeOrderStatus(map: Map<String, Any?>): WrapperResult<HyperTrack.OrderStatus> {
+    private fun deserializeOrderStatus(map: Serialized): WrapperResult<HyperTrack.OrderStatus> {
         return parse(map) {
             when (it.get<String>(KEY_TYPE).getOrThrow()) {
                 TYPE_GEOTAG_ORDER_STATUS_CLOCK_IN -> HyperTrack.OrderStatus.ClockIn
@@ -270,7 +273,35 @@ internal object Serialization {
         }
     }
 
-    private fun serializeLocationWithDeviation(locationWithDeviation: HyperTrack.LocationWithDeviation): Map<String, Any?> {
+    private fun serializeIsInsideGeofence(isInsideGeofence: Result<Boolean, HyperTrack.LocationError>): Serialized {
+        return when (isInsideGeofence) {
+            is Result.Failure -> {
+                serializeFailure(serializeLocationError(isInsideGeofence.failure))
+            }
+
+            is Result.Success -> {
+                serializeSuccess(
+                    mapOf(
+                        KEY_TYPE to TYPE_IS_INSIDE_GEOFENCE,
+                        KEY_VALUE to isInsideGeofence.success,
+                    ),
+                )
+            }
+        }
+    }
+
+    private fun serializeLocation(location: HyperTrack.Location): Serialized {
+        return mapOf(
+            KEY_TYPE to TYPE_LOCATION,
+            KEY_VALUE to
+                mapOf(
+                    KEY_LATITUDE to location.latitude,
+                    KEY_LONGITUDE to location.longitude,
+                ),
+        )
+    }
+
+    private fun serializeLocationWithDeviation(locationWithDeviation: HyperTrack.LocationWithDeviation): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_LOCATION_WITH_DEVIATION,
             KEY_VALUE to
@@ -281,28 +312,28 @@ internal object Serialization {
         )
     }
 
-    private fun serializeFailure(failure: List<Map<String, Any?>>): Map<String, Any?> {
+    private fun serializeFailure(failure: List<Serialized>): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_RESULT_FAILURE,
             KEY_VALUE to failure,
         )
     }
 
-    private fun serializeFailure(failure: Map<String, Any?>): Map<String, Any?> {
+    private fun serializeFailure(failure: Serialized): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_RESULT_FAILURE,
             KEY_VALUE to failure,
         )
     }
 
-    private fun serializeSuccess(success: Map<String, Any?>): Map<String, Any?> {
+    private fun serializeSuccess(success: Serialized): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_RESULT_SUCCESS,
             KEY_VALUE to success,
         )
     }
 
-    private fun serializeLocationError(locationError: HyperTrack.LocationError): Map<String, Any?> {
+    private fun serializeLocationError(locationError: HyperTrack.LocationError): Serialized {
         return when (locationError) {
             HyperTrack.LocationError.NotRunning -> {
                 mapOf(KEY_TYPE to TYPE_LOCATION_ERROR_NOT_RUNNING)
@@ -324,7 +355,7 @@ internal object Serialization {
     }
 
     fun <T> parse(
-        source: Map<String, Any?>,
+        source: Serialized,
         parseFunction: (Parser) -> T,
     ): WrapperResult<T> {
         val parser = Parser(source)
@@ -346,7 +377,7 @@ internal object Serialization {
     }
 
     internal class Parser(
-        private val source: Map<String, Any?>,
+        private val source: Serialized,
     ) {
         private val _exceptions = mutableListOf<Exception>()
         val exceptions: List<Exception> = _exceptions
@@ -412,11 +443,13 @@ internal object Serialization {
     private const val TYPE_DYNAMIC_PUBLISHABLE_KEY = "dynamicPublishableKey"
     private const val TYPE_ERROR = "error"
     private const val TYPE_IS_AVAILABLE = "isAvailable"
+    private const val TYPE_IS_INSIDE_GEOFENCE = "isInsideGeofence"
     private const val TYPE_IS_TRACKING = "isTracking"
     private const val TYPE_LOCATION = "location"
     private const val TYPE_LOCATION_WITH_DEVIATION = "locationWithDeviation"
     private const val TYPE_METADATA = "metadata"
     private const val TYPE_NAME = "name"
+    private const val TYPE_ORDERS = "orders"
     private const val TYPE_WORKER_HANDLE = "workerHandle"
 
     private const val TYPE_LOCATION_ERROR_ERRORS = "errors"
@@ -436,5 +469,8 @@ internal object Serialization {
     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_ORDER_IS_INSIDE_GEOFENCE = "isInsideGeofence"
     private const val KEY_LOCATION = "location"
+    private const val KEY_ORDER_HANDLE = "orderHandle"
+    private const val KEY_ORDER_INDEX = "orderIndex"
 }

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.6.0'
+  s.dependency 'HyperTrack', '5.7.0'
 
   # Don't install the dependencies when we run `pod install` in the old architecture.
   if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then

package/ios/HyperTrackReactNativePlugin.m

@@ -37,8 +37,11 @@ RCT_EXTERN_METHOD(getMetadata:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(getName:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(getOrders:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(getWorkerHandle:(RCTPromiseResolveBlock)resolve
-                    rejecter:(RCTPromiseRejectBlock)reject)
+                  rejecter:(RCTPromiseRejectBlock)reject)
 
 RCT_EXTERN_METHOD(locate:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)

package/ios/HyperTrackReactNativePlugin.swift

@@ -5,6 +5,7 @@ struct Subscriptions {
     let isAvailableSubscription: HyperTrack.Cancellable
     let isTrackingSubscription: HyperTrack.Cancellable
     let errorsSubscription: HyperTrack.Cancellable
+    let ordersSubscription: HyperTrack.Cancellable
 }
 
 @objc(HyperTrackReactNativePlugin)
@@ -14,6 +15,7 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
     private let eventIsTracking = "isTracking"
     private let eventLocate = "locate"
     private let eventLocation = "location"
+    private let eventOrders = "orders"
 
     private var subscriptions: Subscriptions? = nil
     private var locateSubscription: HyperTrack.Cancellable? = nil
@@ -29,6 +31,7 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
             eventIsTracking,
             eventLocate,
             eventLocation,
+            eventOrders,
         ]
     }
 
@@ -52,6 +55,8 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
             sendEvent(withName: eventErrors, body: serializeErrors(HyperTrack.errors))
         case eventLocation:
             sendEvent(withName: eventLocation, body: serializeLocationResult(HyperTrack.location))
+        case eventOrders:
+            sendEvent(withName: eventOrders, body: serializeOrders(Array(HyperTrack.orders)))
         default:
             return
         }
@@ -168,6 +173,18 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
         )
     }
 
+    @objc func getOrders(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.getOrders(),
+            method: .getOrders,
+            resolve,
+            reject
+        )
+    }
+
     @objc func getWorkerHandle(
         _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
@@ -299,7 +316,10 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
         let locationSubscription = HyperTrack.subscribeToLocation { locationResult in
             self.sendEvent(withName: self.eventLocation, body: serializeLocationResult(locationResult))
         }
-        return Subscriptions(locationSubscription: locationSubscription, isAvailableSubscription: isAvailableSubscription, isTrackingSubscription: isTrackingSubscription, errorsSubscription: errorsSubscription)
+        let ordersSubscription = HyperTrack.subscribeToOrders { orders in
+            self.sendEvent(withName: self.eventOrders, body: serializeOrders(Array(orders)))
+        }
+        return Subscriptions(locationSubscription: locationSubscription, isAvailableSubscription: isAvailableSubscription, isTrackingSubscription: isTrackingSubscription, errorsSubscription: errorsSubscription, ordersSubscription: ordersSubscription)
     }
 }
 

package/ios/common/HyperTrackSDKWrapper.swift

@@ -88,6 +88,10 @@ func getName() -> Result<SuccessResult, FailureResult> {
     .success(.dict(serializeName(HyperTrack.name)))
 }
 
+func getOrders() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeOrders(Array(HyperTrack.orders))))
+}
+
 func getWorkerHandle() -> Result<SuccessResult, FailureResult> {
     .success(.dict(serializeWorkerHandle(HyperTrack.workerHandle)))
 }

package/ios/common/SDKMethod.swift

@@ -8,6 +8,7 @@ enum SDKMethod: String {
     case getLocation
     case getMetadata
     case getName
+    case getOrders
     case getWorkerHandle
     case locate
     case setDynamicPublishableKey

package/ios/common/Serialization.swift

@@ -250,6 +250,24 @@ func serializeIsAvailable(_ isAvailable: Bool) -> [String: Any] {
     ]
 }
 
+func serializeIsInsideGeofence(_ isInsideGeofence: Result<Bool, HyperTrack.Location.Error>) -> [String: Any] {
+    switch isInsideGeofence {
+    case let .success(success):
+        return [
+            keyType: typeSuccess,
+            keyValue: [
+                keyType: "isInsideGeofence",
+                keyValue: success,
+            ],
+        ]
+    case let .failure(failure):
+        return [
+            keyType: typeFailure,
+            keyValue: serializeLocationError(failure),
+        ]
+    }
+}
+
 func serializeIsTracking(_ isTracking: Bool) -> [String: Any] {
     return [
         keyType: typeIsTracking,
@@ -358,6 +376,18 @@ func serializeName(_ name: String) -> [String: Any] {
     ]
 }
 
+func serializeOrders(_ orders: [HyperTrack.Order]) -> [String: Any] {
+    return [
+        keyType: "orders",
+        keyValue: orders.map { order in
+            [
+                "orderHandle": order.orderHandle,
+                "isInsideGeofence": serializeIsInsideGeofence(order.isInsideGeofence),
+            ]
+        },
+    ]
+}
+
 func serializeWorkerHandle(_ workerHandle: String) -> [String: Any] {
     return [
         keyType: typeWorkerHandle,