hypertrack-sdk-react-native 9.1.1 → 9.2.0

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

@@ -0,0 +1,13 @@
+package com.reactnativehypertracksdk.common
+
+import android.location.Location
+
+/**
+ * The data that represents geotag to create
+ *
+ * @param data Geotag payload
+ */
+internal data class GeotagData(
+    val data: Map<String, Any?>,
+    val expectedLocation: Location?
+)

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

@@ -1,15 +1,17 @@
 package com.reactnativehypertracksdk.common
 
 import com.hypertrack.sdk.*
+import com.hypertrack.sdk.GeotagResult
 import com.reactnativehypertracksdk.common.Serialization.deserializeAvailability
 import com.reactnativehypertracksdk.common.Serialization.deserializeDeviceName
 import com.reactnativehypertracksdk.common.Serialization.deserializeGeotagData
 import com.reactnativehypertracksdk.common.Serialization.serializeDeviceId
 import com.reactnativehypertracksdk.common.Serialization.serializeErrors
-import com.reactnativehypertracksdk.common.Serialization.serializeFailure
 import com.reactnativehypertracksdk.common.Serialization.serializeIsAvailable
 import com.reactnativehypertracksdk.common.Serialization.serializeIsTracking
-import com.reactnativehypertracksdk.common.Serialization.serializeSuccess
+import com.reactnativehypertracksdk.common.Serialization.serializeLocationErrorFailure
+import com.reactnativehypertracksdk.common.Serialization.serializeLocationSuccess
+import com.reactnativehypertracksdk.common.Serialization.serializeLocationWithDeviationSuccess
 import java.lang.IllegalStateException
 import java.lang.RuntimeException
 
