hypertrack-sdk-react-native 13.4.0 → 13.5.1

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

@@ -9,24 +9,23 @@ import com.hypertrack.sdk.android.Result
  * to Map<String, T> or List<T> where T is any JSON-compatible type
  */
 internal object Serialization {
-    fun deserializeDynamicPublishableKey(args: Serialized): WrapperResult<String> {
-        return parse(args) {
+    fun deserializeDynamicPublishableKey(args: Serialized): WrapperResult<String> =
+        parse(args) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_DYNAMIC_PUBLISHABLE_KEY)
             it
                 .get<String>(KEY_VALUE)
                 .getOrThrow()
         }
-    }
 
-    fun deserializeGeotagData(map: Map<String, Any?>): WrapperResult<GeotagData> {
-        return parse(map) {
+    fun deserializeGeotagData(map: Serialized): WrapperResult<GeotagData> =
+        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 +33,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(
@@ -49,69 +48,61 @@ internal object Serialization {
                 orderStatus = orderStatus,
             )
         }
-    }
 
-    fun deserializeIsAvailable(isAvailable: Map<String, Any?>): WrapperResult<Boolean> {
-        return parse(isAvailable) {
+    fun deserializeIsAvailable(isAvailable: Serialized): WrapperResult<Boolean> =
+        parse(isAvailable) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_IS_AVAILABLE)
             it
                 .get<Boolean>(KEY_VALUE)
                 .getOrThrow()
         }
-    }
 
-    fun deserializeIsTracking(isTracking: Map<String, Any?>): WrapperResult<Boolean> {
-        return parse(isTracking) {
+    fun deserializeIsTracking(isTracking: Serialized): WrapperResult<Boolean> =
+        parse(isTracking) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_IS_TRACKING)
             it
                 .get<Boolean>(KEY_VALUE)
                 .getOrThrow()
         }
-    }
 
-    fun deserializeMetadata(metadata: Map<String, Any?>): WrapperResult<Map<String, Any?>> {
-        return parse(metadata) {
+    fun deserializeMetadata(metadata: Serialized): WrapperResult<Serialized> =
+        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> {
-        return parse(name) {
+    fun deserializeName(name: Serialized): WrapperResult<String> =
+        parse(name) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_NAME)
             it
                 .get<String>(KEY_VALUE)
                 .getOrThrow()
         }
-    }
 
-    fun deserializeWorkerHandle(map: Map<String, Any?>): WrapperResult<String> {
-        return parse(map) {
+    fun deserializeWorkerHandle(map: Serialized): WrapperResult<String> =
+        parse(map) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_WORKER_HANDLE)
             it
                 .get<String>(KEY_VALUE)
                 .getOrThrow()
         }
-    }
 
