hypertrack-sdk-react-native 13.7.1 → 14.0.0

package/android/gradle.properties

@@ -1,3 +1,3 @@
 HyperTrackSdk_kotlinVersion=1.6.21
-HyperTrackSdk_HyperTrackSDKVersion=7.9.1
+HyperTrackSdk_HyperTrackSDKVersion=7.11.0
 android.useAndroidX=true

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

@@ -90,6 +90,11 @@ class HyperTrackReactNativePlugin(
         HyperTrackSdkWrapper.addGeotag(args.toHashMap()).toPromise(promise)
     }
 
+    @ReactMethod
+    fun getAllowMockLocation(promise: Promise) {
+        HyperTrackSdkWrapper.getAllowMockLocation().toPromise(promise)
+    }
+
     @ReactMethod
     fun getDeviceId(promise: Promise) {
         HyperTrackSdkWrapper.getDeviceId().toPromise(promise)
@@ -130,6 +135,14 @@ class HyperTrackReactNativePlugin(
         HyperTrackSdkWrapper.getName().toPromise(promise)
     }
 
+    @ReactMethod
+    fun getOrderIsInsideGeofence(
+        args: ReadableMap,
+        promise: Promise,
+    ) {
+        HyperTrackSdkWrapper.getOrderIsInsideGeofence(args.toHashMap()).toPromise(promise)
+    }
+
     @ReactMethod
     fun getOrders(promise: Promise) {
         HyperTrackSdkWrapper.getOrders().toPromise(promise)
@@ -150,6 +163,11 @@ class HyperTrackReactNativePlugin(
         Success(Unit).toPromise(promise)
     }
 
+    @ReactMethod
+    fun setAllowMockLocation(args: ReadableMap) {
+        HyperTrackSdkWrapper.setAllowMockLocation(args.toHashMap())
+    }
+
     @ReactMethod
     fun setDynamicPublishableKey(args: ReadableMap) {
         HyperTrackSdkWrapper.setDynamicPublishableKey(args.toHashMap())

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

@@ -3,17 +3,21 @@ package com.reactnativehypertracksdk.common
 import com.hypertrack.sdk.android.HyperTrack
 import com.hypertrack.sdk.android.Json
 import com.hypertrack.sdk.android.Result
+import com.reactnativehypertracksdk.common.Serialization.deserializeAllowMockLocation
 import com.reactnativehypertracksdk.common.Serialization.deserializeDynamicPublishableKey
 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.deserializeOrderHandle
 import com.reactnativehypertracksdk.common.Serialization.deserializeWorkerHandle
+import com.reactnativehypertracksdk.common.Serialization.serializeAllowMockLocation
 import com.reactnativehypertracksdk.common.Serialization.serializeDeviceId
 import com.reactnativehypertracksdk.common.Serialization.serializeDynamicPublishableKey
 import com.reactnativehypertracksdk.common.Serialization.serializeErrors
 import com.reactnativehypertracksdk.common.Serialization.serializeIsAvailable
+import com.reactnativehypertracksdk.common.Serialization.serializeIsInsideGeofence
 import com.reactnativehypertracksdk.common.Serialization.serializeIsTracking
 import com.reactnativehypertracksdk.common.Serialization.serializeLocationErrorFailure
 import com.reactnativehypertracksdk.common.Serialization.serializeLocationResult
@@ -89,6 +93,8 @@ internal object HyperTrackSdkWrapper {
                 }
             }
 
+    fun getAllowMockLocation(): WrapperResult<Serialized> = Success(serializeAllowMockLocation(HyperTrack.allowMockLocation))
+
     fun getDeviceId(): WrapperResult<Serialized> = Success(serializeDeviceId(HyperTrack.deviceID))
 
     fun getDynamicPublishableKey(): WrapperResult<Serialized> = Success(serializeDynamicPublishableKey(HyperTrack.dynamicPublishableKey))
@@ -130,11 +136,31 @@ internal object HyperTrackSdkWrapper {
             serializeOrders(HyperTrack.orders.values),
         )
 
+    fun getOrderIsInsideGeofence(args: Serialized): WrapperResult<Serialized> =
+        deserializeOrderHandle(args)
+            .mapSuccess { orderHandle ->
+                HyperTrack
+                    .orders
+                    .values
+                    .firstOrNull { it.orderHandle == orderHandle }
+                    .let { order ->
+                        order?.isInsideGeofence ?: Result.Success(false)
+                    }.let {
+                        serializeIsInsideGeofence(it)
+                    }
+            }
+
     fun getWorkerHandle(): WrapperResult<Serialized> =
         Success(
             serializeWorkerHandle(HyperTrack.workerHandle),
         )
 
+    fun setAllowMockLocation(args: Serialized): WrapperResult<Unit> =
+        deserializeAllowMockLocation(args)
+            .mapSuccess { allowMockLocation ->
+                HyperTrack.allowMockLocation = allowMockLocation
+            }
+
     fun setDynamicPublishableKey(args: Serialized): WrapperResult<Unit> =
         deserializeDynamicPublishableKey(args)
             .mapSuccess { publishableKey ->

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

@@ -8,6 +8,7 @@ package com.reactnativehypertracksdk.common
  */
 internal enum class SdkMethod {
     addGeotag,
+    getAllowMockLocation,
     getDeviceID,
     getDynamicPublishableKey,
     getErrors,
@@ -16,9 +17,11 @@ internal enum class SdkMethod {
     getLocation,
     getMetadata,
     getName,
+    getOrderIsInsideGeofence,
     getOrders,
     getWorkerHandle,
     locate,
+    setAllowMockLocation,
     setDynamicPublishableKey,
     setIsAvailable,
     setIsTracking,

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

@@ -9,6 +9,14 @@ import com.hypertrack.sdk.android.Result
  * to Map<String, T> or List<T> where T is any JSON-compatible type
  */
 internal object Serialization {
+    fun deserializeAllowMockLocation(allowMockLocation: Serialized): WrapperResult<Boolean> =
+        parse(allowMockLocation) {
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_ALLOW_MOCK_LOCATION)
+            it
+                .get<Boolean>(KEY_VALUE)
+                .getOrThrow()
+        }
+
     fun deserializeDynamicPublishableKey(args: Serialized): WrapperResult<String> =
         parse(args) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_DYNAMIC_PUBLISHABLE_KEY)
@@ -81,6 +89,14 @@ internal object Serialization {
                 .getOrThrow()
         }
 
+    fun deserializeOrderHandle(map: Serialized): WrapperResult<String> =
+        parse(map) {
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_ORDER_HANDLE)
+            it
+                .get<String>(KEY_VALUE)
+                .getOrThrow()
+        }
+
     fun deserializeWorkerHandle(map: Serialized): WrapperResult<String> =
         parse(map) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_WORKER_HANDLE)
@@ -89,6 +105,12 @@ internal object Serialization {
                 .getOrThrow()
         }
 
+    fun serializeAllowMockLocation(allowMockLocation: Boolean): Serialized =
+        mapOf(
+            KEY_TYPE to TYPE_ALLOW_MOCK_LOCATION,
+            KEY_VALUE to allowMockLocation,
+        )
+
     fun serializeDeviceId(deviceId: String): Serialized =
         mapOf(
             KEY_TYPE to TYPE_DEVICE_ID,
@@ -125,12 +147,40 @@ internal object Serialization {
             serializeError(it)
         }
 
+    fun serializeFailure(failure: List<Serialized>): Serialized =
+        mapOf(
+            KEY_TYPE to TYPE_RESULT_FAILURE,
+            KEY_VALUE to failure,
+        )
+
+    fun serializeFailure(failure: Serialized): Serialized =
+        mapOf(
+            KEY_TYPE to TYPE_RESULT_FAILURE,
+            KEY_VALUE to failure,
+        )
+
     fun serializeIsAvailable(isAvailable: Boolean): Serialized =
         mapOf(
             KEY_TYPE to TYPE_IS_AVAILABLE,
             KEY_VALUE to isAvailable,
         )
 
+    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,
+                    ),
+                )
+            }
+        }
+
     fun serializeIsTracking(isTracking: Boolean): Serialized =
         mapOf(
             KEY_TYPE to TYPE_IS_TRACKING,
@@ -190,11 +240,17 @@ internal object Serialization {
                     mapOf(
                         KEY_ORDER_HANDLE to order.orderHandle,
                         KEY_ORDER_INDEX to index,
-                        KEY_ORDER_IS_INSIDE_GEOFENCE to serializeIsInsideGeofence(order.isInsideGeofence),
+                        // beware not to call isInsideGeofence here, it's a computed property
                     )
                 },
         )
 
