hypertrack-sdk-react-native 13.3.5 → 13.5.0

package/android/gradle.properties

@@ -1,3 +1,3 @@
 HyperTrackSdk_kotlinVersion=1.6.21
-HyperTrackSdk_HyperTrackSDKVersion=7.5.5
+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,16 @@ 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)
+    }
+
     @ReactMethod
     fun locate(promise: Promise) {
         locateSubscription?.cancel()
@@ -146,6 +176,11 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
         HyperTrackSdkWrapper.setName(args.toHashMap())
     }
 
+    @ReactMethod
+    fun setWorkerHandle(args: ReadableMap) {
+        HyperTrackSdkWrapper.setWorkerHandle(args.toHashMap())
+    }
+
     private fun initListeners(): List<HyperTrack.Cancellable> {
         return mutableListOf<HyperTrack.Cancellable>().also { result ->
             HyperTrack.subscribeToErrors {
@@ -171,6 +206,12 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
             }.also {
                 result.add(it)
             }
+
+            HyperTrack.subscribeToOrders {
+                emitEvent(EVENT_ORDERS, serializeOrders(it.values).toWritableMap())
+            }.also {
+                result.add(it)
+            }
         }
     }
 
@@ -199,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

@@ -9,6 +9,7 @@ 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.deserializeWorkerHandle
 import com.reactnativehypertracksdk.common.Serialization.serializeDeviceId
 import com.reactnativehypertracksdk.common.Serialization.serializeDynamicPublishableKey
 import com.reactnativehypertracksdk.common.Serialization.serializeErrors
@@ -20,6 +21,8 @@ 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?>
 
@@ -137,6 +140,18 @@ internal object HyperTrackSdkWrapper {
         )
     }
 
+    fun getOrders(): WrapperResult<Serialized> {
+        return Success(
+            serializeOrders(HyperTrack.orders.values),
+        )
+    }
+
+    fun getWorkerHandle(): WrapperResult<Serialized> {
+        return Success(
+            serializeWorkerHandle(HyperTrack.workerHandle),
+        )
+    }
+
     fun setDynamicPublishableKey(args: Serialized): WrapperResult<Unit> {
         return deserializeDynamicPublishableKey(args)
             .mapSuccess { publishableKey ->
@@ -174,4 +189,11 @@ internal object HyperTrackSdkWrapper {
                 HyperTrack.name = name
             }
     }
+
+    fun setWorkerHandle(args: Serialized): WrapperResult<Unit> {
+        return deserializeWorkerHandle(args)
+            .mapSuccess { workerHandle ->
+                HyperTrack.workerHandle = workerHandle
+            }
+    }
 }

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

@@ -16,10 +16,13 @@ internal enum class SdkMethod {
     getLocation,
     getMetadata,
     getName,
+    getOrders,
+    getWorkerHandle,
     locate,
     setDynamicPublishableKey,
     setIsAvailable,
     setIsTracking,
     setMetadata,
     setName,
+    setWorkerHandle,
 }

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,16 @@ internal object Serialization {
         }
     }
 
-    fun serializeDeviceId(deviceId: String): Map<String, Any?> {
+    fun deserializeWorkerHandle(map: Serialized): WrapperResult<String> {
+        return parse(map) {
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_WORKER_HANDLE)
+            it
+                .get<String>(KEY_VALUE)
+                .getOrThrow()
+        }
+    }
+
+    fun serializeDeviceId(deviceId: String): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_DEVICE_ID,
             KEY_VALUE to deviceId,
@@ -127,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))
@@ -153,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)
@@ -165,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,
@@ -181,37 +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,
         )
     }
 
-    private fun deserializeLocation(map: Map<String, Any?>): WrapperResult<Location> {
+    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: 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 =
@@ -230,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
@@ -239,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
@@ -254,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
@@ -265,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)
@@ -308,7 +355,7 @@ internal object Serialization {
     }
 
     fun <T> parse(
-        source: Map<String, Any?>,
+        source: Serialized,
         parseFunction: (Parser) -> T,
     ): WrapperResult<T> {
         val parser = Parser(source)
@@ -330,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
@@ -396,11 +443,14 @@ 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_METADATA = "metadata"
-    private const val TYPE_NAME = "name"
     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"
     private const val TYPE_LOCATION_ERROR_NOT_RUNNING = "notRunning"
@@ -419,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,6 +37,12 @@ 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)
+
 RCT_EXTERN_METHOD(locate:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
@@ -60,4 +66,8 @@ RCT_EXTERN_METHOD(setName:(NSDictionary *)args
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(setWorkerHandle:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 @end

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,30 @@ 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
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.getWorkerHandle(),
+            method: .getWorkerHandle,
+            resolve,
+            reject
+        )
+    }
+
     @objc func locate(
         _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
@@ -216,6 +245,21 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
         )
     }
 
+    @objc func setIsTracking(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.setIsTracking(
+                args as! [String: Any]
+            ),
+            method: .setIsTracking,
+            resolve,
+            reject
+        )
+    }
+
     @objc func setMetadata(
         _ args: NSDictionary,
         resolver resolve: RCTPromiseResolveBlock,
@@ -244,16 +288,16 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
         )
     }
 
-    @objc func setIsTracking(
+    @objc func setWorkerHandle(
         _ args: NSDictionary,
         resolver resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
         sendAsPromise(
-            hypertrack_sdk_react_native.setIsTracking(
+            hypertrack_sdk_react_native.setWorkerHandle(
                 args as! [String: Any]
             ),
-            method: .setIsTracking,
+            method: .setWorkerHandle,
             resolve,
             reject
         )
@@ -272,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)
     }
 }