hypertrack-sdk-react-native 10.0.3 → 11.0.1

package/ios/HyperTrackReactNativePlugin.swift

@@ -1,62 +1,77 @@
 import HyperTrack
 
+struct Subscriptions {
+    let locationSubscription: HyperTrack.Cancellable
+    let isAvailableSubscription: HyperTrack.Cancellable
+    let isTrackingSubscription: HyperTrack.Cancellable
+    let errorsSubscription: HyperTrack.Cancellable
+}
+
 @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!
-    
+    private let eventErrors = "errors"
+    private let eventIsAvailable = "isAvailable"
+    private let eventIsTracking = "isTracking"
+    private let eventLocate = "locate"
+    private let eventLocation = "location"
+
+    private var subscriptions: Subscriptions? = nil
+    private var locateSubscription: HyperTrack.Cancellable? = nil
+
     @objc override static func requiresMainQueueSetup() -> Bool {
         return false
     }
-    
+
     @objc override func supportedEvents() -> [String] {
         return [
-            eventTracking,
-            eventAvailability,
-            eventErrors
+            eventErrors,
+            eventIsAvailable,
+            eventIsTracking,
+            eventLocate,
+            eventLocation,
         ]
     }
-    
+
     @objc override func addListener(_ eventName: String) {
+        // Called when any listener is added.
         super.addListener(eventName)
-        switch(eventName) {
-        case eventTracking:
-            sendEvent(withName: eventTracking, body: serializeIsTracking(sdkInstance.isTracking))
-        case eventAvailability:
-            sendEvent(withName: eventAvailability, body: serializeIsAvailable(sdkInstance.availability))
+        /*
+         Due to the issue in RN (probably related to the fact that the SDK calls the subscription
+         callback too fast) we can't init listener in init() anymore.
+         So we init them lazily here.
+         */
+        if subscriptions == nil {
+            subscriptions = initListeners()
+        }
+        switch eventName {
+        case eventIsTracking:
+            sendEvent(withName: eventIsTracking, body: serializeIsTracking(HyperTrack.isTracking))
+        case eventIsAvailable:
+            sendEvent(withName: eventIsAvailable, body: serializeIsAvailable(HyperTrack.isAvailable))
         case eventErrors:
-            sendEvent(withName: eventErrors, body: serializeErrors(sdkInstance.errors))
+            sendEvent(withName: eventErrors, body: serializeErrors(HyperTrack.errors))
+        case eventLocation:
+            sendEvent(withName: eventLocation, body: serializeLocationResult(HyperTrack.location))
         default:
             return
         }
     }
-    
-    /// Method name is changed from 'initialize' because RCTEventEmitter has a method with the same name
-    @objc func initializeSdk(
+
+    @objc func addGeotag(
         _ 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,
+            hypertrack_sdk_react_native.addGeotag(
+                args as! [String: Any]
+            ),
+            method: .addGeotag,
             resolve,
             reject
         )
-        
     }
-    
+
     @objc func getDeviceId(
         _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
@@ -68,35 +83,43 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
             reject
         )
     }