+    fun serializeSuccess(success: Serialized): Serialized =
+        mapOf(
+            KEY_TYPE to TYPE_RESULT_SUCCESS,
+            KEY_VALUE to success,
+        )
+
     fun serializeWorkerHandle(workerHandle: String): Serialized =
         mapOf(
             KEY_TYPE to TYPE_WORKER_HANDLE,
@@ -224,14 +280,6 @@ internal object Serialization {
             }.getOrThrow()
         }
 
-    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: Serialized): WrapperResult<HyperTrack.OrderStatus> =
         parse(map) {
             when (it.get<String>(KEY_TYPE).getOrThrow()) {
@@ -246,22 +294,6 @@ internal object Serialization {
             }
         }
 
-    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,
@@ -282,24 +314,6 @@ internal object Serialization {
                 ),
         )
 
-    private fun serializeFailure(failure: List<Serialized>): Serialized =
-        mapOf(
-            KEY_TYPE to TYPE_RESULT_FAILURE,
-            KEY_VALUE to failure,
-        )
-
-    private fun serializeFailure(failure: Serialized): Serialized =
-        mapOf(
-            KEY_TYPE to TYPE_RESULT_FAILURE,
-            KEY_VALUE to failure,
-        )
-
-    private fun serializeSuccess(success: Serialized): Serialized =
-        mapOf(
-            KEY_TYPE to TYPE_RESULT_SUCCESS,
-            KEY_VALUE to success,
-        )
-
     private fun serializeLocationError(locationError: HyperTrack.LocationError): Serialized =
         when (locationError) {
             HyperTrack.LocationError.NotRunning -> {
@@ -404,6 +418,7 @@ internal object Serialization {
     private const val TYPE_RESULT_FAILURE = "failure"
     private const val TYPE_RESULT_SUCCESS = "success"
 
+    private const val TYPE_ALLOW_MOCK_LOCATION = "allowMockLocation"
     private const val TYPE_DEVICE_ID = "deviceID"
     private const val TYPE_DYNAMIC_PUBLISHABLE_KEY = "dynamicPublishableKey"
     private const val TYPE_ERROR = "error"
@@ -434,8 +449,7 @@ 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"
+    private const val KEY_ORDER_INDEX = "index"
 }

package/hypertrack-sdk-react-native.podspec

@@ -17,7 +17,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency 'HyperTrack', '5.9.1'
+  s.dependency 'HyperTrack', '5.11.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

@@ -13,6 +13,9 @@ RCT_EXTERN_METHOD(addGeotag:(NSDictionary *)args
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(getAllowMockLocation:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(getDeviceId:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
@@ -37,6 +40,10 @@ RCT_EXTERN_METHOD(getMetadata:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(getName:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(getOrderIsInsideGeofence:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(getOrders:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
@@ -46,6 +53,10 @@ RCT_EXTERN_METHOD(getWorkerHandle:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(locate:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(setAllowMockLocation:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(setDynamicPublishableKey:(NSDictionary *)args
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)

package/ios/HyperTrackReactNativePlugin.swift

@@ -77,6 +77,18 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
         )
     }
 
+    @objc func getAllowMockLocation(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.getAllowMockLocation(),
+            method: .getAllowMockLocation,
+            resolve,
+            reject
+        )
+    }
+
     @objc func getDeviceId(
         _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
@@ -173,6 +185,21 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
         )
     }
 
+    @objc func getOrderIsInsideGeofence(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.getOrderIsInsideGeofence(
+                args as! [String: Any]
+            ),
+            method: .getOrderIsInsideGeofence,
+            resolve,
+            reject
+        )
+    }
+
     @objc func getOrders(
         _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
@@ -215,6 +242,21 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
         )
     }
 
+    @objc func setAllowMockLocation(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.setAllowMockLocation(
+                args as! [String: Any]
+            ),
+            method: .setAllowMockLocation,
+            resolve,
+            reject
+        )
+    }
+
     @objc func setDynamicPublishableKey(
         _ args: NSDictionary,
         resolver resolve: RCTPromiseResolveBlock,

package/ios/common/HyperTrackSDKWrapper.swift

@@ -56,6 +56,10 @@ func addGeotag(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
     }
 }
 
+func getAllowMockLocation() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeAllowMockLocation(HyperTrack.allowMockLocation)))
+}
+
 func getDeviceID() -> Result<SuccessResult, FailureResult> {
     .success(.dict(serializeDeviceID(HyperTrack.deviceID)))
 }
@@ -88,6 +92,16 @@ func getName() -> Result<SuccessResult, FailureResult> {
     .success(.dict(serializeName(HyperTrack.name)))
 }
 
+func getOrderIsInsideGeofence(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
+    deserializeOrderHandle(args).flatMap { orderHandle in
+        if let order = HyperTrack.orders.first(where: { $0.orderHandle == orderHandle }) {
+            return .success(.dict(serializeIsInsideGeofence(order.isInsideGeofence)))
+        } else {
+            return .success(.dict(serializeIsInsideGeofence(.success(false))))
+        }
+    }
+}
+
 func getOrders() -> Result<SuccessResult, FailureResult> {
     .success(.dict(serializeOrders(Array(HyperTrack.orders))))
 }
@@ -96,6 +110,13 @@ func getWorkerHandle() -> Result<SuccessResult, FailureResult> {
     .success(.dict(serializeWorkerHandle(HyperTrack.workerHandle)))
 }
 
+func setAllowMockLocation(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
+    deserializeAllowMockLocation(args).flatMap { (allowMockLocation: Bool) in
+        HyperTrack.allowMockLocation = allowMockLocation
+        return .success(.void)
+    }
+}
+
 func setDynamicPublishableKey(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
     deserializeDynamicPublishableKey(args).flatMap { (dynamicPublishableKey: String) in
         HyperTrack.dynamicPublishableKey = dynamicPublishableKey

package/ios/common/SDKMethod.swift

@@ -1,5 +1,6 @@
 enum SDKMethod: String {
     case addGeotag
+    case getAllowMockLocation
     case getDeviceID
     case getDynamicPublishableKey
     case getErrors
@@ -8,9 +9,11 @@ enum SDKMethod: String {
     case getLocation
     case getMetadata
     case getName
+    case getOrderIsInsideGeofence
     case getOrders
     case getWorkerHandle
     case locate
+    case setAllowMockLocation
     case setDynamicPublishableKey
     case setIsAvailable
     case setIsTracking

package/ios/common/Serialization.swift

@@ -5,6 +5,7 @@ private let keyGeotagData = "data"
 private let keyType = "type"
 private let keyValue = "value"
 
+private let typeAllowMockLocation = "allowMockLocation"
 private let typeError = "error"
 private let typeFailure = "failure"
 private let typeIsAvailable = "isAvailable"
@@ -15,6 +16,18 @@ private let typeName = "name"
 private let typeSuccess = "success"
 private let typeWorkerHandle = "workerHandle"
 
+func deserializeAllowMockLocation(
+    _ args: [String: Any]
+) -> Result<Bool, FailureResult> {
+    if args[keyType] as? String != typeAllowMockLocation {
+        return .failure(.fatalError(getParseError(args, key: keyType)))
+    }
+    guard let value = args[keyValue] as? Bool else {
+        return .failure(.fatalError(getParseError(args, key: keyValue)))
+    }
+    return .success(value)
+}
+
 func deserializeDynamicPublishableKey(
     _ args: [String: Any]
 ) -> Result<String, FailureResult> {
@@ -181,6 +194,13 @@ func deserializeWorkerHandle(_ data: [String: Any]) -> Result<String, FailureRes
     return .success(value)
 }
 
+func serializeAllowMockLocation(_ allowMockLocation: Bool) -> [String: Any] {
+    return [
+        keyType: typeAllowMockLocation,
+        keyValue: allowMockLocation,
+    ]
+}
+
 func serializeDeviceID(_ deviceID: String) -> [String: Any] {
     return [
         keyType: "deviceID",
@@ -379,10 +399,11 @@ func serializeName(_ name: String) -> [String: Any] {
 func serializeOrders(_ orders: [HyperTrack.Order]) -> [String: Any] {
     return [
         keyType: "orders",
-        keyValue: orders.map { order in
+        keyValue: orders.enumerated().map { (index, order) in
             [
+                "index": index,
                 "orderHandle": order.orderHandle,
-                "isInsideGeofence": serializeIsInsideGeofence(order.isInsideGeofence),
+                // beware not to call order.isInsideGeofence here, it is a computed property
             ]
         },
     ]

package/lib/commonjs/HyperTrack/HyperTrack.js

@@ -124,6 +124,17 @@ class HyperTrack {
     throw new Error(`Invalid addGeotag() arguments: ${JSON.stringify(args)}`);
   }
 
+  /**
+   * If disallowed, the HyperTrack platform will display and outage if mocked location is detected.
+   *
+   * @param {boolean} true if mock location is allowed
+   */
+  static async getAllowMockLocation() {
+    return HyperTrackSdk.getAllowMockLocation().then(allowMockLocation => {
+      return this.deserializeAllowMockLocation(allowMockLocation);
+    });
+  }
+
   /**
    * Returns a string that is used to uniquely identify the device
    *
@@ -197,7 +208,7 @@ class HyperTrack {
   }
 
   /**
-   * Gets the active orders for the worker. The orders are sorted with the ordering in 
+   * Gets the active orders for the worker. The orders are sorted with the ordering in
    * which the worker should complete them.
    *
    * @returns {Map<string, Order>} Map of orders
@@ -250,6 +261,23 @@ class HyperTrack {
     HyperTrackSdk.locate();
     return this.locateSubscription;
   }
+
+  /**
+   * Allows mocking location data.
+   *
+   * Check the [Test with mock locations](https://hypertrack.com/docs/mock-location) guide for more information.
+   *
+   * To avoid issues related to race conditions in your code use this API **only if** modifying the compiled `HyperTrackAllowMockLocation` AndroidManifest.xml/Info.plist value is insufficient for your needs.
+   * Example: if for some reason you aren't able to recompile with `HyperTrackAllowMockLocation` set to `YES`/`true` for your prod app QA mock location tests and need to set up the value in runtime.
+   *
+   * @param true if mock location is allowed
+   */
+  static async setAllowMockLocation(allow) {
+    HyperTrackSdk.setAllowMockLocation({
+      type: 'allowMockLocation',
+      value: allow
+    });
+  }
   static setDynamicPublishableKey(dynamicPublishableKey) {
     HyperTrackSdk.setDynamicPublishableKey({
       type: 'dynamicPublishableKey',
@@ -432,6 +460,14 @@ class HyperTrack {
     });
   }
 
+  /** @ignore */
+  static deserializeAllowMockLocation(allowMockLocation) {
+    if (allowMockLocation.type !== 'allowMockLocation') {
+      throw new Error(`Invalid allowMockLocation: ${JSON.stringify(allowMockLocation)}`);
+    }
+    return allowMockLocation.value;
+  }
+
   /** @ignore */
   static deserializeDynamicPublishableKey(dynamicPublishableKey) {
     if (dynamicPublishableKey.type !== 'dynamicPublishableKey') {
@@ -562,10 +598,21 @@ class HyperTrack {
     let result = new Map();
     Object.entries(orders.value).map(([_, value]) => {
       return value;
-    }).sort((first, second) => first.index - second.index).forEach(orderInternal => {
+    }).sort((first, second) => {
+      if (first.index === undefined || second.index === undefined) {
+        throw new Error(`Invalid order index: ${JSON.stringify(first)} ${JSON.stringify(second)}`);
+      }
+      return first.index - second.index;
+    }).forEach(orderInternal => {
       result.set(orderInternal.orderHandle, {
         orderHandle: orderInternal.orderHandle,
-        isInsideGeofence: this.deserializeIsInsideGeofence(orderInternal.isInsideGeofence)
+        isInsideGeofence: async () => {
+          const isInsideGeofence = await HyperTrackSdk.getOrderIsInsideGeofence({
+            type: 'orderHandle',
+            value: orderInternal.orderHandle
+          });
+          return this.deserializeIsInsideGeofence(isInsideGeofence);
+        }
       });
     });
     return result;