hypertrack-sdk-react-native 8.2.1 → 9.0.0

package/ios/common/HyperTrackSDKWrapper.swift

@@ -0,0 +1,118 @@
+import HyperTrack
+
+enum SuccessResult {
+    case void
+    case dict(Dictionary<String, Any>)
+}
+
+enum FailureResult: Error {
+    case fatalError(_ message: String)
+    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
+
+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,
+                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))
+            }
+        } else {
+            return .failure(.fatalError("Invalid publishable key"))
+        }
+    } else {
+        return .failure(.error("Invalid SDK init parameters \(params)"))
+    }
+}
+
+func getDeviceID() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeDeviceId(sdkInstance.deviceID)))
+}
+
+func getLocation() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeLocationResult(sdkInstance.location)))
+}
+
+func startTracking() -> Result<SuccessResult, FailureResult> {
+    .success(asVoid(sdkInstance.start()))
+}
+
+func stopTracking() -> Result<SuccessResult, FailureResult> {
+    .success(asVoid(sdkInstance.stop()))
+}
+
+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 setName(_ args: Dictionary<String, Any>) -> Result<SuccessResult, FailureResult> {
+    deserializeDeviceName(args).flatMap({ (name: String) in
+            .success(asVoid(sdkInstance.setDeviceName(name)))
+    })
+    
+}
+
+func setMetadata(_ map: Dictionary<String, Any>) -> Result<SuccessResult, FailureResult> {
+    sdkInstance.metadata = getJSON(map)
+    return .success(.void)
+}
+
+func isTracking() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeIsTracking(sdkInstance.isTracking)))
+}
+
+func isAvailable() -> Result<SuccessResult, FailureResult> {
+    .success(.dict(serializeIsAvailable(sdkInstance.availability)))
+}
+
+func addGeotag(_ args: Dictionary<String, Any>) -> Result<SuccessResult, FailureResult> {
+    return deserializeGeotagData(args).flatMap { data in
+        let metadata: HyperTrack.JSON.Object = getJSON(data)
+        let result = sdkInstance.addGeotag(metadata)
+        return .success(.dict(serializeLocationResult(result)))
+    }
+}
+
+func sync() -> Result<SuccessResult, FailureResult> {
+    .success(asVoid(sdkInstance.syncDeviceSettings()))
+}
+
+func asVoid(_ void: Void) -> SuccessResult {
+    .void
+}
+
+private func mapFatalError(fatalError: HyperTrack.FatalError) -> FailureResult {
+    switch fatalError {
+    case .developmentError(.missingLocationUpdatesBackgroundModeCapability):
+        return .fatalError("missingLocationUpdatesBackgroundModeCapability")
+    case .developmentError(.runningOnSimulatorUnsupported):
+        return .fatalError("runningOnSimulatorUnsupported")
+    case .productionError(.locationServicesUnavalible):
+        return .error("locationServicesUnavalible")
+    case .productionError(.motionActivityServicesUnavalible):
+        return .error("motionActivityServicesUnavalible")
+    case .productionError(.motionActivityPermissionsDenied):
+        return .fatalError("motionActivityPermissionsDenied")
+    }
+}

package/ios/common/SDKInitParams.swift

@@ -0,0 +1,11 @@
+public struct SDKInitParams {
+    let publishableKey: String
+    let loggingEnabled: Bool
+    let allowMockLocations: Bool
+    
+    init?(_ map: Dictionary<String, Any>) {
+        self.publishableKey = (map["publishableKey"] as! String)
+        self.loggingEnabled = (map["loggingEnabled"] as! Bool)
+        self.allowMockLocations = (map["allowMockLocations"] as! Bool)
+    }
+}

package/ios/common/SDKMethod.swift

@@ -0,0 +1,14 @@
+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"
+}

package/ios/common/Serialization.swift