-    fun serializeDeviceId(deviceId: String): Map<String, Any?> {
-        return mapOf(
+    fun serializeDeviceId(deviceId: String): Serialized =
+        mapOf(
             KEY_TYPE to TYPE_DEVICE_ID,
             KEY_VALUE to deviceId,
         )
-    }
 
-    fun serializeDynamicPublishableKey(publishableKey: String): Serialized {
-        return mapOf(
+    fun serializeDynamicPublishableKey(publishableKey: String): Serialized =
+        mapOf(
             KEY_TYPE to TYPE_DYNAMIC_PUBLISHABLE_KEY,
             KEY_VALUE to publishableKey,
         )
-    }
 
-    fun serializeError(error: HyperTrack.Error): Map<String, String> {
-        return mapOf(
+    fun serializeError(error: HyperTrack.Error): Map<String, String> =
+        mapOf(
             KEY_TYPE to TYPE_ERROR,
             KEY_VALUE to
                 when (error) {
@@ -128,30 +119,26 @@ internal object Serialization {
                     HyperTrack.Error.Permissions.Notifications.Denied -> "permissions.notifications.denied"
                 },
         )
-    }
 
-    fun serializeErrors(errors: Set<HyperTrack.Error>): List<Map<String, String>> {
-        return errors.map {
+    fun serializeErrors(errors: Set<HyperTrack.Error>): List<Map<String, String>> =
+        errors.map {
             serializeError(it)
         }
-    }
 
-    fun serializeIsAvailable(isAvailable: Boolean): Map<String, Any?> {
-        return mapOf(
+    fun serializeIsAvailable(isAvailable: Boolean): Serialized =
+        mapOf(
             KEY_TYPE to TYPE_IS_AVAILABLE,
             KEY_VALUE to isAvailable,
         )
-    }
 
-    fun serializeIsTracking(isTracking: Boolean): Map<String, Any?> {
-        return mapOf(
+    fun serializeIsTracking(isTracking: Boolean): Serialized =
+        mapOf(
             KEY_TYPE to TYPE_IS_TRACKING,
             KEY_VALUE to isTracking,
         )
-    }
 
-    fun serializeLocateResult(locationResult: Result<HyperTrack.Location, Set<HyperTrack.Error>>): Map<String, Any?> {
-        return when (locationResult) {
+    fun serializeLocateResult(locationResult: Result<HyperTrack.Location, Set<HyperTrack.Error>>): Serialized =
+        when (locationResult) {
             is Result.Failure -> {
                 serializeFailure(serializeErrors(locationResult.failure))
             }
@@ -160,10 +147,9 @@ internal object Serialization {
                 serializeLocationSuccess(locationResult.success)
             }
         }
-    }
 
-    fun serializeLocationResult(locationResult: Result<HyperTrack.Location, HyperTrack.LocationError>): Map<String, Any?> {
-        return when (locationResult) {
+    fun serializeLocationResult(locationResult: Result<HyperTrack.Location, HyperTrack.LocationError>): Serialized =
+        when (locationResult) {
             is Result.Failure -> {
                 serializeLocationErrorFailure(locationResult.failure)
             }
@@ -172,62 +158,56 @@ internal object Serialization {
                 serializeLocationSuccess(locationResult.success)
             }
         }
-    }
 
-    fun serializeLocationErrorFailure(locationError: HyperTrack.LocationError): Map<String, Any?> {
-        return serializeFailure(serializeLocationError(locationError))
-    }
+    fun serializeLocationErrorFailure(locationError: HyperTrack.LocationError): Serialized =
+        serializeFailure(serializeLocationError(locationError))
 
-    fun serializeLocationSuccess(location: HyperTrack.Location): Map<String, Any?> {
-        return serializeSuccess(serializeLocation(location))
-    }
+    fun serializeLocationSuccess(location: HyperTrack.Location): Serialized = serializeSuccess(serializeLocation(location))
 
-    fun serializeLocationWithDeviationSuccess(locationWithDeviation: HyperTrack.LocationWithDeviation): Map<String, Any?> {
-        return serializeSuccess(
+    fun serializeLocationWithDeviationSuccess(locationWithDeviation: HyperTrack.LocationWithDeviation): Serialized =
+        serializeSuccess(
             serializeLocationWithDeviation(
                 locationWithDeviation,
             ),
         )
-    }
 
-    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?> {
-        return mapOf(
+    fun serializeMetadata(metadata: Serialized): Serialized =
+        mapOf(
             KEY_TYPE to TYPE_METADATA,
             KEY_VALUE to metadata,
         )
-    }
 
-    fun serializeName(name: String): Map<String, Any?> {
-        return mapOf(
+    fun serializeName(name: String): Serialized =
+        mapOf(
             KEY_TYPE to TYPE_NAME,
             KEY_VALUE to name,
         )
-    }
 
-    fun serializeWorkerHandle(workerHandle: String): Map<String, Any?> {
-        return mapOf(
+    fun serializeOrders(orders: Collection<HyperTrack.Order>): Serialized =
+        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 =
+        mapOf(
             KEY_TYPE to TYPE_WORKER_HANDLE,
             KEY_VALUE to workerHandle,
         )
-    }
 
-    private fun deserializeLocation(map: Map<String, Any?>): WrapperResult<Location> {
-        return parse(map) {
+    private fun deserializeLocation(map: Serialized): WrapperResult<Location> =
+        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 =
@@ -244,19 +224,17 @@ internal object Serialization {
                 }
             }.getOrThrow()
         }
-    }
 
-    private fun deserializeOrderHandle(map: Map<String, Any?>): WrapperResult<String> {
-        return parse(map) {
+    private fun deserializeOrderHandle(map: Serialized): WrapperResult<String> =
+        parse(map) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_ORDER_HANDLE)
             it
                 .get<String>(KEY_VALUE)
                 .getOrThrow()
         }
-    }
 
-    private fun deserializeOrderStatus(map: Map<String, Any?>): WrapperResult<HyperTrack.OrderStatus> {
-        return parse(map) {
+    private fun deserializeOrderStatus(map: Serialized): WrapperResult<HyperTrack.OrderStatus> =
+        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
@@ -268,10 +246,35 @@ internal object Serialization {
                 else -> throw Error("Unknown order status: $map")
             }
         }
-    }
 
-    private fun serializeLocationWithDeviation(locationWithDeviation: HyperTrack.LocationWithDeviation): Map<String, Any?> {
-        return mapOf(
+    private fun serializeIsInsideGeofence(isInsideGeofence: Result<Boolean, HyperTrack.LocationError>): Serialized =
+        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 =
+        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 =
+        mapOf(
             KEY_TYPE to TYPE_LOCATION_WITH_DEVIATION,
             KEY_VALUE to
                 mapOf(
@@ -279,31 +282,27 @@ internal object Serialization {
                     KEY_DEVIATION to locationWithDeviation.deviation,
                 ),
         )
-    }
 
-    private fun serializeFailure(failure: List<Map<String, Any?>>): Map<String, Any?> {
-        return mapOf(
+    private fun serializeFailure(failure: List<Serialized>): Serialized =
+        mapOf(
             KEY_TYPE to TYPE_RESULT_FAILURE,
             KEY_VALUE to failure,
         )
-    }
 
-    private fun serializeFailure(failure: Map<String, Any?>): Map<String, Any?> {
-        return mapOf(
+    private fun serializeFailure(failure: Serialized): Serialized =
+        mapOf(
             KEY_TYPE to TYPE_RESULT_FAILURE,
             KEY_VALUE to failure,
         )
-    }
 
-    private fun serializeSuccess(success: Map<String, Any?>): Map<String, Any?> {
-        return mapOf(
+    private fun serializeSuccess(success: Serialized): Serialized =
+        mapOf(
             KEY_TYPE to TYPE_RESULT_SUCCESS,
             KEY_VALUE to success,
         )
-    }
 
-    private fun serializeLocationError(locationError: HyperTrack.LocationError): Map<String, Any?> {
-        return when (locationError) {
+    private fun serializeLocationError(locationError: HyperTrack.LocationError): Serialized =
+        when (locationError) {
             HyperTrack.LocationError.NotRunning -> {
                 mapOf(KEY_TYPE to TYPE_LOCATION_ERROR_NOT_RUNNING)
             }
@@ -321,10 +320,9 @@ internal object Serialization {
                 )
             }
         }
-    }
 
     fun <T> parse(
-        source: Map<String, Any?>,
+        source: Serialized,
         parseFunction: (Parser) -> T,
     ): WrapperResult<T> {
         val parser = Parser(source)
@@ -346,13 +344,13 @@ 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
 
-        inline fun <reified T> get(key: String): WrapperResult<T> {
-            return try {
+        inline fun <reified T> get(key: String): WrapperResult<T> =
+            try {
                 Success(source[key]!! as T)
             } catch (e: Exception) {
                 Failure(
@@ -362,10 +360,9 @@ internal object Serialization {
                         },
                 )
             }
-        }
 
-        inline fun <reified T> getOptional(key: String): WrapperResult<T?> {
-            return try {
+        inline fun <reified T> getOptional(key: String): WrapperResult<T?> =
+            try {
                 Success(source[key] as T?)
             } catch (e: Exception) {
                 Failure(
@@ -375,7 +372,6 @@ internal object Serialization {
                         },
                 )
             }
-        }
 
         inline fun <reified T> assertValue(
             key: String,
@@ -391,7 +387,8 @@ internal object Serialization {
         val source: Any,
         val exceptions: List<Exception>,
     ) : Throwable(
-            exceptions.joinToString("\n")
+            exceptions
+                .joinToString("\n")
                 .let {
                     "Invalid input:\n\n${source}\n\n$it"
                 },
@@ -412,11 +409,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 +435,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/android/src/main/java/com/reactnativehypertracksdk/common/WrapperResult.kt

@@ -1,8 +1,8 @@
 package com.reactnativehypertracksdk.common
 
 internal sealed class WrapperResult<SuccessType> {
-    fun <MappedSuccess> flatMapSuccess(onSuccess: (SuccessType) -> WrapperResult<MappedSuccess>): WrapperResult<MappedSuccess> {
-        return when (this) {
+    fun <MappedSuccess> flatMapSuccess(onSuccess: (SuccessType) -> WrapperResult<MappedSuccess>): WrapperResult<MappedSuccess> =
+        when (this) {
             is Success -> {
                 onSuccess.invoke(this.success)
             }
@@ -11,10 +11,9 @@ internal sealed class WrapperResult<SuccessType> {
                 Failure<MappedSuccess>(this.failure)
             }
         }
-    }
 
-    fun <MappedSuccess> mapSuccess(onSuccess: (SuccessType) -> MappedSuccess): WrapperResult<MappedSuccess> {
-        return when (this) {
+    fun <MappedSuccess> mapSuccess(onSuccess: (SuccessType) -> MappedSuccess): WrapperResult<MappedSuccess> =
+        when (this) {
             is Success -> {
                 Success(onSuccess.invoke(this.success))
             }
@@ -23,29 +22,30 @@ internal sealed class WrapperResult<SuccessType> {
                 Failure<MappedSuccess>(this.failure)
             }
         }
-    }
 
-    fun getOrThrow(): SuccessType {
-        return when (this) {
+    fun getOrThrow(): SuccessType =
+        when (this) {
             is Success -> this.success
             is Failure -> throw Exception(
                 "Result unwrapping failed: ${this.failure}",
                 this.failure,
             )
         }
-    }
 
     companion object {
-        fun <SuccessType> tryAsResult(block: () -> SuccessType): WrapperResult<SuccessType> {
-            return try {
+        fun <SuccessType> tryAsResult(block: () -> SuccessType): WrapperResult<SuccessType> =
+            try {
                 Success(block.invoke())
             } catch (e: Exception) {
                 Failure(e)
             }
-        }
     }
 }
 
-internal data class Success<SuccessType>(val success: SuccessType) : WrapperResult<SuccessType>()
+internal data class Success<SuccessType>(
+    val success: SuccessType,
+) : WrapperResult<SuccessType>()
 
-internal data class Failure<SuccessType>(val failure: Throwable) : WrapperResult<SuccessType>()
+internal data class Failure<SuccessType>(
+    val failure: Throwable,
+) : WrapperResult<SuccessType>()

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,