hypertrack-sdk-react-native 10.0.3 → 11.0.0

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

@@ -1,19 +1,27 @@
 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.hypertrack.sdk.android.HyperTrack
+import com.hypertrack.sdk.android.HyperTrack.metadata
+import com.hypertrack.sdk.android.Json
+import com.hypertrack.sdk.android.Result
+import com.reactnativehypertracksdk.common.Serialization.deserializeIsAvailable
+import com.reactnativehypertracksdk.common.Serialization.deserializeName
 import com.reactnativehypertracksdk.common.Serialization.deserializeGeotagData
+import com.reactnativehypertracksdk.common.Serialization.deserializeIsTracking
+import com.reactnativehypertracksdk.common.Serialization.deserializeMetadata
 import com.reactnativehypertracksdk.common.Serialization.serializeDeviceId
 import com.reactnativehypertracksdk.common.Serialization.serializeErrors
 import com.reactnativehypertracksdk.common.Serialization.serializeIsAvailable
 import com.reactnativehypertracksdk.common.Serialization.serializeIsTracking
 import com.reactnativehypertracksdk.common.Serialization.serializeLocationErrorFailure
+import com.reactnativehypertracksdk.common.Serialization.serializeLocationResult
 import com.reactnativehypertracksdk.common.Serialization.serializeLocationSuccess
 import com.reactnativehypertracksdk.common.Serialization.serializeLocationWithDeviationSuccess
