hypertrack-sdk-react-native 13.5.0 → 13.5.1

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

@@ -20,14 +20,13 @@ 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
@@ -181,39 +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)
-            }
-
-            HyperTrack.subscribeToOrders {
-                emitEvent(EVENT_ORDERS, serializeOrders(it.values).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,

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

@@ -31,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)!!
@@ -60,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) {
@@ -84,116 +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 getOrders(): WrapperResult<Serialized> {
-        return Success(
+    fun getOrders(): WrapperResult<Serialized> =
+        Success(
             serializeOrders(HyperTrack.orders.values),
         )
-    }
 
-    fun getWorkerHandle(): WrapperResult<Serialized> {
-        return Success(
+    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
             }
-    }
 }