hypertrack-sdk-react-native 8.2.1 → 9.0.0

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

@@ -0,0 +1,20 @@
+package com.reactnativehypertracksdk.common
+
+/**
+ * The list of available methods in the SDK API.
+ * Enum naming convention is ignored to make datatype sync across platforms easier
+ */
+internal enum class SdkMethod {
+    initialize,
+    getDeviceId,
+    getLocation,
+    startTracking,
+    stopTracking,
+    setAvailability,
+    setName,
+    setMetadata,
+    isTracking,
+    isAvailable,
+    addGeotag,
+    sync
+}

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

@@ -0,0 +1,196 @@
+package com.reactnativehypertracksdk.common
+
+import android.location.Location
+
+/**
+ * Platform-independent serialization code that converts HyperTrack data types
+ * to Map<String, T> or List<T> where T is any JSON-compatible type
+ */
+internal object Serialization {
+
+    fun serializeErrors(errors: Set<HyperTrackError>): List<Map<String, String>> {
+        return errors.map {
+            serializeHypertrackError(it)
+        }
+    }
+
+    fun serializeSuccess(location: Location): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_RESULT_SUCCESS,
+            KEY_VALUE to serializeLocation(location)
+        )
+    }
+
+    fun serializeFailure(locationError: LocationError): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_RESULT_FAILURE,
+            KEY_VALUE to serializeLocationError(locationError)
+        )
+    }
+
+    fun serializeIsTracking(isTracking: Boolean): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_IS_TRACKING,
+            KEY_VALUE to isTracking
+        )
+    }
+
+    fun serializeIsAvailable(isAvailable: Boolean): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_AVAILABILITY,
+            KEY_VALUE to isAvailable
+        )
+    }
+
+    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,
+            KEY_VALUE to error.name
+        )
+    }
+
+    fun serializeDeviceId(deviceId: String): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_DEVICE_ID,
+            KEY_VALUE to deviceId
+        )
+    }
+
+    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 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 deserializeGeotagData(map: Map<String, Any?>): Result<Geotag> {
+        return parse(map) {
+            val data = it.get<Map<String, Any?>>(KEY_GEOTAG_DATA).getOrThrow()
+            Geotag(data)
+        }
+    }
+
+    fun <T> parse(
+        source: Map<String, Any?>,
+        parseFunction: (ParsingHandle) -> T
+    ): Result<T> {
+        val handle = ParsingHandle(source);
+        return try {
+            if (handle.exceptions.isEmpty()) {
+                Success(parseFunction.invoke(handle))
+            } else {
+                Failure(ParsingExceptions(source, handle.exceptions))
+            }
+        } catch (e: Exception) {
+            Failure(
+                if (handle.exceptions.isNotEmpty()) {
+                    ParsingExceptions(source, handle.exceptions + e)
+                } else {
+                    e
+                }
+            )
+        }
+    }
+
+    internal class ParsingHandle(
+        private val source: Map<String, Any?>,
+    ) {
+        private val _exceptions = mutableListOf<Exception>()
+        val exceptions: List<Exception> = _exceptions
+
+        inline fun <reified T> get(
+            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
+        ) {
+            if (source[key] != value) {
+                _exceptions.add(Exception("Assertion failed: $key != $value"))
+            }
+        }
+    }
+
+    internal data class ParsingExceptions(
+        val source: Any,
+        val exceptions: List<Exception>
+    ) : Throwable(exceptions.joinToString("\n").let {
+        "Invalid input:\n\n${source}\n\n${it}"
+    })
+
+    internal class ParsingException(
+        key: String,
+        exception: Exception
+    ) : Exception("Invalid value for '$key': $exception", exception)
+
+    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_LOCATION = "location"
+    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_IS_TRACKING = "isTracking"
+
+    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_GEOTAG_DATA = "data"
+
+}
+
+

package/hypertrack-sdk-react-native.podspec