@@ -0,0 +1,270 @@
+import HyperTrack
+
+private let keyType = "type"
+private let keyValue = "value"
+
+private let typeSuccess = "success"
+private let typeFailure = "failure"
+private let typeHyperTrackError = "hyperTrackError"
+private let typeIsTracking = "isTracking"
+private let typeIsAvailable = "isAvailable"
+
+let keyGeotagData = "data"
+
+func getJSON(_ dictionary: Dictionary<String, Any>) -> HyperTrack.JSON.Object {
+    return try! DictionaryDecoder().decode(HyperTrack.JSON.Object.self, from: dictionary)
+}
+
+func getHyperTrackError(_ error: HyperTrack.UnrestorableError) -> HyperTrackError {
+    switch(error) {
+    case .invalidPublishableKey:
+        return HyperTrackError.invalidPublishableKey
+    case .motionActivityPermissionsDenied:
+        return HyperTrackError.locationPermissionsDenied
+    }
+}
+
+func getHyperTrackError(_ error: HyperTrack.RestorableError) -> HyperTrackError {
+    switch(error) {
+    case .locationPermissionsNotDetermined:
+        return HyperTrackError.locationPermissionsNotDetermined
+    case .motionActivityPermissionsNotDetermined:
+        return HyperTrackError.motionActivityPermissionsNotDetermined
+    case .locationPermissionsCantBeAskedInBackground:
+        return HyperTrackError.locationPermissionsNotDetermined
+    case .motionActivityPermissionsCantBeAskedInBackground:
+        return HyperTrackError.motionActivityPermissionsNotDetermined
+    case .locationPermissionsRestricted:
+        return HyperTrackError.locationPermissionsRestricted
+    case .motionActivityPermissionsRestricted:
+        return HyperTrackError.motionActivityPermissionsRestricted
+    case .locationPermissionsDenied:
+        return HyperTrackError.locationPermissionsDenied
+    case .locationPermissionsInsufficientForBackground:
+        return HyperTrackError.locationPermissionsInsufficientForBackground
+    case .locationServicesDisabled:
+        return HyperTrackError.locationServicesDisabled
+    case .motionActivityServicesDisabled:
+        return HyperTrackError.motionActivityServicesDisabled
+    case .networkConnectionUnavailable:
+        return HyperTrackError.networkConnectionUnavailable
+    case .trialEnded:
+        return HyperTrackError.blockedFromRunning
+    case .paymentDefault:
+        return HyperTrackError.blockedFromRunning
+    }
+}
+
+func getHyperTrackError(_ error: HyperTrack.HyperTrackError) -> HyperTrackError {
+    switch(error) {
+    case .locationPermissionsNotDetermined:
+        return .locationPermissionsNotDetermined
+    case .locationPermissionsInsufficientForBackground:
+        return .locationPermissionsInsufficientForBackground
+    case .locationPermissionsRestricted:
+        return .locationPermissionsRestricted
+    case .locationPermissionsReducedAccuracy:
+        return .locationPermissionsReducedAccuracy
+    case .locationPermissionsProvisional:
+        return .locationPermissionsProvisional
+    case .locationPermissionsDenied:
+        return .locationPermissionsDenied
+    case .locationServicesDisabled:
+        return .locationServicesDisabled
+    case .motionActivityPermissionsNotDetermined:
+        return .motionActivityPermissionsNotDetermined
+    case .motionActivityPermissionsDenied:
+        return .motionActivityPermissionsDenied
+    case .motionActivityServicesDisabled:
+        return .motionActivityServicesDisabled
+    case .motionActivityServicesUnavailable:
+        return .motionActivityServicesUnavailable
+    case .gpsSignalLost:
+        return .gpsSignalLost
+    case .locationMocked:
+        return .locationMocked
+    case .invalidPublishableKey:
+        return .invalidPublishableKey
+    case .blockedFromRunning:
+        return .blockedFromRunning
+    default:
+        preconditionFailure("Unknown error \(error)")
+    }
+}
+
+func serializeErrors(_ errors: Set<HyperTrack.HyperTrackError>) -> Array<Dictionary<String, Any>> {
+    return errors.map({ error in
+        serializeHyperTrackError(getHyperTrackError(error))
+    })
+}
+
+func serializeDeviceId(_ deviceId: String) -> Dictionary<String, Any> {
+    return [
+        keyType: "deviceID",
+        keyValue: deviceId
+    ]
+}
+
+func serializeLocationResult(_ result: Result<HyperTrack.Location, HyperTrack.LocationError>) -> Dictionary<String, Any>  {
+    switch (result) {
+    case .success(let success):
+        return [
+            keyType: typeSuccess,
+            keyValue: [
+                keyType: "location",
+                keyValue: [
+                    "latitude": success.latitude,
+                    "longitude": success.longitude
+                ]
+            ]
+        ]
+    case .failure(let failure):
+        var locationError: Dictionary<String, Any>
+        switch(failure) {
+        case .locationPermissionsNotDetermined:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.locationPermissionsNotDetermined)
+        case .locationPermissionsCantBeAskedInBackground:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.locationPermissionsNotDetermined)
+        case .locationPermissionsInsufficientForBackground:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.locationPermissionsInsufficientForBackground)
+        case .locationPermissionsRestricted:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.locationPermissionsRestricted)
+        case .locationPermissionsReducedAccuracy:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.locationPermissionsReducedAccuracy)
+        case .locationPermissionsDenied:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.locationPermissionsDenied)
+        case .locationServicesDisabled:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.locationServicesDisabled)
+        case .motionActivityPermissionsNotDetermined:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.motionActivityPermissionsNotDetermined)
+        case .motionActivityPermissionsCantBeAskedInBackground:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.motionActivityPermissionsNotDetermined)
+        case .motionActivityPermissionsDenied:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.motionActivityPermissionsDenied)
+        case .motionActivityServicesDisabled:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.motionActivityServicesDisabled)
+
+        case .gpsSignalLost:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.gpsSignalLost)
+        case .locationMocked:
+            locationError = serializeHyperTrackErrorAsLocationError(HyperTrackError.locationMocked)
+        case .starting:
+            locationError = [
+                keyType: "starting"
+            ]
+        case .notRunning:
+            locationError = [
+                keyType: "notRunning"
+            ]
+        }
+
+        return [
+            keyType: typeFailure,
+            keyValue: locationError
+        ]
+    }
+}
+
+func serializeLocationResult(_ result: Result<HyperTrack.Location, HyperTrack.NoLocationError>) -> Dictionary<String, Any>  {
+    switch (result) {
+    case .success(let success):
+        return [
+            keyType: typeSuccess,
+            keyValue: [
+                keyType: "location",
+                keyValue: [
+                    "latitude": success.latitude,
+                    "longitude": success.longitude
+                ]
+            ]
+        ]
+    case .failure(let failure):
+        var locationError: Dictionary<String, Any>
+        switch(failure) {
+        case .starting:
+            locationError = [
+                keyType: "starting"
+            ]
+        case .notRunning:
+            locationError = [
+                keyType: "notRunning"
+            ]
+        case .errors(let errors):
+            locationError = [
+                keyType: "errors",
+                keyValue: serializeErrors(errors)
+            ]
+        }
+        
+        return [
+            keyType: typeFailure,
+            keyValue: locationError
+        ]
+    }
+}
+
+func serializeHyperTrackErrorAsLocationError(_ error: HyperTrackError) -> Dictionary<String, Any> {
+    return [
+        keyType: "errors",
+        keyValue: [
+            [
+                keyType: typeHyperTrackError,
+                keyValue: error.rawValue
+            ]
+        ]
+    ]
+}
+
+func serializeHyperTrackError(_ error: HyperTrackError) -> Dictionary<String, Any> {
+    return [
+        keyType: typeHyperTrackError,
+        keyValue: error.rawValue
+    ]
+}
+
+func serializeIsTracking(_ isTracking: Bool) -> Dictionary<String, Any> {
+    return [
+        keyType: typeIsTracking,
+        keyValue: isTracking
+    ]
+}
+
+func serializeIsAvailable(_ isAvailable: HyperTrack.Availability) -> Dictionary<String, Any> {
+    return [
+        keyType: typeIsAvailable,
+        keyValue: isAvailable == .available
+    ]
+}
+
+func deserializeDeviceName(_ data: Dictionary<String, Any>) -> Result<String, FailureResult> {
+    if (data[keyType] as? String != "deviceName") {
+        return .failure(.fatalError(getParseError(data, key: keyType)))
+    }
+    guard let value = data[keyValue] as? String else {
+        return .failure(.fatalError(getParseError(data, key: keyValue)))
+    }
+    return .success(value)
+}
+
+func deserializeAvailability(_ data: Dictionary<String, Any>) -> Result<Bool, FailureResult> {
+    if (data[keyType] as? String != typeIsAvailable) {
+        return .failure(.fatalError(getParseError(data, key: keyType)))
+    }
+    guard let value = data[keyValue] as? Bool else {
+        return .failure(.fatalError(getParseError(data, key: keyValue)))
+    }
+    return .success(value)
+}
+
+func deserializeGeotagData(
+    _ geotag: Dictionary<String, Any>
+) -> Result<Dictionary<String, Any>, FailureResult> {
+    guard let data = geotag[keyGeotagData] as? Dictionary<String, Any> else {
+        return .failure(.fatalError(getParseError(geotag, key: keyGeotagData)))
+    }
+    return .success(data)
+}
+
+func getParseError(_ data: Any, key: String) -> String {
+    return "Invalid input for key \(key): \(data)"
+}