hypertrack-sdk-react-native 10.0.3 → 11.0.0

package/ios/common/Serialization.swift

@@ -1,102 +1,82 @@
 import HyperTrack
 
+private let keyExpectedLocation = "expectedLocation"
+private let keyGeotagData = "data"
 private let keyType = "type"
 private let keyValue = "value"
-private let keyGeotagData = "data"
-private let keyExpectedLocation = "expectedLocation"
 
-private let typeSuccess = "success"
+private let typeError = "error"
 private let typeFailure = "failure"
-private let typeHyperTrackError = "hyperTrackError"
-private let typeIsTracking = "isTracking"
 private let typeIsAvailable = "isAvailable"
+private let typeIsTracking = "isTracking"
 private let typeLocation = "location"
+private let typeMetadata = "metadata"
+private let typeName = "name"
+private let typeSuccess = "success"
 
-func getJSON(_ dictionary: [String: Any]) -> HyperTrack.JSON.Object {
-    return try! DictionaryDecoder().decode(HyperTrack.JSON.Object.self, from: dictionary)
+func deserializeGeotagData(
+    _ args: [String: Any]
+) -> Result<GeotagData, FailureResult> {
+    guard let data = args[keyGeotagData] as? [String: Any] else {
+        return .failure(.fatalError(getParseError(args, key: keyGeotagData)))
+    }
+    if let expectedLocationData = args[keyExpectedLocation] as? [String: Any] {
+        let expectedLocation = deserializeLocation(expectedLocationData)
+        switch expectedLocation {
+        case let .failure(failure):
+            return .failure(failure)
+        case let .success(expectedLocation):
+            return .success(.init(data: data, expectedLocation: expectedLocation))
+        }
+    } else {
+        return .success(.init(data: data, expectedLocation: nil))
+    }
 }
 
-func getHyperTrackError(_ error: HyperTrack.UnrestorableError) -> HyperTrackError {
-    switch error {
-    case .invalidPublishableKey:
-        return HyperTrackError.invalidPublishableKey
-    case .motionActivityPermissionsDenied:
-        return HyperTrackError.locationPermissionsDenied
+func deserializeIsAvailable(_ data: [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 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 deserializeIsTracking(_ data: [String: Any]) -> Result<Bool, FailureResult> {
+    if data[keyType] as? String != typeIsTracking {
+        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 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 deserializeLocation(_ data: [String: Any]) -> Result<HyperTrack.Location, FailureResult> {
+    if data[keyType] as? String != typeLocation {
+        return .failure(.fatalError(getParseError(data, key: keyType)))
+    }
+    guard let value = data[keyValue] as? [String: Any] else {
+        return .failure(.fatalError(getParseError(data, key: keyValue)))
+    }
+    guard let latitude = value["latitude"] as? Double else {
+        return .failure(.fatalError(getParseError(value, key: "latitude")))
+    }
+    guard let longitude = value["longitude"] as? Double else {
+        return .failure(.fatalError(getParseError(value, key: "longitude")))
     }
+    return .success(.init(latitude: latitude, longitude: longitude))
 }
 
-func serializeErrors(_ errors: Set<HyperTrack.HyperTrackError>) -> [[String: Any]] {
-    return errors.map { error in
-        serializeHyperTrackError(getHyperTrackError(error))
+func deserializeName(_ data: [String: Any]) -> Result<String, FailureResult> {
+    if data[keyType] as? String != typeName {
+        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 serializeDeviceID(_ deviceID: String) -> [String: Any] {
@@ -106,65 +86,78 @@ func serializeDeviceID(_ deviceID: String) -> [String: Any] {
     ]
 }
 
-func serializeLocationResult(_ result: Result<HyperTrack.Location, HyperTrack.LocationError>) -> [String: Any] {
-    switch result {
+func serializeError(_ error: HyperTrack.Error) -> [String: Any] {
+    let value: String
+    switch error {
+    case .blockedFromRunning:
+        value = "blockedFromRunning"
+    case .invalidPublishableKey:
+        value = "invalidPublishableKey"
+    case let .location(location):
+        switch location {
+        case .mocked:
+            value = "location.mocked"
+        case .servicesDisabled:
+            value = "location.servicesDisabled"
+        case .signalLost:
+            value = "location.signalLost"
+        }
+    case let .permissions(permissionType):
+        switch permissionType {
+        case let .location(permission):
+            switch permission {
+            case .denied:
+                value = "permissions.location.denied"
+            case .insufficientForBackground:
+                value = "permissions.location.insufficientForBackground"
+            case .notDetermined:
+                value = "permissions.location.notDetermined"
+            case .provisional:
+                value = "permissions.location.provisional"
+            case .reducedAccuracy:
+                value = "permissions.location.reducedAccuracy"
+            case .restricted:
+                value = "permissions.location.restricted"
+            }
+        }
+    }
+
+    return [
+        keyType: typeError,
+        keyValue: value,
+    ]
+}
+
+func serializeIsAvailable(_ isAvailable: Bool) -> [String: Any] {
+    return [
+        keyType: typeIsAvailable,
+        keyValue: isAvailable,
+    ]
+}
+
+func serializeIsTracking(_ isTracking: Bool) -> [String: Any] {
+    return [
+        keyType: typeIsTracking,
+        keyValue: isTracking,
+    ]
+}
+
+func serializeLocateResult(_ locateResult: Result<HyperTrack.Location, Set<HyperTrack.Error>>) -> [String: Any] {
+    switch locateResult {
     case let .success(success):
         return [
             keyType: typeSuccess,
-            keyValue: [
-                keyType: typeLocation,
-                keyValue: [
-                    "latitude": success.latitude,
-                    "longitude": success.longitude,
-                ],
-            ],
+            keyValue: serializeLocation(success),
         ]
     case let .failure(failure):
-        var locationError: [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,
+            keyValue: serializeErrors(failure),
         ]
     }
 }
 
-private func serializeLocation(_ location: HyperTrack.Location) -> [String: Any] {
+func serializeLocation(_ location: HyperTrack.Location) -> [String: Any] {
     return [
         keyType: typeLocation,
         keyValue: [
@@ -174,49 +167,30 @@ private func serializeLocation(_ location: HyperTrack.Location) -> [String: Any]
     ]
 }
 
-func serializeLocationResult(_ result: Result<HyperTrack.Location, HyperTrack.NoLocationError>) -> [String: Any] {
-    switch result {
-    case let .success(success):
+func serializeLocationError(_ error: HyperTrack.Location.Error) -> [String: Any] {
+    switch error {
+    case .starting:
         return [
-            keyType: typeSuccess,
-            keyValue: serializeLocation(success),
+            keyType: "starting",
         ]
-    case let .failure(failure):
-        var locationError: [String: Any]
-        switch failure {
-        case .starting:
-            locationError = [
-                keyType: "starting",
-            ]
-        case .notRunning:
-            locationError = [
-                keyType: "notRunning",
-            ]
-        case let .errors(errors):
-            locationError = [
-                keyType: "errors",
-                keyValue: serializeErrors(errors),
-            ]
-        }
-
+    case .notRunning:
         return [
-            keyType: typeFailure,
-            keyValue: locationError,
+            keyType: "notRunning",
+        ]
+    case let .errors(errors):
+        return [
+            keyType: "errors",
+            keyValue: serializeErrors(errors),
         ]
     }
 }
 
-func serializeExpectedLocationResult(
-    _ result: Result<HyperTrack.LocationWithDeviation, HyperTrack.NoLocationError>
-) -> [String: Any] {
+func serializeLocationResult(_ result: Result<HyperTrack.Location, HyperTrack.Location.Error>) -> [String: Any] {
     switch result {
     case let .success(success):
         return [
             keyType: typeSuccess,
-            keyValue: [
-                keyType: "locationWithDeviation",
-                keyValue: serializeLocationWithDeviation(success),
-            ],
+            keyValue: serializeLocation(success),
         ]
     case let .failure(failure):
         return [
@@ -226,24 +200,6 @@ func serializeExpectedLocationResult(
     }
 }
 
-func serializeLocationError(_ error: HyperTrack.NoLocationError) -> [String: Any] {
-    switch error {
-    case .starting:
-        return [
-            keyType: "starting",
-        ]
-    case .notRunning:
-        return [
-            keyType: "notRunning",
-        ]
-    case let .errors(errors):
-        return [
-            keyType: "errors",
-            keyValue: serializeErrors(errors),
-        ]
-    }
-}
-
 func serializeLocationWithDeviation(
     _ locationWithDeviation: HyperTrack.LocationWithDeviation
 ) -> [String: Any] {
@@ -253,95 +209,84 @@ func serializeLocationWithDeviation(
     ]
 }
 
-func serializeHyperTrackErrorAsLocationError(_ error: HyperTrackError) -> [String: Any] {
-    return [
-        keyType: "errors",
-        keyValue: [
-            [
-                keyType: typeHyperTrackError,
-                keyValue: error.rawValue,
+func serializeLocationWithDeviationResult(
+    _ result: Result<HyperTrack.LocationWithDeviation, HyperTrack.Location.Error>
+) -> [String: Any] {
+    switch result {
+    case let .success(success):
+        return [
+            keyType: typeSuccess,
+            keyValue: [
+                keyType: "locationWithDeviation",
+                keyValue: serializeLocationWithDeviation(success),
             ],
-        ],
-    ]
-}
-
-func serializeHyperTrackError(_ error: HyperTrackError) -> [String: Any] {
-    return [
-        keyType: typeHyperTrackError,
-        keyValue: error.rawValue,
-    ]
+        ]
+    case let .failure(failure):
+        return [
+            keyType: typeFailure,
+            keyValue: serializeLocationError(failure),
+        ]
+    }
 }
 
-func serializeIsTracking(_ isTracking: Bool) -> [String: Any] {
+func serializeMetadata(_ metadata: HyperTrack.JSON.Object) -> [String: Any] {
     return [
-        keyType: typeIsTracking,
-        keyValue: isTracking,
+        keyType: typeMetadata,
+        keyValue: toMap(metadata),
     ]
 }
 
-func serializeIsAvailable(_ isAvailable: HyperTrack.Availability) -> [String: Any] {
+func serializeName(_ name: String) -> [String: Any] {
     return [
-        keyType: typeIsAvailable,
-        keyValue: isAvailable == .available,
+        keyType: typeName,
+        keyValue: name,
     ]
 }
 
-func deserializeDeviceName(_ data: [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: [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)))
+func serializeErrors(_ errors: Set<HyperTrack.Error>) -> [[String: Any]] {
+    return errors.map { error in
+        serializeError(error)
     }
-    return .success(value)
 }
 
-func deserializeGeotagData(
-    _ args: [String: Any]
-) -> Result<GeotagData, FailureResult> {
-    guard let data = args[keyGeotagData] as? [String: Any] else {
-        return .failure(.fatalError(getParseError(args, key: keyGeotagData)))
-    }
-    if let expectedLocationData = args[keyExpectedLocation] as? [String: Any] {
-        let expectedLocation = deserializeLocation(expectedLocationData)
-        switch expectedLocation {
-        case let .failure(failure):
-            return .failure(failure)
-        case let .success(expectedLocation):
-            return .success(.init(data: data, expectedLocation: expectedLocation))
+private func toMap(_ object: HyperTrack.JSON.Object) -> [String: Any] {
+    return object.mapValues { value in
+        switch value {
+        case let .object(objectValue):
+            return toMap(objectValue) as Any
+        case let .array(arr):
+            return toArray(arr)
+        case let .bool(bool):
+            return bool
+        case let .number(number):
+            return number
+        case let .string(string):
+            return string
+        case .null:
+            return NSNull()
         }
-    } else {
-        return .success(.init(data: data, expectedLocation: nil))
     }
 }
 
-func deserializeLocation(_ data: [String: Any]) -> Result<HyperTrack.Location, FailureResult> {
-    if data[keyType] as? String != typeLocation {
-        return .failure(.fatalError(getParseError(data, key: keyType)))
-    }
-    guard let value = data[keyValue] as? [String: Any] else {
-        return .failure(.fatalError(getParseError(data, key: keyValue)))
-    }
-    guard let latitude = value["latitude"] as? Double else {
-        return .failure(.fatalError(getParseError(value, key: "latitude")))
-    }
-    guard let longitude = value["longitude"] as? Double else {
-        return .failure(.fatalError(getParseError(value, key: "longitude")))
+private func toArray(_ array: [HyperTrack.JSON]) -> [Any] {
+    return array.map { (json: HyperTrack.JSON) -> Any in
+        switch json {
+        case let .object(objectValue):
+            return toMap(objectValue)
+        case let .array(arr):
+            return toArray(arr)
+        case let .bool(bool):
+            return bool
+        case let .number(number):
+            return number
+        case let .string(string):
+            return string
+        case .null:
+            return NSNull()
+        }
     }
-
-    return .success(HyperTrack.Location(latitude: latitude, longitude: longitude))
 }
 
-func getParseError(_ data: Any, key: String) -> String {
+private func getParseError(_ data: Any, key: String) -> String {
     return "Invalid input for key \(key): \(data)"
 }