@@ -12,13 +12,13 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => "10.0" }
+  s.platforms    = { :ios => "11.0" }
   s.source       = { :git => "https://github.com/hypertrack/sdk-react-native.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency 'HyperTrack/Objective-C', '4.13.0'
+  s.dependency 'HyperTrack/Objective-C', '4.14.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/HyperTrackReactNativePlugin.m

@@ -0,0 +1,54 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(HyperTrackReactNativePlugin, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(supportedEvents)
+
+RCT_EXTERN_METHOD(addListener)
+
+RCT_EXTERN_METHOD(requiresMainQueueSetup)
+
+RCT_EXTERN_METHOD(initializeSdk:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getDeviceId:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getLocation:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(startTracking:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(stopTracking:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(isTracking:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(isAvailable:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(sync:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setAvailability:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setName:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setMetadata:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(addGeotag:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+
+@end

package/ios/HyperTrackReactNativePlugin.swift

@@ -0,0 +1,253 @@
+import HyperTrack
+
+@objc(HyperTrackReactNativePlugin)
+class HyperTrackReactNativePlugin: RCTEventEmitter {
+    
+    private let eventTracking = "onTrackingChanged"
+    private let eventAvailability = "onAvailabilityChanged"
+    private let eventErrors = "onError"
+    
+    private var isTrackingSubscription: HyperTrack.Cancellable!
+    private var availabilitySubscription: HyperTrack.Cancellable!
+    private var errorsSubscription: HyperTrack.Cancellable!
+    
+    @objc override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    @objc override func supportedEvents() -> [String] {
+        return [
+            eventTracking,
+            eventAvailability,
+            eventErrors
+        ]
+    }
+    
+    @objc override func addListener(_ eventName: String) {
+        super.addListener(eventName)
+        switch(eventName) {
+        case eventTracking:
+            sendEvent(withName: eventTracking, body: serializeIsTracking(sdkInstance.isTracking))
+        case eventAvailability:
+            sendEvent(withName: eventAvailability, body: serializeIsAvailable(sdkInstance.availability))
+        case eventErrors:
+            sendEvent(withName: eventErrors, body: serializeErrors(sdkInstance.errors))
+        default:
+            return
+        }
+    }
+    
+    /// Method name is changed from 'initialize' because RCTEventEmitter has a method with the same name
+    @objc func initializeSdk(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.initializeSDK(
+                args as! Dictionary<String, Any>
+            ).map({ (result:SuccessResult) in
+                initListeners()
+                return result
+            }),
+            method: .initialize,
+            resolve,
+            reject
+        )
+        
+    }
+    
+    @objc func getDeviceId(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.getDeviceID(),
+            method: .getDeviceId,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func setName(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.setName(args as! Dictionary<String, Any>),
+            method: .setName,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func setMetadata(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.setMetadata(
+                args as! Dictionary<String, Any>
+            ),
+            method: .setMetadata,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func getLocation(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.getLocation(),
+            method: .getLocation,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func startTracking(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.startTracking(),
+            method: .startTracking,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func stopTracking(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.stopTracking(),
+            method: .stopTracking,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func setAvailability(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.setAvailability(
+                args as! Dictionary<String, Any>
+            ),
+            method: .setAvailability,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func isTracking(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.isTracking(),
+            method: .isTracking,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func isAvailable(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.isAvailable(),
+            method: .isAvailable,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func addGeotag(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.addGeotag(
+                args as! Dictionary<String, Any>
+            ),
+            method: .addGeotag,
+            resolve,
+            reject
+        )
+    }
+    
+    @objc func sync(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.sync(),
+            method: .sync,
+            resolve,
+            reject
+        )
+    }
+    
+    private func initListeners() {
+        isTrackingSubscription = sdkInstance.subscribeToIsTracking(callback: { isTracking in
+            self.sendTrackingEvent(isTracking: isTracking)
+        })
+        availabilitySubscription = sdkInstance.subscribeToAvailability(callback: { availability in
+            self.sendAvailabilityEvent(availability: availability)
+        })
+        errorsSubscription = sdkInstance.subscribeToErrors { errors in
+            self.sendErrorsEvent(errors)
+        }
+    }
+    
+    private func sendTrackingEvent(isTracking: Bool) {
+        sendEvent(withName: eventTracking, body: serializeIsTracking(isTracking))
+    }
+    private func sendAvailabilityEvent(availability: HyperTrack.Availability) {
+        sendEvent(withName: eventAvailability, body: serializeIsAvailable(availability))
+    }
+    
+    private func sendErrorsEvent(_ errors: Set<HyperTrack.HyperTrackError>) {
+        sendEvent(withName: eventErrors, body: serializeErrors(errors))
+    }
+    
+}
+
+private func sendAsPromise(
+    _ result: Result<SuccessResult, FailureResult>,
+    method: SDKMethod,
+    _ resolve: RCTPromiseResolveBlock,
+    _ reject: RCTPromiseRejectBlock
+) {
+    switch result {
+    case .success(let success):
+        switch (success) {
+        case .void:
+            resolve(nil)
+        case .dict(let value):
+            resolve(value)
+        }
+    case .failure(let failure):
+        switch(failure) {
+        case .error(let message):
+            reject(
+                "method_call_error",
+                "\(method.rawValue): \(message)",
+                NSError.init(domain: "com.hypertrack.sdk.reactnative.ios", code: 0, userInfo: nil)
+            )
+        case .fatalError(let message):
+            preconditionFailure(message)
+        }
+    }
+}

package/ios/HyperTrackSdk-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>

package/ios/HyperTrackSdk.xcodeproj/project.pbxproj

@@ -6,10 +6,6 @@
 	objectVersion = 46;
 	objects = {
 
-/* Begin PBXBuildFile section */
-		12CFB2D62872FAE100FEE5E6 /* HyperTrack.m in Sources */ = {isa = PBXBuildFile; fileRef = 12CFB2D52872FAE100FEE5E6 /* HyperTrack.m */; };
-/* End PBXBuildFile section */
-
 /* Begin PBXCopyFilesBuildPhase section */
 		58B511D91A9E6C8500147676 /* CopyFiles */ = {
 			isa = PBXCopyFilesBuildPhase;
@@ -23,10 +19,11 @@
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
-		12CFB2D52872FAE100FEE5E6 /* HyperTrack.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = HyperTrack.m; sourceTree = "<group>"; };
-		12CFB2D72872FAFE00FEE5E6 /* HyperTrack.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = HyperTrack.h; sourceTree = "<group>"; };
+		0AAF11002923F18800A50DA1 /* HyperTrackReactNativePlugin.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = HyperTrackReactNativePlugin.m; sourceTree = "<group>"; };
+		0AAF11012923F18800A50DA1 /* common */ = {isa = PBXFileReference; lastKnownFileType = folder; path = common; sourceTree = "<group>"; };
+		0AAF11022923F18800A50DA1 /* HyperTrackReactNativePlugin.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HyperTrackReactNativePlugin.swift; sourceTree = "<group>"; };
+		0AAF11062923FED200A50DA1 /* HyperTrackSdk-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "HyperTrackSdk-Bridging-Header.h"; sourceTree = "<group>"; };
 		134814201AA4EA6300B7C361 /* libHyperTrackSdk.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libHyperTrackSdk.a; sourceTree = BUILT_PRODUCTS_DIR; };
-		F4FF95D5245B92E700C19C63 /* HyperTrackSdk-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "HyperTrackSdk-Bridging-Header.h"; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -51,9 +48,10 @@
 		58B511D21A9E6C8500147676 = {
 			isa = PBXGroup;
 			children = (
-				12CFB2D52872FAE100FEE5E6 /* HyperTrack.m */,
-				12CFB2D72872FAFE00FEE5E6 /* HyperTrack.h */,
-				F4FF95D5245B92E700C19C63 /* HyperTrackSdk-Bridging-Header.h */,
+				0AAF11062923FED200A50DA1 /* HyperTrackSdk-Bridging-Header.h */,
+				0AAF11012923F18800A50DA1 /* common */,
+				0AAF11002923F18800A50DA1 /* HyperTrackReactNativePlugin.m */,
+				0AAF11022923F18800A50DA1 /* HyperTrackReactNativePlugin.swift */,
 				134814211AA4EA7D00B7C361 /* Products */,
 			);
 			sourceTree = "<group>";
@@ -115,7 +113,6 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				12CFB2D62872FAE100FEE5E6 /* HyperTrack.m in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

package/ios/common/DictionaryDecoder.swift

@@ -0,0 +1,28 @@
+class DictionaryDecoder {
+    private let decoder = JSONDecoder()
+    
+    var dateDecodingStrategy: JSONDecoder.DateDecodingStrategy {
+        set { decoder.dateDecodingStrategy = newValue }
+        get { decoder.dateDecodingStrategy }
+    }
+    
+    var dataDecodingStrategy: JSONDecoder.DataDecodingStrategy {
+        set { decoder.dataDecodingStrategy = newValue }
+        get { decoder.dataDecodingStrategy }
+    }
+    
+    var nonConformingFloatDecodingStrategy: JSONDecoder.NonConformingFloatDecodingStrategy {
+        set { decoder.nonConformingFloatDecodingStrategy = newValue }
+        get { decoder.nonConformingFloatDecodingStrategy }
+    }
+    
+    var keyDecodingStrategy: JSONDecoder.KeyDecodingStrategy {
+        set { decoder.keyDecodingStrategy = newValue }
+        get { decoder.keyDecodingStrategy }
+    }
+    
+    func decode<T>(_ type: T.Type, from dictionary: [String: Any]) throws -> T where T: Decodable {
+        let data = try JSONSerialization.data(withJSONObject: dictionary, options: [])
+        return try decoder.decode(type, from: data)
+    }
+}

package/ios/common/HyperTrackError.swift

@@ -0,0 +1,20 @@
+enum HyperTrackError: String {
+    case gpsSignalLost
+    case locationMocked
+    case locationPermissionsDenied
+    case locationPermissionsInsufficientForBackground
+    case locationPermissionsNotDetermined
+    case locationPermissionsReducedAccuracy
+    case locationPermissionsProvisional
+    case locationPermissionsRestricted
+    case locationServicesDisabled
+    case locationServicesUnavailable
+    case motionActivityPermissionsNotDetermined
+    case motionActivityPermissionsDenied
+    case motionActivityServicesDisabled
+    case motionActivityServicesUnavailable
+    case motionActivityPermissionsRestricted
+    case networkConnectionUnavailable
+    case invalidPublishableKey
+    case blockedFromRunning
+}