hypertrack-sdk-react-native 13.4.0 → 13.5.1

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,26 +1,32 @@
 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?) :
-    ReactContextBaseJavaModule(reactContext) {
+class HyperTrackReactNativePlugin(
+    reactContext: ReactApplicationContext?,
+) : ReactContextBaseJavaModule(reactContext) {
     private var locateSubscription: HyperTrack.Cancellable? = null
     private var subscriptions: List<HyperTrack.Cancellable>? = null
 
-    override fun getName(): String {
-        return NAME
-    }
+    override fun getName(): String = NAME
 
     /**
      * ReactNative built-in methods
@@ -40,15 +46,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 +130,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)
@@ -156,33 +180,43 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
         HyperTrackSdkWrapper.setWorkerHandle(args.toHashMap())
     }
 
-    private fun initListeners(): List<HyperTrack.Cancellable> {
-        return mutableListOf<HyperTrack.Cancellable>().also { result ->
-            HyperTrack.subscribeToErrors {
-                emitEvent(EVENT_ERRORS, serializeErrors(it).toWriteableArray())
-            }.also {
-                result.add(it)
-            }
-
-            HyperTrack.subscribeToIsAvailable {
-                emitEvent(EVENT_IS_AVAILABLE, serializeIsAvailable(it).toWritableMap())
-            }.also {
-                result.add(it)
-            }
-
-            HyperTrack.subscribeToIsTracking {
-                emitEvent(EVENT_IS_TRACKING, serializeIsTracking(it).toWritableMap())
-            }.also {
-                result.add(it)
-            }
-
-            HyperTrack.subscribeToLocation {
-                emitEvent(EVENT_LOCATION, serializeLocationResult(it).toWritableMap())
-            }.also {
-                result.add(it)
-            }
+    private fun initListeners(): List<HyperTrack.Cancellable> =
+        mutableListOf<HyperTrack.Cancellable>().also { result ->
+            HyperTrack
+                .subscribeToErrors {
+                    emitEvent(EVENT_ERRORS, serializeErrors(it).toWriteableArray())
+                }.also {
+                    result.add(it)
+                }
+
+            HyperTrack
+                .subscribeToIsAvailable {
+                    emitEvent(EVENT_IS_AVAILABLE, serializeIsAvailable(it).toWritableMap())
+                }.also {
+                    result.add(it)
+                }
+
+            HyperTrack
+                .subscribeToIsTracking {
+                    emitEvent(EVENT_IS_TRACKING, serializeIsTracking(it).toWritableMap())
+                }.also {
+                    result.add(it)
+                }
+
+            HyperTrack
+                .subscribeToLocation {
+                    emitEvent(EVENT_LOCATION, serializeLocationResult(it).toWritableMap())
+                }.also {
+                    result.add(it)
+                }
+
+            HyperTrack
+                .subscribeToOrders {
+                    emitEvent(EVENT_ORDERS, serializeOrders(it.values).toWritableMap())
+                }.also {
+                    result.add(it)
+                }
         }
-    }
 
     private fun emitEvent(
         event: String,
@@ -209,6 +243,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/HyperTrackSdkPackage.kt

@@ -5,11 +5,8 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
 class HyperTrackSdkPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
-        return listOf(HyperTrackReactNativePlugin(reactContext)).toMutableList()
-    }
+    override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> =
+        listOf(HyperTrackReactNativePlugin(reactContext)).toMutableList()
 
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
-    }
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
 }

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

@@ -60,8 +60,8 @@ internal fun <T> WrapperResult<T>.toPromise(promise: Promise) {
 }
 
 @Suppress("UNCHECKED_CAST")
-internal fun List<Any>.toWriteableArray(): WritableArray {
-    return Arguments.createArray().also { writableArray ->
+internal fun List<Any>.toWriteableArray(): WritableArray =
+    Arguments.createArray().also { writableArray ->
         forEach {
             when (it) {
                 is String -> {
@@ -78,7 +78,6 @@ internal fun List<Any>.toWriteableArray(): WritableArray {
             }
         }
     }
-}
 
 @Suppress("UNCHECKED_CAST")
 internal fun Map<String, Any?>.toWritableMap(): WritableMap {

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?>
@@ -30,8 +31,8 @@ typealias Serialized = Map<String, Any?>
  * It receives serialized params.
  */
 internal object HyperTrackSdkWrapper {
-    fun addGeotag(args: Serialized): WrapperResult<Serialized> {
-        return deserializeGeotagData(args)
+    fun addGeotag(args: Serialized): WrapperResult<Serialized> =
+        deserializeGeotagData(args)
             .flatMapSuccess { geotag ->
                 // TODO: return proper error if JSON is wrong
                 val geotagMetadata = Json.fromMap(geotag.data)!!
@@ -59,18 +60,17 @@ internal object HyperTrackSdkWrapper {
                         )
                     } else {
                         HyperTrack.addGeotag(geotagMetadata, expectedLocation)
-                    }
-                        .let {
-                            when (it) {
-                                is Result.Failure -> {
-                                    serializeLocationErrorFailure(it.failure)
-                                }
-
-                                is Result.Success -> {
-                                    serializeLocationWithDeviationSuccess(it.success)
-                                }
+                    }.let {
+                        when (it) {
+                            is Result.Failure -> {
+                                serializeLocationErrorFailure(it.failure)
+                            }
+
+                            is Result.Success -> {
+                                serializeLocationWithDeviationSuccess(it.success)
                             }
                         }
+                    }
                 } else {
                     if (orderHandle != null || orderStatus != null) {
                         if (orderHandle == null || orderStatus == null) {
@@ -83,110 +83,94 @@ internal object HyperTrackSdkWrapper {
                         )
                     } else {
                         HyperTrack.addGeotag(geotagMetadata)
-                    }
-                        .let { serializeLocationResult(it) }
+                    }.let { serializeLocationResult(it) }
                 }.let {
                     Success(it)
                 }
             }
-    }
 
-    fun getDeviceId(): WrapperResult<Serialized> {
-        return Success(serializeDeviceId(HyperTrack.deviceID))
-    }
+    fun getDeviceId(): WrapperResult<Serialized> = Success(serializeDeviceId(HyperTrack.deviceID))
 
-    fun getDynamicPublishableKey(): WrapperResult<Serialized> {
-        return Success(serializeDynamicPublishableKey(HyperTrack.dynamicPublishableKey))
-    }
+    fun getDynamicPublishableKey(): WrapperResult<Serialized> = Success(serializeDynamicPublishableKey(HyperTrack.dynamicPublishableKey))
 
-    fun getErrors(): WrapperResult<List<Serialized>> {
-        return Success(serializeErrors(HyperTrack.errors))
-    }
+    fun getErrors(): WrapperResult<List<Serialized>> = Success(serializeErrors(HyperTrack.errors))
 
-    fun getIsAvailable(): WrapperResult<Serialized> {
-        return Success(
+    fun getIsAvailable(): WrapperResult<Serialized> =
+        Success(
             serializeIsAvailable(HyperTrack.isAvailable),
         )
-    }
 
-    fun getIsTracking(): WrapperResult<Serialized> {
-        return Success(
+    fun getIsTracking(): WrapperResult<Serialized> =
+        Success(
             serializeIsTracking(HyperTrack.isTracking),
         )
-    }
 
-    fun getLocation(): WrapperResult<Serialized> {
-        return HyperTrack
+    fun getLocation(): WrapperResult<Serialized> =
+        HyperTrack
             .location
             .let {
                 when (it) {
                     is Result.Failure -> serializeLocationErrorFailure(it.failure)
                     is Result.Success -> serializeLocationSuccess(it.success)
                 }
-            }
-            .let { Success(it) }
-    }
+            }.let { Success(it) }
 
-    fun getMetadata(): WrapperResult<Serialized> {
-        return Success(
+    fun getMetadata(): WrapperResult<Serialized> =
+        Success(
             serializeMetadata(HyperTrack.metadata.toMap()),
         )
-    }
 
-    fun getName(): WrapperResult<Serialized> {
-        return Success(
+    fun getName(): WrapperResult<Serialized> =
+        Success(
             serializeName(HyperTrack.name),
         )
-    }
 
-    fun getWorkerHandle(): WrapperResult<Serialized> {
-        return Success(
+    fun getOrders(): WrapperResult<Serialized> =
+        Success(
+            serializeOrders(HyperTrack.orders.values),
+        )
+
+    fun getWorkerHandle(): WrapperResult<Serialized> =
+        Success(
             serializeWorkerHandle(HyperTrack.workerHandle),
         )
-    }
 
-    fun setDynamicPublishableKey(args: Serialized): WrapperResult<Unit> {
-        return deserializeDynamicPublishableKey(args)
+    fun setDynamicPublishableKey(args: Serialized): WrapperResult<Unit> =
+        deserializeDynamicPublishableKey(args)
             .mapSuccess { publishableKey ->
                 HyperTrack.dynamicPublishableKey = publishableKey
             }
-    }
 
-    fun setIsAvailable(args: Serialized): WrapperResult<Unit> {
-        return deserializeIsAvailable(args)
+    fun setIsAvailable(args: Serialized): WrapperResult<Unit> =
+        deserializeIsAvailable(args)
             .mapSuccess { isAvailable ->
                 HyperTrack.isAvailable = isAvailable
             }
-    }
 
-    fun setIsTracking(args: Serialized): WrapperResult<Unit> {
-        return deserializeIsTracking(args)
+    fun setIsTracking(args: Serialized): WrapperResult<Unit> =
+        deserializeIsTracking(args)
             .mapSuccess { isTracking ->
                 HyperTrack.isTracking = isTracking
             }
-    }
 
-    fun setMetadata(args: Serialized): WrapperResult<Unit> {
-        return deserializeMetadata(args)
+    fun setMetadata(args: Serialized): WrapperResult<Unit> =
+        deserializeMetadata(args)
             .flatMapSuccess { metadata ->
                 WrapperResult.tryAsResult {
                     // TODO: return proper error if JSON is wrong
                     HyperTrack.metadata = Json.fromMap(metadata)!!
                 }
             }
-    }
 
-    fun setName(args: Serialized): WrapperResult<Unit> {
-        return deserializeName(args)
+    fun setName(args: Serialized): WrapperResult<Unit> =
+        deserializeName(args)
             .mapSuccess { name ->
                 HyperTrack.name = name
             }
-    }
 
-    fun setWorkerHandle(args: Serialized): WrapperResult<Unit> {
-        return deserializeWorkerHandle(args)
+    fun setWorkerHandle(args: Serialized): WrapperResult<Unit> =
+        deserializeWorkerHandle(args)
             .mapSuccess { workerHandle ->
                 HyperTrack.workerHandle = 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,