hypertrack-sdk-react-native 8.2.1 → 9.0.0

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

@@ -0,0 +1,209 @@
+package com.reactnativehypertracksdk
+
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.hypertrack.sdk.*
+import com.hypertrack.sdk.TrackingStateObserver.OnTrackingStateChangeListener
+import com.hypertrack.sdk.AvailabilityStateObserver.OnAvailabilityStateChangeListener
+import com.reactnativehypertracksdk.common.*
+import com.reactnativehypertracksdk.common.Serialization.serializeIsAvailable
+import com.reactnativehypertracksdk.common.Serialization.serializeIsTracking
+
+@Suppress("ComplexRedundantLet")
+@ReactModule(name = HyperTrackReactNativePlugin.NAME)
+class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    var trackingStateListener: OnTrackingStateChangeListener? = null
+    var availabilityListener: OnAvailabilityStateChangeListener? = null
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    @ReactMethod
+    fun addListener(type: String?) {
+        when(type) {
+            EVENT_TRACKING -> {
+                HyperTrackSdkWrapper.isTracking().let {
+                    when(it) {
+                        is Success -> {
+                            emitIsTracking(it.success)
+                        }
+                        is Failure -> {
+                            throw Exception("isTracking failed: ${it.failure}", it.failure)
+                        }
+                    }
+                }
+            }
+            EVENT_AVAILABILITY -> {
+                HyperTrackSdkWrapper.isAvailable().let {
+                    when(it) {
+                        is Success -> {
+                            emitIsAvailable(it.success)
+                        }
+                        is Failure -> {
+                            throw Exception("isAvailable failed: ${it.failure}", it.failure)
+                        }
+                    }
+                }
+            }
+            EVENT_ERRORS -> {
+                HyperTrackSdkWrapper.getInitialErrors().let {
+                    emitErrors(it)
+                }
+            }
+            else -> Unit
+        }
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    @ReactMethod
+    fun removeListeners(type: Int?) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    @ReactMethod
+    fun initializeSdk(
+        initParams: ReadableMap,
+        promise: Promise
+    ) {
+        HyperTrackSdkWrapper
+            .initialize(initParams.toHashMap())
+            .mapSuccess { sdk ->
+                initListeners(sdk)
+            }
+            .toPromise(promise)
+    }
+
+    private fun initListeners(sdkInstance: HyperTrack) {
+        if (trackingStateListener != null) {
+            sdkInstance.removeTrackingListener(trackingStateListener)
+            trackingStateListener = null
+        }
+        trackingStateListener = object : OnTrackingStateChangeListener {
+            override fun onError(trackingError: TrackingError) {
+                emitErrors(HyperTrackSdkWrapper.getErrors(trackingError))
+            }
+
+            override fun onTrackingStart() {
+                emitIsTracking(serializeIsTracking(true))
+            }
+
+            override fun onTrackingStop() {
+                emitIsTracking(serializeIsTracking(false))
+            }
+        }.also {
+            sdkInstance.addTrackingListener(it)
+        }
+
+        if (availabilityListener != null) {
+            sdkInstance.removeAvailabilityListener(availabilityListener)
+            availabilityListener = null
+        }
+        availabilityListener =
+            object : AvailabilityStateObserver.OnAvailabilityStateChangeListener {
+                override fun onError(p0: AvailabilityError) {
+                    // ignored, errors are handled by trackingStateListener
+                }
+
+                override fun onAvailable() {
+                    emitIsAvailable(serializeIsAvailable(true))
+                }
+
+                override fun onUnavailable() {
+                    emitIsAvailable(serializeIsAvailable(false))
+                }
+            }.also {
+                sdkInstance.addAvailabilityListener(it)
+            }
+    }
+
+    @ReactMethod
+    fun getDeviceId(promise: Promise) {
+        HyperTrackSdkWrapper.getDeviceID().toPromise(promise)
+    }
+
+    @ReactMethod
+    fun isTracking(promise: Promise) {
+        HyperTrackSdkWrapper.isTracking().toPromise(promise)
+    }
+
+    @ReactMethod
+    fun startTracking() {
+        HyperTrackSdkWrapper.startTracking()
+    }
+
+    @ReactMethod
+    fun stopTracking() {
+        HyperTrackSdkWrapper.stopTracking()
+    }
+
+    @ReactMethod
+    fun sync() {
+        HyperTrackSdkWrapper.sync()
+    }
+
+    @ReactMethod
+    fun addGeotag(args: ReadableMap, promise: Promise) {
+        HyperTrackSdkWrapper.addGeotag(args.toHashMap()).toPromise(promise)
+    }
+
+    @ReactMethod
+    fun isAvailable(promise: Promise) {
+        HyperTrackSdkWrapper.isAvailable().toPromise(promise)
+    }
+
+    @ReactMethod
+    fun setAvailability(args: ReadableMap) {
+        HyperTrackSdkWrapper.setAvailability(args.toHashMap())
+    }
+
+    @ReactMethod
+    fun setName(args: ReadableMap) {
+        HyperTrackSdkWrapper.setName(args.toHashMap())
+    }
+
+    @ReactMethod
+    fun setMetadata(args: ReadableMap) {
+        HyperTrackSdkWrapper.setMetadata(args.toHashMap())
+    }
+
+    @ReactMethod
+    fun getLocation(promise: Promise) {
+        HyperTrackSdkWrapper.getLocation().toPromise(promise)
+    }
+
+    private fun emitIsTracking(isTracking: Map<String, Any?>) {
+        emitEvent(EVENT_TRACKING, isTracking.toWritableMap())
+    }
+
+    private fun emitIsAvailable(isAvailable: Map<String, Any?>) {
+        emitEvent(EVENT_AVAILABILITY, isAvailable.toWritableMap())
+    }
+
+    private fun emitErrors(errors: List<Map<String, Any?>>) {
+        emitEvent(EVENT_ERRORS, errors.toWriteableArray())
+    }
+
+    private fun emitEvent(event: String, data: WritableMap) {
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(event, data)
+    }
+
+    private fun emitEvent(event: String, data: WritableArray) {
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(event, data)
+    }
+
+    companion object {
+        private const val EVENT_TRACKING = "onTrackingChanged"
+        private const val EVENT_AVAILABILITY = "onAvailabilityChanged"
+        private const val EVENT_ERRORS = "onError"
+
+        const val NAME = "HyperTrackReactNativePlugin"
+    }
+}

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

