@bricks-soft/capacitor-location-tracking 8.1.0 → 8.2.0

package/ios/Sources/LocationTrackingPlugin/Config/ConfigDefaults.swift

@@ -0,0 +1,96 @@
+import Foundation
+
+enum ConfigDefaults {
+    static let value: TrackingJSON = try! jsonObject(Data(#"""
+{
+  "geolocation": {
+    "desiredAccuracy": "high",
+    "distanceFilter": 10,
+    "locationUpdateInterval": 1000,
+    "fastestLocationUpdateInterval": 500,
+    "disableElasticity": false,
+    "elasticityMultiplier": 1,
+    "stationaryRadius": 25,
+    "stopTimeout": 5,
+    "stopAfterElapsedMinutes": 0,
+    "stopOnStationary": false,
+    "locationTimeout": 30000,
+    "filter": {
+      "useKalman": false,
+      "trackingAccuracyThreshold": 100,
+      "maxImpliedSpeed": 80,
+      "odometerAccuracyThreshold": 20,
+      "allowIdenticalLocations": false,
+      "rejectMockLocations": false
+    }
+  },
+  "activity": {
+    "disableMotionActivityUpdates": false,
+    "activityRecognitionInterval": 10000,
+    "minimumActivityRecognitionConfidence": 75,
+    "motionTriggerDelay": 0,
+    "disableStopDetection": false
+  },
+  "heartbeat": {
+    "enabled": true,
+    "minInterval": 180,
+    "maxInterval": 300,
+    "uploadKeepAwake": 10
+  },
+  "http": {
+    "url": null,
+    "method": "POST",
+    "headers": {},
+    "params": {},
+    "autoSync": true,
+    "autoSyncThreshold": 0,
+    "syncInterval": 0,
+    "batchSync": false,
+    "maxBatchSize": 100,
+    "disableAutoSyncOnCellular": false,
+    "rootProperty": "location",
+    "locationTemplate": null,
+    "geofenceTemplate": null,
+    "timeout": 60000,
+    "maxRetryAfter": 3600,
+    "authorization": null
+  },
+  "persistence": {
+    "maxDaysToPersist": 7,
+    "maxRecordsToPersist": -1,
+    "extras": {}
+  },
+  "app": {
+    "stopOnTerminate": true,
+    "startOnBoot": false
+  },
+  "notification": {
+    "title": null,
+    "largeIcon": null,
+    "color": null,
+    "text": "Location tracking is active",
+    "smallIcon": "drawable/lt_ic_notification",
+    "priority": "default",
+    "channelId": "location_tracking",
+    "channelName": "Location tracking",
+    "actions": [],
+    "resume": {
+      "title": null,
+      "enabled": false,
+      "text": "Location tracking is paused. Tap to resume.",
+      "channelName": "Paused location tracking",
+      "delay": 600
+    }
+  },
+  "geofence": {
+    "initialTriggerEntry": true
+  },
+  "logger": {
+    "logLevel": "info",
+    "logMaxDays": 3
+  },
+  "backgroundPermissionRationale": {"title": null, "message": null, "positiveAction": null, "negativeAction": null},
+  "locationProvider": "auto"
+}
+"""#.utf8))
+}

package/ios/Sources/LocationTrackingPlugin/Config/ConfigSchema.swift

@@ -0,0 +1,74 @@
+import Foundation
+import CoreFoundation
+
+struct ConfigSchema {
+    static let authorization: TrackingJSON = ["strategy": "JWT", "accessToken": NSNull(), "refreshToken": NSNull(), "refreshUrl": NSNull(), "refreshPayload": TrackingJSON(), "refreshHeaders": TrackingJSON(), "refreshPayloadEncoding": "json", "expires": -1]
+    static let maps = Set(["http.headers", "http.params", "persistence.extras", "http.authorization.refreshPayload", "http.authorization.refreshHeaders"])
+    static let enums = ["geolocation.desiredAccuracy": ["high", "balanced", "low", "passive"], "http.method": ["POST", "PUT", "PATCH"], "http.authorization.strategy": ["JWT"], "http.authorization.refreshPayloadEncoding": ["json", "form"], "notification.priority": ["min", "low", "default", "high", "max"], "logger.logLevel": ["off", "error", "warn", "info", "debug", "verbose"], "locationProvider": ["auto", "gms", "hms", "android"]]
+    static func parse(_ patch: TrackingJSON, base: TrackingJSON, defaults: TrackingJSON = ConfigDefaults.value, path: String = "", lenient: Bool = false, warnings: inout [String]) throws -> TrackingJSON {
+        var result = base
+        let schema = path == "http.authorization" ? authorization : defaults
+        for (key, raw) in patch {
+            let name = path.isEmpty ? key : path + "." + key
+            guard let fallback = schema[key] else { warnings.append("Ignoring unknown config key \(name)"); continue }
+            do {
+                if raw is NSNull { result[key] = fallback; continue }
+                if maps.contains(name) {
+                    guard var map = raw as? TrackingJSON else { throw invalid(name) }
+                    if name.hasSuffix("Headers") || name == "http.headers" {
+                        var strings: TrackingJSON = [:]
+                        for (field, value) in map where !(value is NSNull) {
+                            if let text = value as? String { strings[field] = text }
+                            else if value is NSNumber { strings[field] = String(decoding: try jsonData(value), as: UTF8.self) }
+                            else { throw invalid(name) }
+                        }
+                        map = strings
+                    }
+                    if name.hasPrefix("http.authorization.") {
+                        for (field, value) in map {
+                            if let text = value as? String, let stored = base.object(key)[field] as? String, text == mask(stored) { map[field] = stored }
+                        }
+                    }
+                    result[key] = map
+                } else if name == "http.authorization" || fallback is TrackingJSON {
+                    guard let object = raw as? TrackingJSON else { throw invalid(name) }
+                    let nested = name == "http.authorization" ? authorization : fallback as? TrackingJSON ?? [:]
+                    result[key] = try parse(object, base: base[key] as? TrackingJSON ?? nested, defaults: nested, path: name, lenient: lenient, warnings: &warnings)
+                } else if let allowed = enums[name] {
+                    guard let text = raw as? String, let canonical = allowed.first(where: { $0.lowercased() == text.lowercased() }) else { throw invalid(name) }
+                    result[key] = canonical
+                } else if name == "notification.actions" {
+                    guard let actions = raw as? [TrackingJSON] else { throw invalid(name) }
+                    result[key] = try actions.map { action -> TrackingJSON in
+                        guard let id = action["id"] as? String, !id.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, let label = action["label"] as? String else { throw invalid(name) }
+                        return ["id": id, "label": label]
+                    }
+                } else if let number = fallback as? NSNumber {
+                    if CFGetTypeID(number) == CFBooleanGetTypeID() {
+                        if let value = raw as? NSNumber, CFGetTypeID(value) == CFBooleanGetTypeID() { result[key] = value }
+                        else if let text = raw as? String, ["true", "false"].contains(text.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()) { result[key] = text.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == "true" }
+                        else { throw invalid(name) }
+                    } else {
+                        let value: Double?
+                        if let number = raw as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() { value = number.doubleValue }
+                        else if let text = raw as? String { value = Double(text.trimmingCharacters(in: .whitespacesAndNewlines)) }
+                        else { value = nil }
+                        guard let value, value.isFinite, abs(value) < Double(Int64.max) / 2 else { throw invalid(name) }
+                        let decimals = Set(["geolocation.distanceFilter", "geolocation.elasticityMultiplier", "geolocation.stationaryRadius", "geolocation.filter.trackingAccuracyThreshold", "geolocation.filter.maxImpliedSpeed", "geolocation.filter.odometerAccuracyThreshold"])
+                        result[key] = decimals.contains(name) ? value : value.rounded(.towardZero)
+                    }
+                } else {
+                    guard let text = raw as? String else { throw invalid(name) }
+                    if name == "http.authorization.accessToken" || name == "http.authorization.refreshToken", let stored = base[key] as? String, text == mask(stored) { result[key] = stored }
+                    else { result[key] = text }
+                }
+            } catch {
+                if !lenient { throw error }
+                warnings.append("Ignoring invalid stored config key \(name)")
+            }
+        }
+        return result
+    }
+    private static func invalid(_ path: String) -> TrackingError { TrackingError("INVALID_ARGUMENT", "Invalid config.\(path)") }
+    static func mask(_ text: String) -> String { text.count > 8 ? "***" + text.suffix(4) : "***" }
+}

package/ios/Sources/LocationTrackingPlugin/Config/ConfigValidator.swift

@@ -0,0 +1,40 @@
+import Foundation
+
+struct ConfigValidator {
+    static func clamp(_ candidate: TrackingJSON) -> (TrackingJSON, [String]) {
+        var result = candidate
+        var warnings: [String] = []
+        let minimums: [String: [String: Double]] = [
+            "geolocation": ["distanceFilter": 0, "locationUpdateInterval": 0, "fastestLocationUpdateInterval": 0, "elasticityMultiplier": 0, "stationaryRadius": 1, "stopTimeout": 0, "stopAfterElapsedMinutes": 0],
+            "activity": ["activityRecognitionInterval": 0, "minimumActivityRecognitionConfidence": 0, "motionTriggerDelay": 0],
+            "http": ["maxBatchSize": 1, "autoSyncThreshold": 0, "syncInterval": 0, "maxRetryAfter": 0],
+            "persistence": ["maxDaysToPersist": 1, "maxRecordsToPersist": -1], "logger": ["logMaxDays": 1]
+        ]
+        for (section, fields) in minimums {
+            var values = result.object(section)
+            for (key, minimum) in fields {
+                let current = values.number(key, ConfigDefaults.value.object(section).number(key))
+                let maximum = section == "activity" && key == "minimumActivityRecognitionConfidence" ? 100.0 : Double(Int32.max)
+                let clamped = min(maximum, max(minimum, current))
+                if clamped != current { warnings.append("\(section).\(key) clamped to \(clamped)") }
+                values[key] = clamped
+            }
+            result[section] = values
+        }
+        for section in ["http", "geolocation"] {
+            let key = section == "http" ? "timeout" : "locationTimeout"
+            var values = result.object(section)
+            if values.number(key) <= 0 {
+                values[key] = ConfigDefaults.value.object(section)[key]
+                warnings.append("\(section).\(key) raised to its default")
+            }
+            result[section] = values
+        }
+        var geo = result.object("geolocation")
+        var filter = geo.object("filter")
+        for key in ["trackingAccuracyThreshold", "maxImpliedSpeed", "odometerAccuracyThreshold"] { filter[key] = max(0, filter.number(key, ConfigDefaults.value.object("geolocation").object("filter").number(key))) }
+        geo["filter"] = filter
+        result["geolocation"] = geo
+        return (result, warnings)
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Config/SecretStore.swift

@@ -0,0 +1,35 @@
+import Foundation
+import Security
+
+final class SecretStore {
+    private let service: String
+    init(service: String = "com.brickssoft.locationtracking.authorization") { self.service = service }
+    private var query: TrackingJSON {
+        [kSecClass as String: kSecClassGenericPassword, kSecAttrService as String: service, kSecAttrAccount as String: "http"]
+    }
+    func load() throws -> TrackingJSON? {
+        var request = query
+        request[kSecReturnData as String] = true
+        request[kSecMatchLimit as String] = kSecMatchLimitOne
+        var result: CFTypeRef?
+        let status = SecItemCopyMatching(request as CFDictionary, &result)
+        if status == errSecItemNotFound { return nil }
+        guard status == errSecSuccess, let data = result as? Data else { throw TrackingError("IO_ERROR", "Keychain authorization is unavailable (status \(status))") }
+        return try jsonObject(data)
+    }
+    func save(_ value: TrackingJSON?) throws {
+        if let value {
+            let data = try jsonData(value)
+            let attributes: TrackingJSON = [kSecValueData as String: data, kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly]
+            let status = SecItemUpdate(query as CFDictionary, attributes as CFDictionary)
+            if status == errSecItemNotFound {
+                var request = query
+                attributes.forEach { request[$0.key] = $0.value }
+                guard SecItemAdd(request as CFDictionary, nil) == errSecSuccess else { throw TrackingError("IO_ERROR", "Cannot save authorization in Keychain") }
+            } else if status != errSecSuccess { throw TrackingError("IO_ERROR", "Cannot update authorization in Keychain") }
+        } else {
+            let status = SecItemDelete(query as CFDictionary)
+            guard status == errSecSuccess || status == errSecItemNotFound else { throw TrackingError("IO_ERROR", "Cannot clear authorization in Keychain") }
+        }
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Config/TrackingConfig.swift

@@ -0,0 +1,104 @@
+import Foundation
+
+final class TrackingConfig {
+    private(set) var value: TrackingJSON
+    private(set) var secretsUnavailable = false
+    private let store: TrackingStore
+    private let secrets: SecretStore
+    init(store: TrackingStore, secrets: SecretStore) throws {
+        self.store = store
+        self.secrets = secrets
+        var warnings: [String] = []
+        value = try ConfigSchema.parse(try store.load("config") ?? [:], base: ConfigDefaults.value, lenient: true, warnings: &warnings)
+        if (try store.load("authorization"))?.flag("configured") == true {
+            var http = value.object("http")
+            do {
+                guard let auth = try secrets.load() else { throw TrackingError("IO_ERROR", "Stored authorization is missing from Keychain") }
+                http["authorization"] = auth
+            } catch {
+                secretsUnavailable = true
+                http["authorization"] = TrackingJSON()
+            }
+            value["http"] = http
+        }
+    }
+    @discardableResult func apply(_ patch: TrackingJSON, reset: Bool) throws -> [String] {
+        var warnings: [String] = []
+        var candidate = try ConfigSchema.parse(patch, base: reset ? ConfigDefaults.value : value, warnings: &warnings)
+        let clamped = ConfigValidator.clamp(candidate)
+        candidate = clamped.0
+        warnings += clamped.1
+        var heartbeat = candidate.object("heartbeat")
+        heartbeat["minInterval"] = max(60, heartbeat.number("minInterval", 180))
+        heartbeat["maxInterval"] = max(heartbeat.number("minInterval"), heartbeat.number("maxInterval", 300))
+        heartbeat["uploadKeepAwake"] = min(60, max(0, heartbeat.number("uploadKeepAwake", 10)))
+        candidate["heartbeat"] = heartbeat
+        var notification = candidate.object("notification")
+        var resume = notification.object("resume")
+        if resume.number("delay", 600) < heartbeat.number("maxInterval") + 60 {
+            resume["delay"] = heartbeat.number("maxInterval") + 60
+            warnings.append("notification.resume.delay raised to heartbeat.maxInterval + 60")
+        }
+        notification["resume"] = resume
+        candidate["notification"] = notification
+        let http = candidate.object("http")
+        if let url = http["url"] as? String, !url.isEmpty {
+            guard let parsed = URL(string: url), ["https", "http"].contains(parsed.scheme?.lowercased() ?? ""), parsed.host != nil else { throw TrackingError("INVALID_ARGUMENT", "http.url must be an HTTP URL") }
+            if parsed.scheme == "http" { warnings.append("http.url uses unencrypted HTTP; iOS App Transport Security may refuse it") }
+        }
+        for section in ["geolocation", "activity", "heartbeat", "http", "persistence", "logger"] {
+            try Self.validateNumbers(candidate.object(section))
+        }
+        guard ["POST", "PUT", "PATCH"].contains(http.text("method", "POST")), http.number("timeout", 60000) > 0, http.number("maxBatchSize", 100) >= 1 else { throw TrackingError("INVALID_ARGUMENT", "Invalid HTTP method, timeout or batch size") }
+        _ = try jsonData(candidate)
+        var persisted = candidate
+        var persistedHttp = http
+        persistedHttp["authorization"] = NSNull()
+        persisted["http"] = persistedHttp
+        let previousSecrets = value.object("http")["authorization"] as? TrackingJSON
+        let nextSecrets = http["authorization"] as? TrackingJSON
+        let differentSecrets = try jsonData(previousSecrets ?? [:]) != jsonData(nextSecrets ?? [:])
+        let explicitAuthorization = patch.object("http").keys.contains("authorization") || reset
+        let changedSecrets = (previousSecrets == nil) != (nextSecrets == nil) || differentSecrets || (secretsUnavailable && explicitAuthorization)
+        if changedSecrets { try secrets.save(nextSecrets) }
+        do {
+            try store.transaction {
+                try store.save("config", persisted)
+                try store.save("authorization", ["configured": nextSecrets != nil])
+            }
+        } catch {
+            if changedSecrets {
+                do { try secrets.save(previousSecrets) }
+                catch { throw TrackingError("IO_ERROR", "Configuration write and authorization rollback failed") }
+            }
+            throw error
+        }
+        value = candidate
+        if explicitAuthorization { secretsUnavailable = false }
+        return warnings
+    }
+    var masked: TrackingJSON {
+        var result = value
+        var http = result.object("http")
+        if var auth = http["authorization"] as? TrackingJSON {
+            for key in ["accessToken", "refreshToken"] {
+                if let text = auth[key] as? String { auth[key] = ConfigSchema.mask(text) }
+            }
+            for key in ["refreshPayload", "refreshHeaders"] {
+                var map = auth.object(key)
+                for (name, value) in map {
+                    if let text = value as? String, !text.contains("{refreshToken}") { map[name] = ConfigSchema.mask(text) }
+                }
+                auth[key] = map
+            }
+            http["authorization"] = auth
+        }
+        result["http"] = http
+        return result
+    }
+    private static func validateNumbers(_ object: TrackingJSON) throws {
+        for (_, value) in object {
+            if let number = value as? NSNumber, !number.doubleValue.isFinite || abs(number.doubleValue) >= Double(Int64.max) / 2 { throw TrackingError("INVALID_ARGUMENT", "Configuration number is out of range") }
+        }
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Core/JSON.swift

@@ -0,0 +1,50 @@
+import Foundation
+
+public typealias TrackingJSON = [String: Any]
+
+public struct TrackingError: Error, LocalizedError {
+    public let code: String
+    public let message: String
+    var storageFull = false
+    public var errorDescription: String? { message }
+    public init(_ code: String, _ message: String) { self.code = code; self.message = message }
+}
+
+func jsonData(_ value: Any) throws -> Data {
+    guard JSONSerialization.isValidJSONObject(value) || value is NSNull || value is String || value is NSNumber else {
+        throw TrackingError("INVALID_ARGUMENT", "Value must be JSON serializable")
+    }
+    return try JSONSerialization.data(withJSONObject: value, options: [.fragmentsAllowed, .sortedKeys])
+}
+
+func jsonObject(_ data: Data) throws -> TrackingJSON {
+    guard let result = try JSONSerialization.jsonObject(with: data) as? TrackingJSON else {
+        throw TrackingError("IO_ERROR", "Expected a JSON object")
+    }
+    return result
+}
+
+private let isoFormatter: ISO8601DateFormatter = {
+    let formatter = ISO8601DateFormatter()
+    formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+    return formatter
+}()
+
+func iso(_ date: Date = Date()) -> String { isoFormatter.string(from: date) }
+
+func isoDate(_ text: String) -> Date? { isoFormatter.date(from: text) }
+
+extension Dictionary where Key == String, Value == Any {
+    func object(_ key: String) -> TrackingJSON { self[key] as? TrackingJSON ?? [:] }
+    func number(_ key: String, _ fallback: Double = 0) -> Double { (self[key] as? NSNumber)?.doubleValue ?? fallback }
+    func flag(_ key: String, _ fallback: Bool = false) -> Bool { self[key] as? Bool ?? fallback }
+    func text(_ key: String, _ fallback: String = "") -> String { self[key] as? String ?? fallback }
+    func requiringObject(_ key: String) throws -> TrackingJSON {
+        guard let value = self[key] as? TrackingJSON else { throw TrackingError("INVALID_ARGUMENT", "\(key) must be an object") }
+        return value
+    }
+    func requiringString(_ key: String) throws -> String {
+        guard let value = self[key] as? String, !value.isEmpty else { throw TrackingError("INVALID_ARGUMENT", "\(key) must be a nonempty string") }
+        return value
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Core/Options.swift

@@ -0,0 +1,26 @@
+import Foundation
+import CoreFoundation
+
+struct Options {
+    static func validate(_ method: String, _ options: TrackingJSON) throws {
+        let numbers: [String: [String]] = ["getLocations": ["limit"], "setOdometer": ["odometer"], "getCurrentPosition": ["samples", "timeout", "maximumAge"], "watchPosition": ["interval"], "getLog": ["start", "end", "limit"]]
+        for key in numbers[method] ?? [] {
+            if let value = options[key], !(value is NSNull) {
+                guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID(), number.doubleValue.isFinite, abs(number.doubleValue) < Double(Int64.max) / 2 else { throw TrackingError("INVALID_ARGUMENT", "\(key) must be a finite number in range") }
+            }
+        }
+        for key in ["persist", "reset", "isMoving"] {
+            if let value = options[key], !(value is NSNull), !(value is NSNumber && CFGetTypeID(value as! NSNumber) == CFBooleanGetTypeID()) { throw TrackingError("INVALID_ARGUMENT", "\(key) must be a boolean") }
+        }
+        for key in ["config", "extras", "headers", "params", "location", "geofence"] {
+            if let value = options[key], !(value is NSNull), !(value is TrackingJSON) { throw TrackingError("INVALID_ARGUMENT", "\(key) must be an object") }
+        }
+        if let desired = options["desiredAccuracy"], !(desired is NSNull) {
+            guard let text = desired as? String, ["high", "balanced", "low", "passive"].contains(text) else { throw TrackingError("INVALID_ARGUMENT", "Unknown desiredAccuracy") }
+        }
+        if method == "requestPermissions", let value = options["permissions"], !(value is [String]) { throw TrackingError("INVALID_ARGUMENT", "permissions must be a string array") }
+        if method == "log" {
+            guard ["error", "warn", "info", "debug", "verbose"].contains(options.text("level")) else { throw TrackingError("INVALID_ARGUMENT", "Unknown log level") }
+        }
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Core/PluginInfo.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+enum PluginInfo {
+    static let version = "8.2.0"
+    static let backend = "ios"
+}

package/ios/Sources/LocationTrackingPlugin/Core/TrackingClock.swift

@@ -0,0 +1,11 @@
+import Foundation
+import Darwin
+
+enum TrackingClock {
+    static func now() -> TrackingInstant { TrackingInstant(wall: Date().timeIntervalSince1970 * 1000, elapsed: elapsedMilliseconds()) }
+    static func elapsedMilliseconds() -> Double {
+        var info = mach_timebase_info_data_t()
+        mach_timebase_info(&info)
+        return Double(mach_continuous_time()) * Double(info.numer) / Double(info.denom) / 1e6
+    }
+}