-    
-    @objc func setName(
-        _ args: NSDictionary,
-        resolver resolve: RCTPromiseResolveBlock,
+
+    @objc func getErrors(
+        _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
         sendAsPromise(
-            hypertrack_sdk_react_native.setName(args as! Dictionary<String, Any>),
-            method: .setName,
+            hypertrack_sdk_react_native.getErrors(),
+            method: .getErrors,
             resolve,
             reject
         )
     }
-    
-    @objc func setMetadata(
-        _ args: NSDictionary,
-        resolver resolve: RCTPromiseResolveBlock,
+
+    @objc func getIsAvailable(
+        _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
         sendAsPromise(
-            hypertrack_sdk_react_native.setMetadata(
-                args as! Dictionary<String, Any>
-            ),
-            method: .setMetadata,
+            hypertrack_sdk_react_native.getIsAvailable(),
+            method: .getIsAvailable,
+            resolve,
+            reject
+        )
+    }
+
+    @objc func getIsTracking(
+        _ resolve: RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        sendAsPromise(
+            hypertrack_sdk_react_native.getIsTracking(),
+            method: .getIsTracking,
             resolve,
             reject
         )
     }
-    
+
     @objc func getLocation(
         _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
@@ -108,120 +131,122 @@ class HyperTrackReactNativePlugin: RCTEventEmitter {
             reject
         )
     }
-    
-    @objc func startTracking(
+
+    @objc func getMetadata(
         _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
         sendAsPromise(
-            hypertrack_sdk_react_native.startTracking(),
-            method: .startTracking,
+            hypertrack_sdk_react_native.getMetadata(),
+            method: .getMetadata,
             resolve,
             reject
         )
     }
-    
-    @objc func stopTracking(
+
+    @objc func getName(
         _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
         sendAsPromise(
-            hypertrack_sdk_react_native.stopTracking(),
-            method: .stopTracking,
+            hypertrack_sdk_react_native.getName(),
+            method: .getName,
             resolve,
             reject
         )
     }
-    
-    @objc func setAvailability(
-        _ args: NSDictionary,
-        resolver resolve: RCTPromiseResolveBlock,
+
+    @objc func locate(
+        _ resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
+        if let locateSubscription = locateSubscription {
+            locateSubscription.cancel()
+        }
+        locateSubscription = HyperTrack.locate { locateResult in
+            self.sendEvent(withName: self.eventLocate, body: serializeLocateResult(locateResult))
+        }
         sendAsPromise(
-            hypertrack_sdk_react_native.setAvailability(
-                args as! Dictionary<String, Any>
-            ),
-            method: .setAvailability,
+            .success(.void),
+            method: .locate,
             resolve,
             reject
         )
     }
-    
-    @objc func isTracking(
-        _ resolve: RCTPromiseResolveBlock,
+
+    @objc func setIsAvailable(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
         sendAsPromise(
-            hypertrack_sdk_react_native.isTracking(),
-            method: .isTracking,
+            hypertrack_sdk_react_native.setIsAvailable(
+                args as! [String: Any]
+            ),
+            method: .setIsAvailable,
             resolve,
             reject
         )
     }
-    
-    @objc func isAvailable(
-        _ resolve: RCTPromiseResolveBlock,
+
+    @objc func setMetadata(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
         sendAsPromise(
-            hypertrack_sdk_react_native.isAvailable(),
-            method: .isAvailable,
+            hypertrack_sdk_react_native.setMetadata(
+                args as! [String: Any]
+            ),
+            method: .setMetadata,
             resolve,
             reject
         )
     }
-    
-    @objc func addGeotag(
+
+    @objc func setName(
         _ args: NSDictionary,
         resolver resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
         sendAsPromise(
-            hypertrack_sdk_react_native.addGeotag(
-                args as! Dictionary<String, Any>
-            ),
-            method: .addGeotag,
+            hypertrack_sdk_react_native.setName(args as! [String: Any]),
+            method: .setName,
             resolve,
             reject
         )
     }
-    
-    @objc func sync(
-        _ resolve: RCTPromiseResolveBlock,
+
+    @objc func setIsTracking(
+        _ args: NSDictionary,
+        resolver resolve: RCTPromiseResolveBlock,
         rejecter reject: RCTPromiseRejectBlock
     ) {
         sendAsPromise(
-            hypertrack_sdk_react_native.sync(),
-            method: .sync,
+            hypertrack_sdk_react_native.setIsTracking(
+                args as! [String: Any]
+            ),
+            method: .setIsTracking,
             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 initListeners() -> Subscriptions {
+        let errorsSubscription = HyperTrack.subscribeToErrors { errors in
+            self.sendEvent(withName: self.eventErrors, body: serializeErrors(errors))
         }
+        let isAvailableSubscription = HyperTrack.subscribeToIsAvailable { [self] isAvailable in
+            self.sendEvent(withName: self.eventIsAvailable, body: serializeIsAvailable(isAvailable))
+        }
+        let isTrackingSubscription = HyperTrack.subscribeToIsTracking { isTracking in
+            self.sendEvent(withName: self.eventIsTracking, body: serializeIsTracking(isTracking))
+        }
+        let locationSubscription = HyperTrack.subscribeToLocation { locationResult in
+            self.sendEvent(withName: self.eventLocation, body: serializeLocationResult(locationResult))
+        }
+        return Subscriptions(locationSubscription: locationSubscription, isAvailableSubscription: isAvailableSubscription, isTrackingSubscription: isTrackingSubscription, errorsSubscription: errorsSubscription)
     }
-    
-    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(
@@ -231,22 +256,24 @@ private func sendAsPromise(
     _ reject: RCTPromiseRejectBlock
 ) {
     switch result {
-    case .success(let success):
-        switch (success) {
+    case let .success(success):
+        switch success {
         case .void:
             resolve(nil)
-        case .dict(let value):
+        case let .dict(value):
+            resolve(value)
+        case let .array(value):
             resolve(value)
         }
-    case .failure(let failure):
-        switch(failure) {
-        case .error(let message):
+    case let .failure(failure):
+        switch failure {
+        case let .error(message):
             reject(
                 "method_call_error",
                 "\(method.rawValue): \(message)",
-                NSError.init(domain: "com.hypertrack.sdk.reactnative.ios", code: 0, userInfo: nil)
+                NSError(domain: "com.hypertrack.sdk.reactnative.ios", code: 0, userInfo: nil)
             )
-        case .fatalError(let message):
+        case let .fatalError(message):
             preconditionFailure(message)
         }
     }

package/ios/common/DictionaryDecoder.swift

@@ -1,26 +1,26 @@
 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/HyperTrackSDKWrapper.swift

@@ -2,7 +2,8 @@ import HyperTrack
 
 enum SuccessResult {
     case void
-    case dict(Dictionary<String, Any>)
+    case dict([String: Any])
+    case array([Any])
 }
 
 enum FailureResult: Error {
@@ -10,116 +11,81 @@ enum FailureResult: Error {
     case error(_ message: String)
 }
 
-var sdkInstance: HyperTrack! // initialize method is guaranteed to be called (by non-native side) prior to any access to the SDK instance
-
-// method is named 'initializeSDK' to avoid conflict with React Native plugin 'initialize' method
-func initializeSDK(
-    _ params: Dictionary<String, Any>
-) -> Result<SuccessResult, FailureResult> {
-    if let sdkInitParams = SDKInitParams(params) {
-        let publishableKey = HyperTrack.PublishableKey(params["publishableKey"] as! String)
-        if let publishableKey = publishableKey {
-            switch HyperTrack.makeSDK(
-                publishableKey: publishableKey,
-                automaticallyRequestPermissions: sdkInitParams.automaticallyRequestPermissions,
-                mockLocationsAllowed: sdkInitParams.allowMockLocations
-            ) {
-            case let .success(hyperTrack):
-                sdkInstance = hyperTrack
-                HyperTrack.isLoggingEnabled = sdkInitParams.loggingEnabled
-                return .success(.void)
-            case let .failure(fatalError):
-                return .failure(mapFatalError(fatalError: fatalError))
+func addGeotag(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
+    return deserializeGeotagData(args).flatMap { geotagData in
+        if let metadata: HyperTrack.JSON.Object = toJSON(geotagData.data) {
+            if let expectedLocation = geotagData.expectedLocation {
+                let result = HyperTrack.addGeotag(metadata, expectedLocation: expectedLocation)
+                return .success(.dict(serializeLocationWithDeviationResult(result)))
+            } else {
+                let result = HyperTrack.addGeotag(metadata)
+                return .success(.dict(serializeLocationResult(result)))
             }
         } else {
-            return .failure(.fatalError("Invalid publishable key"))
+            return .failure(.error("Failed to deserialize geotag metadata"))
         }
-    } else {
-        return .failure(.error("Invalid SDK init parameters \(params)"))
     }
 }
 
 func getDeviceID() -> Result<SuccessResult, FailureResult> {
-    .success(.dict(serializeDeviceID(sdkInstance.deviceID)))
+    .success(.dict(serializeDeviceID(HyperTrack.deviceID)))
 }
 
-func getLocation() -> Result<SuccessResult, FailureResult> {
-    .success(.dict(serializeLocationResult(sdkInstance.location)))
+func getErrors() -> Result<SuccessResult, FailureResult> {
+    .success(.array(serializeErrors(HyperTrack.errors)))
 }
 
-func startTracking() -> Result<SuccessResult, FailureResult> {
-    .success(asVoid(sdkInstance.start()))
+func getMetadata() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeMetadata(HyperTrack.metadata)))
 }
 
-func stopTracking() -> Result<SuccessResult, FailureResult> {
-    .success(asVoid(sdkInstance.stop()))
+func getName() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeName(HyperTrack.name)))
 }
 
-func setAvailability(
-    _ availability: Dictionary<String, Any>
-) -> Result<SuccessResult, FailureResult> {
-    deserializeAvailability(availability).flatMap { (isAvailable:Bool) in
-        if(isAvailable) {
-            sdkInstance.availability = .available
-        } else {
-            sdkInstance.availability = .unavailable
-        }
-        return .success(.void)
-    }
+func getLocation() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeLocationResult(HyperTrack.location)))
 }
 
-func setName(_ args: Dictionary<String, Any>) -> Result<SuccessResult, FailureResult> {
-    deserializeDeviceName(args).flatMap({ (name: String) in
-        .success(asVoid(sdkInstance.setDeviceName(name)))
-    })
+func getIsAvailable() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeIsAvailable(HyperTrack.isAvailable)))
 }
 
-func setMetadata(_ map: Dictionary<String, Any>) -> Result<SuccessResult, FailureResult> {
-    sdkInstance.metadata = getJSON(map)
-    return .success(.void)
+func setIsAvailable(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
+    deserializeIsAvailable(args).flatMap { (isAvailable: Bool) in
+        HyperTrack.isAvailable = isAvailable
+        return .success(.void)
+    }
 }
 
-func isTracking() -> Result<SuccessResult, FailureResult> {
-    .success(.dict(serializeIsTracking(sdkInstance.isTracking)))
+func getIsTracking() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeIsTracking(HyperTrack.isTracking)))
 }
 
-func isAvailable() -> Result<SuccessResult, FailureResult> {
-    .success(.dict(serializeIsAvailable(sdkInstance.availability)))
+func setIsTracking(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
+    deserializeIsTracking(args).flatMap { (isTracking: Bool) in
+        HyperTrack.isTracking = isTracking
+        return .success(.void)
+    }
 }
 
-func addGeotag(_ args: Dictionary<String, Any>) -> Result<SuccessResult, FailureResult> {
-    return deserializeGeotagData(args).flatMap { geotagData in
-        let metadata: HyperTrack.JSON.Object = getJSON(geotagData.data)
-        if let expectedLocation = geotagData.expectedLocation {
-            let result = sdkInstance.addGeotag(metadata, expectedLocation: expectedLocation)
-            return .success(.dict(serializeExpectedLocationResult(result)))
+func setMetadata(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
+    deserializeMetadata(args).flatMap { map in
+        if let metadata = toJSON(map) {
+            HyperTrack.metadata = metadata
+            return .success(.void)
         } else {
-            let result = sdkInstance.addGeotag(metadata)
-            return .success(.dict(serializeLocationResult(result)))
+            return .failure(.error("Failed to deserialize metadata"))
         }
     }
 }
 
-func sync() -> Result<SuccessResult, FailureResult> {
-    .success(asVoid(sdkInstance.syncDeviceSettings()))
+func setName(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
+    deserializeName(args).flatMap { name in
+        .success(asVoid(HyperTrack.name = name))
+    }
 }
 
-func asVoid(_ void: Void) -> SuccessResult {
+func asVoid(_: Void) -> SuccessResult {
     .void
 }
-
-private func mapFatalError(fatalError: HyperTrack.FatalError) -> FailureResult {
-    switch fatalError {
-    case .developmentError(.missingLocationUpdatesBackgroundModeCapability):
-        return .fatalError("missingLocationUpdatesBackgroundModeCapability")
-    case .developmentError(.runningOnSimulatorUnsupported):
-        return .fatalError("runningOnSimulatorUnsupported")
-    // typo is in the HyperTrack SDK itself, no need to fix (it will be deleted in the next major update)
-    case .productionError(.locationServicesUnavalible):
-        return .error("locationServicesUnavalible")
-    case .productionError(.motionActivityServicesUnavalible):
-        return .error("motionActivityServicesUnavalible")
-    case .productionError(.motionActivityPermissionsDenied):
-        return .fatalError("motionActivityPermissionsDenied")
-    }
-}

package/ios/common/SDKMethod.swift

@@ -1,14 +1,15 @@
 enum SDKMethod: String {
-    case initialize = "initialize"
-    case getDeviceID = "getDeviceID"
-    case getLocation = "getLocation"
-    case startTracking = "startTracking"
-    case stopTracking = "stopTracking"
-    case setAvailability = "setAvailability"
-    case setName = "setName"
-    case setMetadata = "setMetadata"
-    case isTracking = "isTracking"
-    case isAvailable = "isAvailable"
-    case addGeotag = "addGeotag"
-    case sync = "sync"
+    case addGeotag
+    case getDeviceID
+    case getErrors
+    case getIsAvailable
+    case getIsTracking
+    case getLocation
+    case getMetadata
+    case getName
+    case locate
+    case setIsAvailable
+    case setIsTracking
+    case setMetadata
+    case setName
 }