@@ -3,12 +3,10 @@ import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
-import com.hypertrack.reactnative.androidsdk.HTSDKModule
-
 
 class HyperTrackSdkPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(HTSDKModule(reactContext))
+    override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
+        return listOf(HyperTrackReactNativePlugin(reactContext)).toMutableList()
     }
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

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

@@ -0,0 +1,88 @@
+package com.reactnativehypertracksdk
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.reactnativehypertracksdk.common.Failure
+import com.reactnativehypertracksdk.common.Result
+import com.reactnativehypertracksdk.common.Success
+
+@Suppress("UNCHECKED_CAST")
+internal fun <T> Result<T>.toPromise(promise: Promise) {
+  when(this) {
+    is Success -> {
+      when(this.success) {
+        is Map<*, *> -> {
+          promise.resolve((this.success as Map<String, Any>).toWritableMap())
+        }
+        is Unit -> {
+          promise.resolve(null)
+        }
+        else -> {
+          // using nested exception to correctly display error in RN logs
+          promise.reject(Exception(IllegalArgumentException(this.success.toString())))
+        }
+      }
+    }
+    is Failure -> {
+      promise.reject(Exception(this.failure))
+    }
+  }
+}
+
+@Suppress("UNCHECKED_CAST")
+internal fun List<Any>.toWriteableArray(): WritableArray {
+    return Arguments.createArray().also { writableArray ->
+        forEach {
+            when (it) {
+                is String -> {
+                    writableArray.pushString(it)
+                }
+                is Map<*, *> -> {
+                    writableArray.pushMap((it as Map<String, Any>).toWritableMap())
+                }
+                else -> {
+                    throw Exception(IllegalArgumentException(it.javaClass.toString()))
+                }
+            }
+        }
+    }
+}
+
+@Suppress("UNCHECKED_CAST")
+internal fun Map<String, Any?>.toWritableMap(): WritableMap {
+    val map = this
+    return Arguments.createMap().apply {
+        map.forEach { entry ->
+            val key = entry.key
+            when (val value = entry.value) {
+                is String -> {
+                    putString(key, value)
+                }
+                is Int -> {
+                    putInt(key, value)
+                }
+                is Double -> {
+                    putDouble(key, value)
+                }
+                is Boolean -> {
+                    putBoolean(key, value)
+                }
+                is List<*> -> {
+                    putArray(key, (value as List<String>).toWriteableArray())
+                }
+                is Map<*, *> -> {
+                    putMap(key, (value as Map<String, Any>).toWritableMap())
+                }
+                null -> {
+                    putNull(key)
+                }
+                else -> {
+                    throw Exception(IllegalArgumentException(entry.value?.javaClass.toString()))
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+package com.reactnativehypertracksdk.common
+
+/**
+ * The data that represents geotag to create. Now it contains only payload data but
+ * can have other params like expectedLocation in future
+ *
+ * @param data Geotag payload
+ */
+internal data class Geotag(val data: Map<String, Any?>)

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

@@ -0,0 +1,27 @@
+package com.reactnativehypertracksdk.common
+
+/**
+ * Check HyperTrack SDK docs for HyperTrackError
+ * Enum naming convention is ignored to make datatype sync across platforms easier
+ */
+@Suppress("EnumEntryName")
+internal enum class HyperTrackError {
+    gpsSignalLost,
+    locationMocked,
+    locationPermissionsDenied,
+    locationPermissionsInsufficientForBackground,
+    locationPermissionsNotDetermined,
+    locationPermissionsReducedAccuracy,
+    locationPermissionsProvisional,
+    locationPermissionsRestricted,
+    locationServicesDisabled,
+    locationServicesUnavailable,
+    motionActivityPermissionsNotDetermined,
+    motionActivityPermissionsDenied,
+    motionActivityServicesDisabled,
+    motionActivityServicesUnavailable,
+    motionActivityPermissionsRestricted,
+    networkConnectionUnavailable,
+    invalidPublishableKey,
+    blockedFromRunning
+}

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

@@ -0,0 +1,243 @@
+package com.reactnativehypertracksdk.common
+
+import com.hypertrack.sdk.*
+import com.reactnativehypertracksdk.common.Serialization.deserializeAvailability
+import com.reactnativehypertracksdk.common.Serialization.deserializeGeotagData
+import com.reactnativehypertracksdk.common.Serialization.serializeFailure
+import com.reactnativehypertracksdk.common.Serialization.serializeErrors
+import com.reactnativehypertracksdk.common.Serialization.serializeIsAvailable
+import com.reactnativehypertracksdk.common.Serialization.serializeIsTracking
+import com.reactnativehypertracksdk.common.Serialization.serializeSuccess
+import com.reactnativehypertracksdk.common.Serialization.serializeDeviceId
+import com.reactnativehypertracksdk.common.Serialization.deserializeDeviceName
+import com.reactnativehypertracksdk.common.Serialization.parse
+import java.lang.IllegalStateException
+import java.lang.RuntimeException
+import android.util.Log
+
+
+/**
+ * This class stores SDK instance, calls HyperTrack SDK methods and serializes responses.
+ * It receives serialized params.
+ */
+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
+
+    fun initialize(
+        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()
+                }
+                this.sdkInstance.backgroundTrackingRequirement(
+                    initParams.requireBackgroundTrackingPermission
+                )
+                Success(sdkInstance)
+            }
+        } catch (exception: Exception) {
+            Failure(Exception("Hypertrack SDK initialization failed.", 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?>> {
+        return deserializeGeotagData(args).flatMapSuccess { geotag ->
+            sdkInstance.addGeotag(geotag.data).let { result ->
+                when (result) {
+                    is GeotagResult.SuccessWithDeviation -> {
+                        serializeSuccess(result.deviceLocation)
+                    }
+                    is GeotagResult.Success -> {
+                        serializeSuccess(result.deviceLocation)
+                    }
+                    is GeotagResult.Error -> {
+                        serializeFailure(getLocationError(result.reason))
+                    }
+                    else -> {
+                        throw IllegalArgumentException()
+                    }
+                }
+            }.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 setAvailability(args: Map<String, Any?>): Result<Unit> {
+        return deserializeAvailability(args).mapSuccess { isAvailable ->
+            if (isAvailable) {
+                sdkInstance.availability = Availability.AVAILABLE
+            } else {
+                sdkInstance.availability = Availability.UNAVAILABLE
+            }
+        }
+    }
+
+    fun setName(args: Map<String, Any?>): Result<Unit> {
+        return deserializeDeviceName(args).mapSuccess { name ->
+            sdkInstance.setDeviceName(name)
+        }
+    }
+
+    fun setMetadata(metadata: Map<String, Any?>): Result<Unit> {
+        return Result.tryAsResult {
+            sdkInstance.setDeviceMetadata(metadata)
+            Unit
+        }
+    }
+
+    fun getLocation(): Result<Map<String, Any?>> {
+        return sdkInstance.latestLocation.let { result ->
+            if (result.isSuccess) {
+                serializeSuccess(result.value)
+            } else {
+                serializeFailure(getLocationError(result.error))
+            }
+        }.let { Success(it) }
+    }
+
+    fun getInitialErrors(): List<Map<String, String>> {
+        return serializeErrors(getHyperTrackErrorsFromBlockers())
+    }
+
+    fun getErrors(error: TrackingError): List<Map<String, String>> {
+        return serializeErrors(getTrackingErrors((error)))
+    }
+
+    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()
+        }
+    }
+
+    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)
+            }
+            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
+            }
+        }
+    }
+
+    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
+                    }
+                }
+            }
+            .toSet()
+    }
+
+}

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