-import java.lang.IllegalStateException
-import java.lang.RuntimeException
+import com.reactnativehypertracksdk.common.Serialization.serializeMetadata
+import com.reactnativehypertracksdk.common.Serialization.serializeName
+
+typealias Serialized = Map<String, Any?>
 
 /**
  * This class stores SDK instance, calls HyperTrack SDK methods and serializes responses.
@@ -21,257 +29,116 @@ import java.lang.RuntimeException
  */
 internal object HyperTrackSdkWrapper {
 
-    // initialize method is guaranteed to be called (by non-native side)
-    // prior to any access to the SDK instance
-    private lateinit var _sdkInstance: HyperTrack
-    val sdkInstance: HyperTrack
-        get() = _sdkInstance
-
-    // method is named to align with 'initializeSDK' in iOS
-    fun initializeSdk(
-        args: Map<String, Any?>
-    ): Result<HyperTrack> {
-        return try {
-            SdkInitParams.fromMap(args)
-                .flatMapSuccess { initParams -> 
-                    _sdkInstance = HyperTrack.getInstance(initParams.publishableKey)
-                    if (initParams.loggingEnabled) {
-                        HyperTrack.enableDebugLogging()
-                    }
-                    if (initParams.allowMockLocations) {
-                        sdkInstance.allowMockLocations()
-                    }
-                    sdkInstance.backgroundTrackingRequirement(
-                        initParams.requireBackgroundTrackingPermission
-                    )
-                    Success(sdkInstance)
-                }
-        } catch (exception: Exception) {
-            Failure(exception)
-        }
-    }
-
-    fun getDeviceId(): Result<Map<String, Any?>> {
-        return Success(serializeDeviceId(sdkInstance.deviceID))
-    }
-
-    fun startTracking(): Result<Unit> {
-        sdkInstance.start()
-        return Success(Unit)
-    }
-
-    fun stopTracking(): Result<Unit> {
-        sdkInstance.stop()
-        return Success(Unit)
-    }
-
-    fun sync(): Result<Unit> {
-        sdkInstance.syncDeviceSettings()
-        return Success(Unit)
-    }
-
-    fun addGeotag(args: Map<String, Any?>): Result<Map<String, Any?>> {
+    fun addGeotag(args: Serialized): WrapperResult<Serialized> {
         return deserializeGeotagData(args)
             .flatMapSuccess { geotag ->
-                sdkInstance
-                    .addGeotag(geotag.data, geotag.expectedLocation)
-                    .let { result ->
-                        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 {
-                            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))
+                // TODO: return proper error if JSON is wrong
+                val geotagMetadata = Json.fromMap(geotag.data)!!
+                val expectedLocation = geotag
+                    .expectedLocation
+                    ?.let {
+                        HyperTrack.Location(
+                            latitude = it.latitude,
+                            longitude = it.longitude
+                        )
+                    }
+                if (expectedLocation != null) {
+                    HyperTrack
+                        .addGeotag(geotagMetadata, expectedLocation)
+                        .let {
+                            when (it) {
+                                is Result.Failure -> {
+                                    serializeLocationErrorFailure(it.failure)
                                 }
 
-                                else -> {
-                                    throw IllegalArgumentException()
+                                is Result.Success -> {
+                                    serializeLocationWithDeviationSuccess(it.success)
                                 }
                             }
                         }
-                    }
-                    .let {
-                        Success(it)
-                    }
+                } else {
+                    HyperTrack
+                        .addGeotag(geotagMetadata)
+                        .let { serializeLocationResult(it) }
+                }.let {
+                    Success(it)
+                }
             }
     }
 
-    fun isTracking(): Result<Map<String, Any?>> {
-        return Success(serializeIsTracking(sdkInstance.isTracking))
-    }
-
-    fun isAvailable(): Result<Map<String, Any?>> {
-        return Success(
-            serializeIsAvailable(sdkInstance.availability.equals(Availability.AVAILABLE))
-        )
+    fun getDeviceId(): WrapperResult<Serialized> {
+        return Success(serializeDeviceId(HyperTrack.deviceID))
     }
 
-    fun setAvailability(args: Map<String, Any?>): Result<Unit> {
-        return deserializeAvailability(args)
-            .mapSuccess { isAvailable ->
-                if (isAvailable) {
-                    sdkInstance.availability = Availability.AVAILABLE
-                } else {
-                    sdkInstance.availability = Availability.UNAVAILABLE
-                }
-            }
+    fun getErrors(): WrapperResult<List<Serialized>> {
+        return Success(serializeErrors(HyperTrack.errors))
     }
 
-    fun setName(args: Map<String, Any?>): Result<Unit> {
-        return deserializeDeviceName(args)
-            .mapSuccess { name ->
-                sdkInstance.setDeviceName(name)
-            }
+    fun getIsAvailable(): WrapperResult<Serialized> {
+        return Success(
+            serializeIsAvailable(HyperTrack.isAvailable)
+        )
     }
 
-    fun setMetadata(metadata: Map<String, Any?>): Result<Unit> {
-        return Result.tryAsResult {
-            sdkInstance.setDeviceMetadata(metadata)
-            Unit
-        }
+    fun getIsTracking(): WrapperResult<Serialized> {
+        return Success(
+            serializeIsTracking(HyperTrack.isTracking)
+        )
     }
 
-    fun getLocation(): Result<Map<String, Any?>> {
-        return sdkInstance.latestLocation
-            .let { result ->
-                if (result.isSuccess) {
-                    serializeLocationSuccess(result.value)
-                } else {
-                    serializeLocationErrorFailure(getLocationError(result.error))
+    fun getLocation(): WrapperResult<Serialized> {
+        return HyperTrack
+            .location
+            .let {
+                when (it) {
+                    is Result.Failure -> serializeLocationErrorFailure(it.failure)
+                    is Result.Success -> serializeLocationSuccess(it.success)
                 }
             }
             .let { Success(it) }
     }
 
-    fun getInitialErrors(): List<Map<String, String>> {
-        return serializeErrors(getHyperTrackErrorsFromBlockers())
+    fun getMetadata(): WrapperResult<Serialized> {
+        return Success(
+            serializeMetadata(HyperTrack.metadata.toMap())
+        )
     }
 
-    fun getErrors(error: TrackingError): List<Map<String, String>> {
-        return serializeErrors(getTrackingErrors((error)))
+    fun getName(): WrapperResult<Serialized> {
+        return Success(
+            serializeName(HyperTrack.name)
+        )
     }
 
-    private fun getTrackingErrors(error: TrackingError): Set<HyperTrackError> {
-        return when (error.code) {
-            TrackingError.INVALID_PUBLISHABLE_KEY_ERROR -> {
-                HyperTrackError.invalidPublishableKey
-            }
-            TrackingError.PERMISSION_DENIED_ERROR -> {
-                null
-            }
-            TrackingError.AUTHORIZATION_ERROR -> {
-                HyperTrackError.blockedFromRunning
-            }
-            TrackingError.GPS_PROVIDER_DISABLED_ERROR -> {
-                HyperTrackError.locationServicesDisabled
-            }
-            TrackingError.UNKNOWN_NETWORK_ERROR -> {
-                HyperTrackError.blockedFromRunning
-            }
-            else -> {
-                throw RuntimeException("Unknown tracking error")
-            }
-        }
-            .let { hyperTrackError ->
-                (hyperTrackError?.let { setOf(it) } ?: setOf()) + getHyperTrackErrorsFromBlockers()
+    fun setIsAvailable(args: Serialized): WrapperResult<Unit> {
+        return deserializeIsAvailable(args)
+            .mapSuccess { isAvailable ->
+                HyperTrack.isAvailable = isAvailable
             }
     }
 
-    private fun getLocationError(error: OutageReason): LocationError {
-        val blockersErrors = getHyperTrackErrorsFromBlockers()
-        return when (error) {
-            OutageReason.NO_GPS_SIGNAL -> {
-                Errors(setOf(HyperTrackError.gpsSignalLost) + blockersErrors)
-            }
-            OutageReason.MISSING_LOCATION_PERMISSION -> {
-                Errors(setOf(HyperTrackError.locationPermissionsDenied) + blockersErrors)
+    fun setIsTracking(args: Serialized): WrapperResult<Unit> {
+        return deserializeIsTracking(args)
+            .mapSuccess { isTracking ->
+                HyperTrack.isTracking = isTracking
             }
-            OutageReason.LOCATION_SERVICE_DISABLED -> {
-                Errors(setOf(HyperTrackError.locationServicesDisabled) + blockersErrors)
-            }
-            OutageReason.MISSING_ACTIVITY_PERMISSION -> {
-                Errors(setOf(HyperTrackError.motionActivityPermissionsDenied) + blockersErrors)
-            }
-            OutageReason.NOT_TRACKING -> {
-                NotRunning
-            }
-            OutageReason.START_HAS_NOT_FINISHED -> {
-                Starting
-            }
-            OutageReason.RESTART_REQUIRED -> {
-                throw IllegalStateException("RESTART_REQUIRED must not be returned")
-            }
-        }
     }
 
-    private fun getLocationError(error: GeotagResult.Error.Reason): LocationError {
-        val blockersErrors = getHyperTrackErrorsFromBlockers()
-        return when (error) {
-            GeotagResult.Error.Reason.NO_GPS_SIGNAL -> {
-                Errors(setOf(HyperTrackError.gpsSignalLost) + blockersErrors)
-            }
-            GeotagResult.Error.Reason.MISSING_LOCATION_PERMISSION -> {
-                Errors(setOf(HyperTrackError.locationPermissionsDenied) + blockersErrors)
-            }
-            GeotagResult.Error.Reason.LOCATION_SERVICE_DISABLED -> {
-                Errors(setOf(HyperTrackError.locationServicesDisabled) + blockersErrors)
-            }
-            GeotagResult.Error.Reason.MISSING_ACTIVITY_PERMISSION -> {
-                Errors(setOf(HyperTrackError.motionActivityPermissionsDenied) + blockersErrors)
-            }
-            GeotagResult.Error.Reason.NOT_TRACKING -> {
-                NotRunning
-            }
-            GeotagResult.Error.Reason.START_HAS_NOT_FINISHED -> {
-                Starting
+    fun setMetadata(args: Serialized): WrapperResult<Unit> {
+        return deserializeMetadata(args)
+            .flatMapSuccess { metadata ->
+                WrapperResult.tryAsResult {
+                    // TODO: return proper error if JSON is wrong
+                    HyperTrack.metadata = Json.fromMap(metadata)!!
+                }
             }
-        }
     }
 
-    private fun getHyperTrackErrorsFromBlockers(): Set<HyperTrackError> {
-        return HyperTrack.getBlockers()
-            .map {
-                when (it) {
-                    Blocker.LOCATION_PERMISSION_DENIED -> {
-                        HyperTrackError.locationPermissionsDenied
-                    }
-                    Blocker.LOCATION_SERVICE_DISABLED -> {
-                        HyperTrackError.locationServicesDisabled
-                    }
-                    Blocker.ACTIVITY_PERMISSION_DENIED -> {
-                        HyperTrackError.motionActivityPermissionsDenied
-                    }
-                    Blocker.BACKGROUND_LOCATION_DENIED -> {
-                        HyperTrackError.locationPermissionsInsufficientForBackground
-                    }
-                }
+    fun setName(args: Serialized): WrapperResult<Unit> {
+        return deserializeName(args)
+            .mapSuccess { name ->
+                HyperTrack.name = name
             }
-            .toSet()
     }
+
 }

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

@@ -2,20 +2,22 @@ package com.reactnativehypertracksdk.common
 
 /**
  * The list of available methods in the SDK API.
+ * It is used to match method calls in some wrappers (like Flutter)
  * Enum naming convention is ignored to make datatype sync across platforms easier.
  * Using Swift naming convention.
  */
 internal enum class SdkMethod {
-    initialize,
+    addGeotag,
     getDeviceID,
+    getErrors,
+    getIsAvailable,
+    getIsTracking,
     getLocation,
-    startTracking,
-    stopTracking,
-    setAvailability,
-    setName,
+    getMetadata,
+    getName,
+    locate,
+    setIsAvailable,
+    setIsTracking,
     setMetadata,
-    isTracking,
-    isAvailable,
-    addGeotag,
-    sync
+    setName,
 }