hypertrack-sdk-react-native 10.0.3 → 11.0.1

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

@@ -1,6 +1,8 @@
 package com.reactnativehypertracksdk.common
 
 import android.location.Location
+import com.hypertrack.sdk.android.HyperTrack
+import com.hypertrack.sdk.android.Result
 
 /**
  * Platform-independent serialization code that converts HyperTrack data types
@@ -8,93 +10,250 @@ import android.location.Location
  */
 internal object Serialization {
 
-    fun serializeErrors(errors: Set<HyperTrackError>): List<Map<String, String>> {
-        return errors.map {
-            serializeHypertrackError(it)
+    fun deserializeIsAvailable(isAvailable: Map<String, Any?>): WrapperResult<Boolean> {
+        return parse(isAvailable) {
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_IS_AVAILABLE)
+            it
+                .get<Boolean>(KEY_VALUE)
+                .getOrThrow()
         }
     }
 
-    fun serializeLocationSuccess(location: Location): Map<String, Any?> {
-        return serializeSuccess(serializeLocation(location))
+    fun deserializeIsTracking(isTracking: Map<String, Any?>): WrapperResult<Boolean> {
+        return parse(isTracking) {
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_IS_TRACKING)
+            it
+                .get<Boolean>(KEY_VALUE)
+                .getOrThrow()
+        }
     }
 
-    fun serializeLocationWithDeviationSuccess(
-        location: Location,
-        deviation: Double
-    ): Map<String, Any?> {
-        return serializeSuccess(serializeLocationWithDeviation(
-            location,
-            deviation
-        ))
+    fun deserializeMetadata(metadata: Map<String, Any?>): WrapperResult<Map<String, Any?>> {
+        return parse(metadata) {
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_METADATA)
+            it
+                .get<Map<String, Any?>>(KEY_VALUE)
+                .getOrThrow()
+        }
     }
 
-    fun serializeLocationErrorFailure(locationError: LocationError): Map<String, Any?> {
-        return serializeFailure(serializeLocationError(locationError))
+    fun deserializeName(name: Map<String, Any?>): WrapperResult<String> {
+        return parse(name) {
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_NAME)
+            it
+                .get<String>(KEY_VALUE)
+                .getOrThrow()
+        }
     }
 
-    fun serializeIsTracking(isTracking: Boolean): Map<String, Any?> {
+    fun deserializeGeotagData(map: Map<String, Any?>): WrapperResult<GeotagData> {
+        return parse(map) {
+            val data = it
+                .get<Map<String, Any?>>(KEY_GEOTAG_DATA)
+                .getOrThrow()
+            val locationData = it
+                .getOptional<Map<String, Any?>>(KEY_GEOTAG_EXPECTED_LOCATION)
+                .getOrThrow()
+            val location = locationData?.let { deserializeLocation(it).getOrThrow() }
+            GeotagData(data, location)
+        }
+    }
+
+    fun serializeDeviceId(deviceId: String): Map<String, Any?> {
         return mapOf(
-            KEY_TYPE to TYPE_IS_TRACKING,
-            KEY_VALUE to isTracking
+            KEY_TYPE to TYPE_DEVICE_ID,
+            KEY_VALUE to deviceId
+        )
+    }
+
+    fun serializeError(error: HyperTrack.Error): Map<String, String> {
+        return mapOf(
+            KEY_TYPE to TYPE_ERROR,
+            KEY_VALUE to when (error) {
+                HyperTrack.Error.BlockedFromRunning -> "blockedFromRunning"
+                HyperTrack.Error.InvalidPublishableKey -> "invalidPublishableKey"
+                HyperTrack.Error.Location.Mocked -> "location.mocked"
+                HyperTrack.Error.Location.ServicesDisabled -> "location.servicesDisabled"
+                HyperTrack.Error.Location.ServicesUnavailable -> "location.servicesUnavailable"
+                HyperTrack.Error.Location.SignalLost -> "location.signalLost"
+                HyperTrack.Error.NoExemptionFromBackgroundStartRestrictions -> "noExemptionFromBackgroundStartRestrictions"
+                HyperTrack.Error.Permissions.Location.Denied -> "permissions.location.denied"
+                HyperTrack.Error.Permissions.Location.InsufficientForBackground -> "permissions.location.insufficientForBackground"
+                HyperTrack.Error.Permissions.Location.ReducedAccuracy -> "permissions.location.reducedAccuracy"
+                HyperTrack.Error.Permissions.Notifications.Denied -> "permissions.notifications.denied"
+            }
         )
     }
 
+    fun serializeErrors(errors: Set<HyperTrack.Error>): List<Map<String, String>> {
+        return errors.map {
+            serializeError(it)
+        }
+    }
+
     fun serializeIsAvailable(isAvailable: Boolean): Map<String, Any?> {
         return mapOf(
-            KEY_TYPE to TYPE_AVAILABILITY,
+            KEY_TYPE to TYPE_IS_AVAILABLE,
             KEY_VALUE to isAvailable
         )
     }
 
-    fun serializeHypertrackError(error: HyperTrackError): Map<String, String> {
+    fun serializeIsTracking(isTracking: Boolean): Map<String, Any?> {
         return mapOf(
-            KEY_TYPE to TYPE_HYPERTRACK_ERROR,
-            KEY_VALUE to error.name
+            KEY_TYPE to TYPE_IS_TRACKING,
+            KEY_VALUE to isTracking
         )
     }
 
-    fun serializeDeviceId(deviceId: String): Map<String, Any?> {
+    fun serializeMetadata(metadata: Map<String, Any?>): Map<String, Any?> {
         return mapOf(
-            KEY_TYPE to TYPE_DEVICE_ID,
-            KEY_VALUE to deviceId
+            KEY_TYPE to TYPE_METADATA,
+            KEY_VALUE to metadata
         )
     }
 
-    fun deserializeDeviceName(name: Map<String, Any?>): Result<String> {
-        return parse(name) {
-            it.assertValue<String>(key = KEY_TYPE, value = TYPE_DEVICE_NAME)
-            it
-                .get<String>(KEY_VALUE)
-                .getOrThrow()
+    fun serializeName(name: String): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_NAME,
+            KEY_VALUE to name
+        )
+    }
+
+    fun serializeLocateResult(
+        locationResult: Result<HyperTrack.Location, Set<HyperTrack.Error>>
+    ): Map<String, Any?> {
+        return when (locationResult) {
+            is Result.Failure -> {
+                serializeFailure(serializeErrors(locationResult.failure))
+            }
+
+            is Result.Success -> {
+                serializeLocationSuccess(locationResult.success)
+            }
         }
     }
 
-    fun deserializeAvailability(isAvailable: Map<String, Any?>): Result<Boolean> {
-        return parse(isAvailable) {
-            it.assertValue<String>(key = KEY_TYPE, value = TYPE_AVAILABILITY)
-            it
-                .get<Boolean>(KEY_VALUE)
-                .getOrThrow()
+    fun serializeLocationResult(
+        locationResult: Result<HyperTrack.Location, HyperTrack.LocationError>
+    ): Map<String, Any?> {
+        return when (locationResult) {
+            is Result.Failure -> {
+                serializeLocationErrorFailure(locationResult.failure)
+            }
+
+            is Result.Success -> {
+                serializeLocationSuccess(locationResult.success)
+            }
         }
     }
 
-    fun deserializeGeotagData(map: Map<String, Any?>): Result<GeotagData> {
+    fun serializeLocationErrorFailure(locationError: HyperTrack.LocationError): Map<String, Any?> {
+        return serializeFailure(serializeLocationError(locationError))
+    }
+
+    fun serializeLocationSuccess(location: HyperTrack.Location): Map<String, Any?> {
+        return serializeSuccess(serializeLocation(location))
+    }
+
+    fun serializeLocationWithDeviationSuccess(
+        locationWithDeviation: HyperTrack.LocationWithDeviation,
+    ): Map<String, Any?> {
+        return serializeSuccess(
+            serializeLocationWithDeviation(
+                locationWithDeviation
+            )
+        )
+    }
+
+    private fun serializeLocationWithDeviation(
+        locationWithDeviation: HyperTrack.LocationWithDeviation,
+    ): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_LOCATION_WITH_DEVIATION,
+            KEY_VALUE to mapOf(
+                KEY_LOCATION to serializeLocation(locationWithDeviation.location),
+                KEY_DEVIATION to locationWithDeviation.deviation
+            )
+        )
+    }
+
+    private fun deserializeLocation(map: Map<String, Any?>): WrapperResult<Location> {
         return parse(map) {
-            val data = it
-                .get<Map<String, Any?>>(KEY_GEOTAG_DATA)
-                .getOrThrow()
-            val locationData = it
-                .getOptional<Map<String, Any?>>(KEY_GEOTAG_EXPECTED_LOCATION)
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_LOCATION)
+            val value = it
+                .get<Map<String, Any?>>(KEY_VALUE)
                 .getOrThrow()
-            val location = locationData?.let { deserializeLocation(it).getOrThrow() }
-            GeotagData(data, location)
+            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 serializeFailure(failure: List<Map<String, Any?>>): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_RESULT_FAILURE,
+            KEY_VALUE to failure
+        )
+    }
+
+    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
+        )
+    }
+
+    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
+            )
+        )
+    }
+
+
+    private fun serializeLocationError(locationError: HyperTrack.LocationError): Map<String, Any?> {
+        return when (locationError) {
+            HyperTrack.LocationError.NotRunning -> {
+                mapOf(KEY_TYPE to TYPE_LOCATION_ERROR_NOT_RUNNING)
+            }
+
+            HyperTrack.LocationError.Starting -> {
+                mapOf(KEY_TYPE to TYPE_LOCATION_ERROR_STARTING)
+            }
+
+            is HyperTrack.LocationError.Errors -> {
+                mapOf(
+                    KEY_TYPE to TYPE_LOCATION_ERROR_ERRORS,
+                    KEY_VALUE to locationError.errors
+                        .map { serializeError(it) }
+                )
+            }
         }
     }
 
     fun <T> parse(
         source: Map<String, Any?>,
         parseFunction: (Parser) -> T
-    ): Result<T> {
+    ): WrapperResult<T> {
         val parser = Parser(source)
         return try {
             if (parser.exceptions.isEmpty()) {
@@ -121,7 +280,7 @@ internal object Serialization {
 
         inline fun <reified T> get(
             key: String
-        ): Result<T> {
+        ): WrapperResult<T> {
             return try {
                 Success(source[key]!! as T)
             } catch (e: Exception) {
@@ -136,7 +295,7 @@ internal object Serialization {
 
         inline fun <reified T> getOptional(
             key: String
-        ): Result<T?> {
+        ): WrapperResult<T?> {
             return try {
                 Success(source[key] as T?)
             } catch (e: Exception) {
@@ -174,105 +333,30 @@ 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_WITH_DEVIATION,
-            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"
 
-    private const val TYPE_RESULT_SUCCESS = "success"
     private const val TYPE_RESULT_FAILURE = "failure"
+    private const val TYPE_RESULT_SUCCESS = "success"
 
-    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"
-    private const val TYPE_HYPERTRACK_ERROR = "hyperTrackError"
+    private const val TYPE_ERROR = "error"
+    private const val TYPE_IS_AVAILABLE = "isAvailable"
     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_LOCATION_ERROR_ERRORS = "errors"
     private const val TYPE_LOCATION_ERROR_NOT_RUNNING = "notRunning"
     private const val TYPE_LOCATION_ERROR_STARTING = "starting"
-    private const val TYPE_LOCATION_ERROR_ERRORS = "errors"
 
     private const val KEY_LATITUDE = "latitude"
     private const val KEY_LONGITUDE = "longitude"
 
+    const val KEY_DEVIATION = "deviation"
     const val KEY_GEOTAG_DATA = "data"
     const val KEY_GEOTAG_EXPECTED_LOCATION = "expectedLocation"
-    const val KEY_DEVIATION = "deviation"
     const val KEY_LOCATION = "location"
 }

package/android/src/main/java/com/reactnativehypertracksdk/common/{Result.kt → WrapperResult.kt}

@@ -1,24 +1,26 @@
 package com.reactnativehypertracksdk.common
 
-internal sealed class Result<SuccessType> {
+internal sealed class WrapperResult<SuccessType> {
     fun <MappedSuccess> flatMapSuccess(
-        onSuccess: (SuccessType) -> Result<MappedSuccess>
-    ): Result<MappedSuccess> {
+        onSuccess: (SuccessType) -> WrapperResult<MappedSuccess>
+    ): WrapperResult<MappedSuccess> {
         return when (this) {
             is Success -> {
                 onSuccess.invoke(this.success)
             }
+
             is Failure -> {
                 Failure<MappedSuccess>(this.failure)
             }
         }
     }
 
-    fun <MappedSuccess> mapSuccess(onSuccess: (SuccessType) -> MappedSuccess): Result<MappedSuccess> {
+    fun <MappedSuccess> mapSuccess(onSuccess: (SuccessType) -> MappedSuccess): WrapperResult<MappedSuccess> {
         return when (this) {
             is Success -> {
                 Success(onSuccess.invoke(this.success))
             }
+
             is Failure -> {
                 Failure<MappedSuccess>(this.failure)
             }
@@ -36,7 +38,7 @@ internal sealed class Result<SuccessType> {
     }
 
     companion object {
-        fun <SuccessType> tryAsResult(block: () -> SuccessType): Result<SuccessType> {
+        fun <SuccessType> tryAsResult(block: () -> SuccessType): WrapperResult<SuccessType> {
             return try {
                 Success(block.invoke())
             } catch (e: Exception) {
@@ -46,5 +48,5 @@ internal sealed class Result<SuccessType> {
     }
 }
 
-internal data class Success<SuccessType>(val success: SuccessType) : Result<SuccessType>()
-internal data class Failure<SuccessType>(val failure: Throwable) : Result<SuccessType>()
+internal data class Success<SuccessType>(val success: SuccessType) : 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/Objective-C', '4.16.1'
+  s.dependency 'HyperTrack', '5.0.1'
 
   # 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

@@ -9,36 +9,39 @@ RCT_EXTERN_METHOD(addListener)
 
 RCT_EXTERN_METHOD(requiresMainQueueSetup)
 
-RCT_EXTERN_METHOD(initializeSdk:(NSDictionary *)args
+RCT_EXTERN_METHOD(addGeotag:(NSDictionary *)args
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
 RCT_EXTERN_METHOD(getDeviceId:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(getLocation:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(getErrors:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(startTracking:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(getIsAvailable:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(stopTracking:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(getIsTracking:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)   
+
+RCT_EXTERN_METHOD(getLocation:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(isTracking:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(getMetadata:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(isAvailable:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(getName:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(sync:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(locate:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(setAvailability:(NSDictionary *)args
+RCT_EXTERN_METHOD(setIsAvailable:(NSDictionary *)args
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(setName:(NSDictionary *)args
+RCT_EXTERN_METHOD(setIsTracking:(NSDictionary *)args
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
@@ -46,9 +49,8 @@ RCT_EXTERN_METHOD(setMetadata:(NSDictionary *)args
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(addGeotag:(NSDictionary *)args
+RCT_EXTERN_METHOD(setName:(NSDictionary *)args
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-
 @end