@@ -0,0 +1,9 @@
+package com.reactnativehypertracksdk.common
+
+/**
+ * Check HyperTrack SDK docs for LocationError
+ */
+internal sealed class LocationError
+internal object NotRunning : LocationError()
+internal object Starting : LocationError()
+internal data class Errors(val errors: Set<HyperTrackError>) : LocationError()

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

@@ -0,0 +1,48 @@
+package com.reactnativehypertracksdk.common
+
+internal sealed class Result<S> {
+    fun <T> flatMapSuccess(onSuccess: (S) -> Result<T>): Result<T> {
+        return when (this) {
+            is Success -> {
+                onSuccess.invoke(this.success)
+            }
+            is Failure -> {
+                Failure<T>(this.failure)
+            }
+        }
+    }
+
+    fun <T> mapSuccess(onSuccess: (S) -> T): Result<T> {
+        return when (this) {
+            is Success -> {
+                Success(onSuccess.invoke(this.success))
+            }
+            is Failure -> {
+                Failure<T>(this.failure)
+            }
+        }
+    }
+
+    fun getOrThrow(): S {
+        return when (this) {
+            is Success -> this.success
+            is Failure -> throw Exception(
+                "Result unwrapping failed: ${this.failure}",
+                this.failure
+            )
+        }
+    }
+
+    companion object {
+        fun <T> tryAsResult(block: () -> T): Result<T> {
+            return try {
+                Success(block.invoke())
+            } catch (e: Exception) {
+                Failure(e)
+            }
+        }
+    }
+}
+
+internal data class Success<S>(val success: S) : Result<S>()
+internal data class Failure<S>(val failure: Throwable) : Result<S>()

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