@@ -30,8 +32,7 @@ internal object HyperTrackSdkWrapper {
         args: Map<String, Any?>
     ): Result<HyperTrack> {
         return try {
-            SdkInitParams
-                .fromMap(args)
+            SdkInitParams.fromMap(args)
                 .flatMapSuccess { initParams ->
                     _sdkInstance = HyperTrack.getInstance(initParams.publishableKey)
                     if (initParams.loggingEnabled) {
@@ -40,7 +41,7 @@ internal object HyperTrackSdkWrapper {
                     if (initParams.allowMockLocations) {
                         sdkInstance.allowMockLocations()
                     }
-                    this.sdkInstance.backgroundTrackingRequirement(
+                    sdkInstance.backgroundTrackingRequirement(
                         initParams.requireBackgroundTrackingPermission
                     )
                     Success(sdkInstance)
@@ -73,20 +74,45 @@ internal object HyperTrackSdkWrapper {
         return deserializeGeotagData(args)
             .flatMapSuccess { geotag ->
                 sdkInstance
-                    .addGeotag(geotag.data)
+                    .addGeotag(geotag.data, geotag.expectedLocation)
                     .let { result ->
-                        when (result) {
-                            is GeotagResult.SuccessWithDeviation -> {
-                                serializeSuccess(result.deviceLocation)
-                            }
-                            is GeotagResult.Success -> {
-                                serializeSuccess(result.deviceLocation)
-                            }
-                            is GeotagResult.Error -> {
-                                serializeFailure(getLocationError(result.reason))
+                        if(geotag.expectedLocation == null) {
+                            when (result) {
+                                is GeotagResult.SuccessWithDeviation -> {
+                                    // not supposed to happen
+                                    serializeLocationSuccess(result.deviceLocation)
+                                }
+
+                                is GeotagResult.Success -> {
+                                    serializeLocationSuccess(result.deviceLocation)
+                                }
+
+                                is GeotagResult.Error -> {
+                                    serializeLocationErrorFailure(getLocationError(result.reason))
+                                }
+
+                                else -> {
+                                    throw IllegalArgumentException()
+                                }
                             }
-                            else -> {
-                                throw IllegalArgumentException()
+                        } else {
+                            when (result) {
+                                is GeotagResult.SuccessWithDeviation -> {
+                                    serializeLocationWithDeviationSuccess(result.deviceLocation, result.deviationDistance.toDouble())
+                                }
+
+                                is GeotagResult.Success -> {
+                                    // not supposed to happen
+                                    serializeLocationWithDeviationSuccess(result.deviceLocation, 0.0)
+                                }
+
+                                is GeotagResult.Error -> {
+                                    serializeLocationErrorFailure(getLocationError(result.reason))
+                                }
+
+                                else -> {
+                                    throw IllegalArgumentException()
+                                }
                             }
                         }
                     }
@@ -135,9 +161,9 @@ internal object HyperTrackSdkWrapper {
         return sdkInstance.latestLocation
             .let { result ->
                 if (result.isSuccess) {
-                    serializeSuccess(result.value)
+                    serializeLocationSuccess(result.value)
                 } else {
-                    serializeFailure(getLocationError(result.error))
+                    serializeLocationErrorFailure(getLocationError(result.error))
                 }
             }
             .let { Success(it) }

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

@@ -14,18 +14,22 @@ internal object Serialization {
         }
     }
 
-    fun serializeSuccess(location: Location): Map<String, Any?> {
-        return mapOf(
-            KEY_TYPE to TYPE_RESULT_SUCCESS,
-            KEY_VALUE to serializeLocation(location)
-        )
+    fun serializeLocationSuccess(location: Location): Map<String, Any?> {
+        return serializeSuccess(serializeLocation(location))
     }
 
-    fun serializeFailure(locationError: LocationError): Map<String, Any?> {
-        return mapOf(
-            KEY_TYPE to TYPE_RESULT_FAILURE,
-            KEY_VALUE to serializeLocationError(locationError)
-        )
+    fun serializeLocationWithDeviationSuccess(
+        location: Location,
+        deviation: Double
+    ): Map<String, Any?> {
+        return serializeSuccess(serializeLocationWithDeviation(
+            location,
+            deviation
+        ))
+    }
+
+    fun serializeLocationErrorFailure(locationError: LocationError): Map<String, Any?> {
+        return serializeFailure(serializeLocationError(locationError))
     }
 
     fun serializeIsTracking(isTracking: Boolean): Map<String, Any?> {
@@ -42,34 +46,6 @@ internal object Serialization {
         )
     }
 
-    fun serializeLocation(location: 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 serializeLocationError(locationError: LocationError): Map<String, Any?> {
-        return when (locationError) {
-            NotRunning -> {
-                mapOf(KEY_TYPE to TYPE_LOCATION_ERROR_NOT_RUNNING)
-            }
-            Starting -> {
-                mapOf(KEY_TYPE to TYPE_LOCATION_ERROR_STARTING)
-            }
-            is Errors -> {
-                mapOf(
-                    KEY_TYPE to TYPE_LOCATION_ERROR_ERRORS,
-                    KEY_VALUE to locationError.errors
-                        .map { serializeHypertrackError(it) }
-                )
-            }
-        }
-    }
-
     fun serializeHypertrackError(error: HyperTrackError): Map<String, String> {
         return mapOf(
             KEY_TYPE to TYPE_HYPERTRACK_ERROR,
@@ -102,12 +78,16 @@ internal object Serialization {
         }
     }
 
-    fun deserializeGeotagData(map: Map<String, Any?>): Result<Geotag> {
+    fun deserializeGeotagData(map: Map<String, Any?>): Result<GeotagData> {
         return parse(map) {
             val data = it
                 .get<Map<String, Any?>>(KEY_GEOTAG_DATA)
                 .getOrThrow()
-            Geotag(data)
+            val locationData = it
+                .getOptional<Map<String, Any?>>(KEY_GEOTAG_EXPECTED_LOCATION)
+                .getOrThrow()
+            val location = locationData?.let { deserializeLocation(it).getOrThrow() }
+            GeotagData(data, location)
         }
     }
 
@@ -154,6 +134,21 @@ internal object Serialization {
             }
         }
 
+        inline fun <reified T> getOptional(
+            key: String
+        ): Result<T?> {
+            return try {
+                Success(source[key] as T?)
+            } catch (e: Exception) {
+                Failure(
+                    ParsingException(key, e)
+                        .also {
+                            _exceptions.add(it)
+                        }
+                )
+            }
+        }
+
         inline fun <reified T> assertValue(
             key: String,
             value: Any
@@ -179,6 +174,82 @@ internal object Serialization {
         exception: Exception
     ) : Exception("Invalid value for '$key': $exception", exception)
 
+    private fun deserializeLocation(map: Map<String, Any?>): Result<Location> {
+        return parse(map) {
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_LOCATION)
+            val value = it
+                .get<Map<String, Any?>>(KEY_VALUE)
+                .getOrThrow()
+            parse(value) { parser ->
+                val latitude = parser
+                    .get<Double>(KEY_LATITUDE)
+                    .getOrThrow()
+                val longitude = parser
+                    .get<Double>(KEY_LONGITUDE)
+                    .getOrThrow()
+                Location("api").also {
+                    it.latitude = latitude
+                    it.longitude = longitude
+                }
+            }.getOrThrow()
+        }
+    }
+
+    private fun serializeLocationWithDeviation(
+        location: Location,
+        deviation: Double
+    ): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_LOCATION,
+            KEY_VALUE to mapOf(
+                KEY_LOCATION to serializeLocation(location),
+                KEY_DEVIATION to deviation
+            )
+        )
+    }
+
+    private fun serializeFailure(failure: Map<String, Any?>): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_RESULT_FAILURE,
+            KEY_VALUE to failure
+        )
+    }
+
+    private fun serializeSuccess(success: Map<String, Any?>): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_RESULT_SUCCESS,
+            KEY_VALUE to success
+        )
+    }
+
+    private fun serializeLocation(location: 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
+            )
+        )
+    }
+
+    private fun serializeLocationError(locationError: LocationError): Map<String, Any?> {
+        return when (locationError) {
+            NotRunning -> {
+                mapOf(KEY_TYPE to TYPE_LOCATION_ERROR_NOT_RUNNING)
+            }
+            Starting -> {
+                mapOf(KEY_TYPE to TYPE_LOCATION_ERROR_STARTING)
+            }
+            is Errors -> {
+                mapOf(
+                    KEY_TYPE to TYPE_LOCATION_ERROR_ERRORS,
+                    KEY_VALUE to locationError.errors
+                        .map { serializeHypertrackError(it) }
+                )
+            }
+        }
+    }
+
     private const val KEY_TYPE = "type"
     private const val KEY_VALUE = "value"
 
@@ -186,6 +257,7 @@ internal object Serialization {
     private const val TYPE_RESULT_FAILURE = "failure"
 
     private const val TYPE_LOCATION = "location"
+    private const val TYPE_LOCATION_WITH_DEVIATION = "locationWithDeviation"
     private const val TYPE_AVAILABILITY = "isAvailable"
     private const val TYPE_DEVICE_NAME = "deviceName"
     private const val TYPE_DEVICE_ID = "deviceID"
@@ -200,4 +272,7 @@ internal object Serialization {
     private const val KEY_LONGITUDE = "longitude"
 
     const val KEY_GEOTAG_DATA = "data"
+    const val KEY_GEOTAG_EXPECTED_LOCATION = "expectedLocation"
+    const val KEY_DEVIATION = "deviation"
+    const val KEY_LOCATION = "location"
 }

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/Objective-C', '4.14.0'
+  s.dependency 'HyperTrack/Objective-C', '4.15.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/common/GeotagData.swift

@@ -0,0 +1,11 @@
+import HyperTrack
+
+struct GeotagData {
+    let data: [String: Any]
+    let expectedLocation: HyperTrack.Location?
+
+    init(data: [String: Any], expectedLocation: HyperTrack.Location?) {
+        self.data = data
+        self.expectedLocation = expectedLocation
+    }
+}

package/ios/common/HyperTrackSDKWrapper.swift

@@ -88,10 +88,15 @@ func isAvailable() -> Result<SuccessResult, FailureResult> {
 }
 
 func addGeotag(_ args: Dictionary<String, Any>) -> Result<SuccessResult, FailureResult> {
-    return deserializeGeotagData(args).flatMap { data in
-        let metadata: HyperTrack.JSON.Object = getJSON(data)
-        let result = sdkInstance.addGeotag(metadata)
-        return .success(.dict(serializeLocationResult(result)))
+    return deserializeGeotagData(args).flatMap { geotagData in
+        let metadata: HyperTrack.JSON.Object = getJSON(geotagData.data)
+        if let expectedLocation = geotagData.expectedLocation {
+            let result = sdkInstance.addGeotag(metadata, expectedLocation: expectedLocation)
+            return .success(.dict(serializeExpectedLocationResult(result)))
+        } else {
+            let result = sdkInstance.addGeotag(metadata)
+            return .success(.dict(serializeLocationResult(result)))
+        }
     }
 }