@@ -0,0 +1,46 @@
+package com.reactnativehypertracksdk.common
+
+import com.reactnativehypertracksdk.common.Serialization.parse
+import android.util.Log
+
+/**
+ * SDK config params
+ */
+internal data class SdkInitParams(
+    val publishableKey: String,
+    val requireBackgroundTrackingPermission: Boolean,
+    val loggingEnabled: Boolean,
+    val allowMockLocations: Boolean,
+) {
+
+    companion object {
+        fun fromMap(map: Map<String, Any?>): Result<SdkInitParams> {
+            Log.v(javaClass.simpleName, "fromMap 1")
+            return parse(map) {
+                Log.v(javaClass.simpleName, "parse 1")
+                SdkInitParams(
+                    publishableKey = it.get<String>(KEY_PUBLISHABLE_KEY).getOrThrow(),
+                    requireBackgroundTrackingPermission = it.get<Boolean>(
+                        KEY_REQUIRE_BACKGROUND_TRACKING_PERMISSION
+                    ).getOrThrow(),
+                    loggingEnabled = it.get<Boolean>(KEY_LOGGING_ENABLED).getOrThrow(),
+                    allowMockLocations = it.get<Boolean>(KEY_ALLOW_MOCK_LOCATIONS).getOrThrow()
+                )
+            }.also {
+                Log.v(javaClass.simpleName, "fromMap $it")
+            }
+        }
+
+        private const val KEY_PUBLISHABLE_KEY =
+            "publishableKey"
+        private const val KEY_REQUIRE_BACKGROUND_TRACKING_PERMISSION =
+            "requireBackgroundTrackingPermission"
+        private const val KEY_LOGGING_ENABLED =
+            "loggingEnabled"
+        private const val KEY_ALLOW_MOCK_LOCATIONS =
+            "allowMockLocations"
+    }
+
+}
+
+