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

package/ios/Sources/LocationTrackingPlugin/Logging/LogExport.swift

@@ -0,0 +1,73 @@
+import Foundation
+import UIKit
+import MessageUI
+import zlib
+
+final class LogExport: NSObject, MFMailComposeViewControllerDelegate {
+    private let transport = HTTPTransport()
+    private var mailer: MFMailComposeViewController?
+    static func gzip(_ data: Data) throws -> Data {
+        var stream = z_stream()
+        guard deflateInit2_(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8, Z_DEFAULT_STRATEGY, ZLIB_VERSION, Int32(MemoryLayout<z_stream>.size)) == Z_OK else { throw TrackingError("IO_ERROR", "Cannot initialize log compression") }
+        defer { deflateEnd(&stream) }
+        var output = Data(count: Int(compressBound(uLong(data.count))) + 32)
+        let status = data.withUnsafeBytes { input in
+            output.withUnsafeMutableBytes { buffer in
+                stream.next_in = UnsafeMutablePointer(mutating: input.baseAddress?.assumingMemoryBound(to: Bytef.self))
+                stream.avail_in = uInt(data.count)
+                stream.next_out = buffer.baseAddress?.assumingMemoryBound(to: Bytef.self)
+                stream.avail_out = uInt(buffer.count)
+                return deflate(&stream, Z_FINISH)
+            }
+        }
+        guard status == Z_STREAM_END else { throw TrackingError("IO_ERROR", "Cannot compress logs") }
+        output.count = Int(stream.total_out)
+        return output
+    }
+    func upload(_ text: String, options: TrackingJSON, completion: @escaping (Result<TrackingJSON, Error>) -> Void) throws {
+        let address = try options.requiringString("url")
+        guard let url = URL(string: address), ["https", "http"].contains(url.scheme ?? ""), url.host != nil else { throw TrackingError("INVALID_ARGUMENT", "url must be HTTP or HTTPS") }
+        let boundary = UUID().uuidString
+        var body = Data()
+        func append(_ text: String) { body.append(Data(text.utf8)) }
+        append("--\(boundary)\r\nContent-Disposition: form-data; name=\"log\"; filename=\"location-tracking.log.gz\"\r\nContent-Type: application/gzip\r\n\r\n")
+        body.append(try Self.gzip(Data(text.utf8)))
+        append("\r\n")
+        for (key, value) in options.object("params") {
+            guard !key.contains("\r"), !key.contains("\n"), !key.contains("\"") else { throw TrackingError("INVALID_ARGUMENT", "Invalid multipart field name") }
+            let text: String
+            if let string = value as? String { text = string }
+            else { text = String(decoding: try jsonData(value), as: UTF8.self) }
+            append("--\(boundary)\r\nContent-Disposition: form-data; name=\"\(key)\"\r\n\r\n\(text)\r\n")
+        }
+        append("--\(boundary)--\r\n")
+        var headers = options["headers"] as? [String: String] ?? [:]
+        headers["Content-Type"] = "multipart/form-data; boundary=\(boundary)"
+        transport.send(url: url, method: "POST", headers: headers, body: body, timeout: 60000) { result in
+            switch result {
+            case .success(let response): completion(.success(["success": response.success, "status": response.status]))
+            case .failure: completion(.success(["success": false, "status": 0]))
+            }
+        }
+    }
+    func email(_ text: String, options: TrackingJSON, completion: @escaping (Result<TrackingJSON, Error>) -> Void) {
+        do {
+            let email = try options.requiringString("email")
+            guard MFMailComposeViewController.canSendMail() else { throw TrackingError("UNAVAILABLE", "Mail is not configured on this device") }
+            guard mailer == nil else { throw TrackingError("UNAVAILABLE", "Log email is already open") }
+            guard let scene = UIApplication.shared.connectedScenes.compactMap({ $0 as? UIWindowScene }).first(where: { $0.activationState == .foregroundActive }), var presenter = scene.windows.first(where: { $0.isKeyWindow })?.rootViewController else { throw TrackingError("NO_ACTIVITY", "No active app window") }
+            while let presented = presenter.presentedViewController { presenter = presented }
+            let controller = MFMailComposeViewController()
+            controller.mailComposeDelegate = self
+            controller.setToRecipients([email])
+            controller.setSubject(options.text("subject", "Location tracking log"))
+            controller.addAttachmentData(try Self.gzip(Data(text.utf8)), mimeType: "application/gzip", fileName: "location-tracking.log.gz")
+            mailer = controller
+            presenter.present(controller, animated: true) { completion(.success([:])) }
+        } catch { completion(.failure(error)) }
+    }
+    func mailComposeController(_ controller: MFMailComposeViewController, didFinishWith result: MFMailComposeResult, error: Error?) {
+        controller.dismiss(animated: true)
+        mailer = nil
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Logging/TrackingLog.swift

@@ -0,0 +1,47 @@
+import Foundation
+import os
+
+final class TrackingLog {
+    private let logger = Logger(subsystem: "com.brickssoft.locationtracking", category: "plugin")
+    private var entries: [TrackingJSON] = []
+    private let store: TrackingStore
+    private var minimumLevel = "info"
+    private var maximumDays = 3
+    private let severity = ["off": Int.max, "error": 5, "warn": 4, "info": 3, "debug": 2, "verbose": 1]
+    init(store: TrackingStore) {
+        self.store = store
+        entries = (try? store.load("logs"))?["entries"] as? [TrackingJSON] ?? []
+    }
+    func configure(_ config: TrackingJSON) {
+        minimumLevel = config.text("logLevel", "info")
+        maximumDays = max(1, Int(config.number("logMaxDays", 3)))
+        prune()
+    }
+    private func prune() {
+        let cutoff = Date().addingTimeInterval(-Double(maximumDays) * 86400).timeIntervalSince1970 * 1000
+        entries.removeAll { $0.number("at") < cutoff }
+    }
+    func write(_ level: String, _ message: String) {
+        guard (severity[level] ?? 0) >= (severity[minimumLevel] ?? 3) else { return }
+        prune()
+        let safe = Self.redact(message)
+        entries.append(["at": Date().timeIntervalSince1970 * 1000, "level": level, "text": "\(iso()) \(level) \(safe)"])
+        if entries.count > 2000 { entries.removeFirst(entries.count - 2000) }
+        do { try store.save("logs", ["entries": entries]) }
+        catch { logger.error("Log persistence failed") }
+        logger.log("\(safe, privacy: .private)")
+    }
+    func read(_ query: TrackingJSON) -> String {
+        prune()
+        var values = entries.filter { $0.number("at") >= query.number("start", 0) && $0.number("at") <= query.number("end", .greatestFiniteMagnitude) && (query.text("level").isEmpty || (severity[$0.text("level")] ?? 0) >= (severity[query.text("level")] ?? 0)) }
+        if query.text("order", "asc") == "desc" { values.reverse() }
+        return values.prefix(max(0, Int(query.number("limit", 2000)))).map { $0.text("text") }.joined(separator: "\n")
+    }
+    func clear() throws { try store.save("logs", ["entries": []]); entries = [] }
+    private static let redactions: [NSRegularExpression] = [#"(?i)\bBearer\s+[A-Za-z0-9._~+/=-]+"#, #"(?i)\b(?:https?|wss?)://[^\s"'<>]+"#, #"\beyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*"#, #"(?i)("?\b(?:access[_-]?token|refresh[_-]?token|id[_-]?token|token|password|passwd|secret|client[_-]?secret|api[_-]?key|authorization)\b"?\s*[:=]\s*)("(?:[^"\\]|\\.)*"|[^\s,;&}]+)"#].compactMap { try? NSRegularExpression(pattern: $0) }
+    static func redact(_ text: String) -> String {
+        var result = text
+        for regex in Self.redactions { result = regex.stringByReplacingMatches(in: result, range: NSRange(result.startIndex..., in: result), withTemplate: "[redacted]") }
+        return result
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Permission/LocationServices.swift

@@ -0,0 +1,32 @@
+import Foundation
+import CoreLocation
+
+final class LocationServices {
+    static let shared = LocationServices()
+    private(set) var enabled = true
+    private(set) var isReady = false
+    private var refreshing = false
+    private var completions: [() -> Void] = []
+    private let read: () -> Bool
+    init(read: @escaping () -> Bool = { CLLocationManager.locationServicesEnabled() }) { self.read = read }
+    func whenReady(_ completion: @escaping () -> Void) {
+        if isReady { completion() }
+        else { refresh(completion: completion) }
+    }
+    func refresh(completion: (() -> Void)? = nil) {
+        if let completion { completions.append(completion) }
+        guard !refreshing else { return }
+        refreshing = true
+        DispatchQueue.global(qos: .utility).async {
+            let enabled = self.read()
+            DispatchQueue.main.async {
+                self.enabled = enabled
+                self.isReady = true
+                self.refreshing = false
+                let waiting = self.completions
+                self.completions = []
+                waiting.forEach { $0() }
+            }
+        }
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Permission/Permissions.swift

@@ -0,0 +1,102 @@
+import Foundation
+import CoreLocation
+import CoreMotion
+import UserNotifications
+import UIKit
+
+final class Permissions: NSObject, CLLocationManagerDelegate {
+    static let order = ["location", "notifications", "activityRecognition", "backgroundLocation"]
+    let manager: CLLocationManager
+    private let motion = CMMotionActivityManager()
+    private var requests: [([String], (TrackingJSON) -> Void)] = []
+    private var authorizationDone: (() -> Void)?
+    private var awaitingAlways = false
+    private var activeObserver: NSObjectProtocol?
+    var providerChanged: ((TrackingJSON) -> Void)?
+    init(manager: CLLocationManager = CLLocationManager()) {
+        self.manager = manager
+        super.init()
+        manager.delegate = self
+        LocationServices.shared.refresh()
+        activeObserver = NotificationCenter.default.addObserver(forName: UIApplication.didBecomeActiveNotification, object: nil, queue: .main) { [weak self] _ in
+            LocationServices.shared.refresh()
+            guard let self, self.awaitingAlways else { return }
+            self.finishAuthorization()
+        }
+    }
+    deinit { if let activeObserver { NotificationCenter.default.removeObserver(activeObserver) } }
+    var provider: TrackingJSON {
+        let status = manager.authorizationStatus
+        let authorized = status == .authorizedAlways || status == .authorizedWhenInUse
+        let enabled = LocationServices.shared.enabled
+        return ["enabled": enabled, "gps": enabled, "network": enabled, "permission": status == .authorizedAlways ? "always" : authorized ? "when_in_use" : "denied", "accuracy": authorized ? (manager.accuracyAuthorization == .fullAccuracy ? "precise" : "approximate") : "none", "backend": PluginInfo.backend]
+    }
+    func status(_ completion: @escaping (TrackingJSON) -> Void) {
+        let location: String
+        switch manager.authorizationStatus {
+        case .notDetermined: location = "prompt"
+        case .authorizedAlways, .authorizedWhenInUse: location = "granted"
+        default: location = "denied"
+        }
+        let activity: String
+        switch CMMotionActivityManager.authorizationStatus() {
+        case .notDetermined: activity = "prompt"
+        case .authorized: activity = "granted"
+        default: activity = "denied"
+        }
+        let background = manager.authorizationStatus == .authorizedAlways ? "granted" : manager.authorizationStatus == .denied || manager.authorizationStatus == .restricted ? "denied" : "prompt"
+        UNUserNotificationCenter.current().getNotificationSettings { settings in
+            let notification = settings.authorizationStatus == .notDetermined ? "prompt" : settings.authorizationStatus == .denied ? "denied" : "granted"
+            DispatchQueue.main.async { completion(["location": location, "backgroundLocation": background, "activityRecognition": activity, "notifications": notification]) }
+        }
+    }
+    func request(_ types: [String], completion: @escaping (TrackingJSON) -> Void) {
+        requests.append((types, completion))
+        if requests.count == 1 { advance(types) }
+    }
+    private func advance(_ types: [String]) {
+        guard let first = types.first else {
+            status { result in
+                let callback = self.requests.removeFirst().1
+                callback(result)
+                if let next = self.requests.first { self.advance(next.0) }
+            }
+            return
+        }
+        let rest = Array(types.dropFirst())
+        let next = { self.advance(rest) }
+        switch first {
+        case "location" where manager.authorizationStatus == .notDetermined:
+            authorizationDone = next
+            manager.requestWhenInUseAuthorization()
+        case "backgroundLocation" where (manager.authorizationStatus == .notDetermined || manager.authorizationStatus == .authorizedWhenInUse) && !UserDefaults.standard.bool(forKey: "LT.alwaysAsked"):
+            UserDefaults.standard.set(true, forKey: "LT.alwaysAsked")
+            awaitingAlways = true
+            authorizationDone = next
+            manager.requestAlwaysAuthorization()
+            DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
+                if self.awaitingAlways && UIApplication.shared.applicationState == .active { self.finishAuthorization() }
+            }
+        case "activityRecognition" where CMMotionActivityManager.isActivityAvailable() && CMMotionActivityManager.authorizationStatus() == .notDetermined:
+            motion.queryActivityStarting(from: Date().addingTimeInterval(-1), to: Date(), to: .main) { _, _ in next() }
+        case "notifications":
+            UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { _, _ in DispatchQueue.main.async(execute: next) }
+        default: next()
+        }
+    }
+    private func finishAuthorization() {
+        let done = authorizationDone
+        authorizationDone = nil
+        awaitingAlways = false
+        done?()
+    }
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        LocationServices.shared.refresh { [weak self] in
+            guard let self else { return }
+            self.providerChanged?(self.provider)
+        }
+        if awaitingAlways {
+            if manager.authorizationStatus == .authorizedAlways { finishAuthorization() }
+        } else if manager.authorizationStatus != .notDetermined { finishAuthorization() }
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Position/PositionSource.swift

@@ -0,0 +1,79 @@
+import Foundation
+import CoreLocation
+
+final class PositionSource: NSObject, CLLocationManagerDelegate {
+    private let manager = CLLocationManager()
+    private let services: LocationServices
+    private let callback: (Result<CLLocation, Error>) -> Void
+    private let collector: SampleCollector
+    private let rejectMock: Bool
+    private let requestedAt = Date()
+    private let continuous: Bool
+    private let interval: TimeInterval
+    private var stopped = false
+    private var timeout: DispatchWorkItem?
+    private var deliveredAt: Double?
+    init(options: TrackingJSON, continuous: Bool, services: LocationServices = .shared, callback: @escaping (Result<CLLocation, Error>) -> Void) {
+        self.services = services
+        self.callback = callback
+        self.collector = SampleCollector(Int(options.number("samples", 3)))
+        self.rejectMock = options.flag("_rejectMock")
+        self.continuous = continuous
+        self.interval = max(0, options.number("interval", 1000)) / 1000
+        super.init()
+        manager.delegate = self
+        manager.desiredAccuracy = RouteSource.accuracy(options.text("desiredAccuracy", "high"))
+        manager.distanceFilter = kCLDistanceFilterNone
+        manager.pausesLocationUpdatesAutomatically = false
+        let modes = Bundle.main.object(forInfoDictionaryKey: "UIBackgroundModes") as? [String] ?? []
+        manager.allowsBackgroundLocationUpdates = continuous && modes.contains("location")
+        manager.showsBackgroundLocationIndicator = continuous
+        if !continuous {
+            let item = DispatchWorkItem { [weak self] in
+                guard let self, !self.stopped else { return }
+                if let best = self.collector.best { self.callback(.success(best)) }
+                else { self.callback(.failure(TrackingError("TIMEOUT", "Position request timed out"))) }
+                self.stop()
+            }
+            timeout = item
+            DispatchQueue.main.asyncAfter(deadline: .now() + options.number("timeout", 30000) / 1000, execute: item)
+        }
+    }
+    func start() {
+        guard continuous || services.enabled else { callback(.failure(TrackingError("LOCATION_DISABLED", "Location Services are disabled"))); stop(); return }
+        guard !services.enabled || manager.authorizationStatus == .authorizedAlways || manager.authorizationStatus == .authorizedWhenInUse else { callback(.failure(TrackingError("PERMISSION_DENIED", "Location permission is required"))); stop(); return }
+        manager.startUpdatingLocation()
+    }
+    func stop() { stopped = true; timeout?.cancel(); manager.stopUpdatingLocation(); manager.delegate = nil }
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        guard !stopped else { return }
+        for fix in locations where fix.horizontalAccuracy >= 0 && CLLocationCoordinate2DIsValid(fix.coordinate) {
+            if !continuous && rejectMock && fix.sourceInformation?.isSimulatedBySoftware == true { continue }
+            if continuous {
+                let now = TrackingClock.elapsedMilliseconds()
+                if deliveredAt == nil || now - deliveredAt! >= interval * 1000 { deliveredAt = now; callback(.success(fix)) }
+            } else {
+                if fix.timestamp < requestedAt.addingTimeInterval(-2) { continue }
+                if collector.add(fix) { callback(.success(collector.best!)); stop(); return }
+            }
+        }
+    }
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        if continuous && !stopped && (manager.authorizationStatus == .authorizedAlways || manager.authorizationStatus == .authorizedWhenInUse) { manager.startUpdatingLocation() }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        if (error as? CLError)?.code == .locationUnknown { return }
+        if continuous {
+            services.refresh { [weak self] in
+                guard let self, self.services.enabled else { return }
+                self.fail(error)
+            }
+        } else { fail(error) }
+    }
+    private func fail(_ error: Error) {
+        guard !stopped else { return }
+        callback(.failure(TrackingError((error as? CLError)?.code == .denied ? "PERMISSION_DENIED" : "UNAVAILABLE", "Core Location could not obtain a position")))
+        stop()
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Position/Positions.swift

@@ -0,0 +1,33 @@
+import Foundation
+import CoreLocation
+
+final class Positions {
+    private let services: LocationServices
+    private var pending = Set<String>()
+    init(services: LocationServices = .shared) { self.services = services }
+    private var sources: [String: PositionSource] = [:]
+    private var cached: CachedPosition?
+    private let manager = CLLocationManager()
+    func request(id: String, options: TrackingJSON, watch: Bool, completion: @escaping (Result<CLLocation, Error>) -> Void) {
+        guard services.isReady else {
+            pending.insert(id)
+            services.whenReady {
+                guard self.pending.remove(id) != nil else { return }
+                self.request(id: id, options: options, watch: watch, completion: completion)
+            }
+            return
+        }
+        if !watch && !services.enabled { completion(.failure(TrackingError("LOCATION_DISABLED", "Location Services are disabled"))); return }
+        if services.enabled && manager.authorizationStatus != .authorizedAlways && manager.authorizationStatus != .authorizedWhenInUse { completion(.failure(TrackingError("PERMISSION_DENIED", "Location permission is required"))); return }
+        if !watch, options.number("maximumAge") > 0, let cached, cached.age() <= options.number("maximumAge"), !(options.flag("_rejectMock") && cached.fix.sourceInformation?.isSimulatedBySoftware == true) { completion(.success(cached.fix)); return }
+        let source = PositionSource(options: options, continuous: watch, services: services) { [weak self] result in
+            if case .success(let fix) = result { self?.cached = CachedPosition(fix) }
+            if !watch { self?.sources.removeValue(forKey: id) }
+            else if case .failure = result { self?.sources.removeValue(forKey: id) }
+            completion(result)
+        }
+        sources[id] = source
+        source.start()
+    }
+    func clear(_ id: String) { pending.remove(id); sources.removeValue(forKey: id)?.stop() }
+}

package/ios/Sources/LocationTrackingPlugin/Position/SampleCollector.swift

@@ -0,0 +1,31 @@
+import Foundation
+import CoreLocation
+
+final class SampleCollector {
+    private let wanted: Int
+    private(set) var best: CLLocation?
+    private(set) var count = 0
+    init(_ wanted: Int) { self.wanted = max(1, wanted) }
+    func add(_ fix: CLLocation) -> Bool {
+        count += 1
+        if let current = best {
+            if rank(fix) < rank(current) || (rank(fix) == rank(current) && fix.timestamp >= current.timestamp) { best = fix }
+        } else { best = fix }
+        return count >= wanted || best.map { rank($0) <= 10 } == true
+    }
+    private func rank(_ fix: CLLocation) -> Double { fix.horizontalAccuracy > 0 ? fix.horizontalAccuracy : .infinity }
+}
+
+struct CachedPosition {
+    let fix: CLLocation
+    let receivedElapsed: Double
+    let ageAtReceipt: Double
+    init(_ fix: CLLocation, wall: Date = Date(), elapsed: Double = TrackingClock.elapsedMilliseconds()) {
+        self.fix = fix
+        receivedElapsed = elapsed
+        ageAtReceipt = max(0, wall.timeIntervalSince(fix.timestamp) * 1000)
+    }
+    func age(wall: Date = Date(), elapsed: Double = TrackingClock.elapsedMilliseconds()) -> Double {
+        max(wall.timeIntervalSince(fix.timestamp) * 1000, ageAtReceipt + max(0, elapsed - receivedElapsed))
+    }
+}

package/ios/Sources/LocationTrackingPlugin/PrivacyInfo.xcprivacy

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>NSPrivacyTracking</key><false/>
+<key>NSPrivacyTrackingDomains</key><array/>
+<key>NSPrivacyCollectedDataTypes</key><array/>
+<key>NSPrivacyAccessedAPITypes</key><array>
+<dict><key>NSPrivacyAccessedAPIType</key><string>NSPrivacyAccessedAPICategoryUserDefaults</string><key>NSPrivacyAccessedAPITypeReasons</key><array><string>CA92.1</string></array></dict>
+</array>
+</dict></plist>

package/ios/Sources/LocationTrackingPlugin/Processing/LocationProcessor.swift

@@ -0,0 +1,83 @@
+import Foundation
+
+final class KalmanFilter {
+    private var last: TrackedLocation?
+    private var latitude = 0.0
+    private var longitude = 0.0
+    private var variance = 0.0
+    func filter(_ fix: TrackedLocation) -> TrackedLocation {
+        let accuracy = fix.accuracy.isFinite && fix.accuracy > 1 ? fix.accuracy : 1
+        let measurement = accuracy * accuracy
+        let dt = last.map { Geo.elapsed($0, fix) }
+        last = fix
+        guard let dt, dt >= 0, dt <= 60000 else {
+            latitude = fix.latitude; longitude = fix.longitude; variance = measurement
+            return fix
+        }
+        if dt > 0 {
+            let reported = fix.speed.flatMap { $0.isFinite && $0 >= 0 ? $0 : nil }
+            let speed = reported.map { max(1, $0) } ?? 3
+            let seconds = dt / 1000
+            variance += speed * speed * seconds * max(1, seconds)
+        }
+        let gain = variance / (variance + measurement)
+        latitude += gain * (fix.latitude - latitude)
+        longitude = Geo.normalize(longitude + gain * Geo.wrap(fix.longitude - longitude))
+        variance *= 1 - gain
+        var result = fix; result.latitude = latitude; result.longitude = longitude
+        return result
+    }
+    func reset() { last = nil; variance = 0 }
+}
+
+enum FilterResult {
+    case accepted(TrackedLocation)
+    case rejected(String)
+}
+
+final class LocationProcessor {
+    private let lock = NSLock()
+    private let kalman = KalmanFilter()
+    private var lastAccepted: TrackedLocation?
+    func process(_ fix: TrackedLocation, filter: TrackingJSON) -> FilterResult {
+        lock.lock(); defer { lock.unlock() }
+        if !Geo.valid(fix.latitude, fix.longitude) || (fix.latitude == 0 && fix.longitude == 0) { return .rejected("invalid coordinates") }
+        if !(fix.accuracy <= filter.number("trackingAccuracyThreshold", 100)) { return .rejected("accuracy exceeds trackingAccuracyThreshold") }
+        if fix.isMock && filter.flag("rejectMockLocations") { return .rejected("mock location") }
+        if let previous = lastAccepted {
+            let dt = Geo.elapsed(previous, fix)
+            if dt < 0 { return .rejected("stale fix") }
+            if !filter.flag("allowIdenticalLocations") && fix.latitude == previous.latitude && fix.longitude == previous.longitude && fix.time == previous.time { return .rejected("identical fix") }
+            let maxSpeed = filter.number("maxImpliedSpeed", 80)
+            if maxSpeed > 0 && dt > 0 && Geo.distance(previous, fix) / (dt / 1000) > maxSpeed { return .rejected("implied speed exceeds maxImpliedSpeed") }
+        }
+        lastAccepted = fix
+        if filter.flag("useKalman") { return .accepted(kalman.filter(fix)) }
+        kalman.reset()
+        return .accepted(fix)
+    }
+    func reset() { lock.lock(); defer { lock.unlock() }; lastAccepted = nil; kalman.reset() }
+}
+
+final class Odometer {
+    private var anchor: TrackedLocation?
+    private var session: Double?
+    func onLocation(_ fix: TrackedLocation, runtime: TrackingJSON, threshold: Double) -> Double {
+        guard passes(fix, threshold) else { return 0 }
+        let started = runtime["trackingStartedAt"] as? Double
+        if session != started {
+            session = started
+            anchor = nil
+            if let started, runtime.flag("enabled"), let last = TrackedLocation.from(runtime.object("lastLocation")), Self.belongs(last, to: started, runtime: runtime), !fix.isOlder(than: last), passes(last, threshold) { anchor = last }
+        }
+        let previous = anchor
+        anchor = fix
+        return previous.map { Geo.distance($0, fix) } ?? 0
+    }
+    func reset(session: Double?) { anchor = nil; self.session = session }
+    static func belongs(_ last: TrackedLocation, to started: Double, runtime: TrackingJSON) -> Bool {
+        guard let session = last.session else { return last.time >= started }
+        return session == started
+    }
+    private func passes(_ fix: TrackedLocation, _ threshold: Double) -> Bool { fix.accuracy <= threshold && Geo.valid(fix.latitude, fix.longitude) }
+}

package/ios/Sources/LocationTrackingPlugin/Processing/TrackedLocation.swift

@@ -0,0 +1,64 @@
+import Foundation
+
+struct TrackedLocation: Codable, Equatable {
+    var latitude: Double
+    var longitude: Double
+    var accuracy: Double = 5.2
+    var altitude: Double? = nil
+    var altitudeAccuracy: Double? = nil
+    var speed: Double? = nil
+    var speedAccuracy: Double? = nil
+    var heading: Double? = nil
+    var headingAccuracy: Double? = nil
+    var time: Double
+    var elapsed: Double? = nil
+    var isMock = false
+    var session: Double? = nil
+
+    var accuracyMeters: Double { accuracy.isFinite && accuracy > 0 ? accuracy : 0 }
+    func isOlder(than other: TrackedLocation) -> Bool { Geo.elapsed(self, other) > 0 }
+    var json: TrackingJSON { (try? jsonObject(JSONEncoder().encode(self))) ?? [:] }
+    static func from(_ json: TrackingJSON) -> TrackedLocation? { try? JSONDecoder().decode(Self.self, from: jsonData(json)) }
+}
+
+enum Geo {
+    static func valid(_ latitude: Double, _ longitude: Double) -> Bool {
+        latitude.isFinite && longitude.isFinite && (-90...90).contains(latitude) && (-180...180).contains(longitude)
+    }
+    static func distance(_ a: TrackedLocation, _ b: TrackedLocation) -> Double {
+        distance(a.latitude, a.longitude, b.latitude, b.longitude)
+    }
+    static func distance(_ lat1: Double, _ lng1: Double, _ lat2: Double, _ lng2: Double) -> Double {
+        let radians = Double.pi / 180
+        let latitude = sin((lat2 - lat1) * radians / 2)
+        let longitude = sin((lng2 - lng1) * radians / 2)
+        let h = latitude * latitude + cos(lat1 * radians) * cos(lat2 * radians) * longitude * longitude
+        return 6371008.8 * 2 * asin(sqrt(min(1, max(0, h))))
+    }
+    static func elapsed(_ a: TrackedLocation, _ b: TrackedLocation) -> Double {
+        if let first = a.elapsed, let second = b.elapsed, first > 0, second > 0 { return second - first }
+        return b.time - a.time
+    }
+    static func wrap(_ delta: Double) -> Double {
+        let reduced = (delta + 180).truncatingRemainder(dividingBy: 360)
+        return (reduced < 0 ? reduced + 360 : reduced) - 180
+    }
+    static func normalize(_ longitude: Double) -> Double {
+        if (-180...180).contains(longitude) { return longitude }
+        return wrap(longitude)
+    }
+}
+
+enum ElasticDistance {
+    static func threshold(_ distance: Double, _ speed: Double?, _ multiplier: Double, _ disabled: Bool) -> Double {
+        let base = distance.isFinite ? max(0, distance) : 0
+        if disabled { return base }
+        let velocity = speed.flatMap { $0.isFinite && $0 > 0 ? $0 : nil } ?? 0
+        let factor = multiplier.isFinite ? multiplier : 1
+        return base * max(1, floor(velocity / 5 + 0.5) * factor)
+    }
+    static func shouldRecord(_ previous: TrackedLocation?, _ fix: TrackedLocation, _ config: TrackingJSON) -> Bool {
+        guard let previous else { return true }
+        return Geo.distance(previous, fix) >= threshold(config.number("distanceFilter", 10), fix.speed, config.number("elasticityMultiplier", 1), config.flag("disableElasticity"))
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Record/ExternalRecord.swift

@@ -0,0 +1,54 @@
+import Foundation
+import CoreFoundation
+
+struct ExternalRecord {
+    let location: TrackedLocation
+    let event: String
+    let moving: Bool?
+    let extras: TrackingJSON
+    static let events = Set(["location", "motionchange", "current_position", "watch_position", "heartbeat", "geofence", "tracking_start", "tracking_stop", "providerchange"])
+    init(_ input: TrackingJSON, now: Double) throws {
+        let coords = try input.requiringObject("coords")
+        guard let latitude = Self.number(coords["latitude"]) else { throw TrackingError("INVALID_ARGUMENT", "coords.latitude is required") }
+        guard let longitude = Self.number(coords["longitude"]) else { throw TrackingError("INVALID_ARGUMENT", "coords.longitude is required") }
+        guard Geo.valid(latitude, longitude) else { throw TrackingError("INVALID_ARGUMENT", "coords are out of range") }
+        guard let accuracy = Self.number(coords["accuracy"]) else { throw TrackingError("INVALID_ARGUMENT", "coords.accuracy is required") }
+        guard accuracy > 0 else { throw TrackingError("INVALID_ARGUMENT", "coords.accuracy must be > 0") }
+        var time = now
+        if let value = input["timestamp"], !(value is NSNull) {
+            let formatter = ISO8601DateFormatter()
+            formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+            guard let text = value as? String else { throw TrackingError("INVALID_ARGUMENT", "timestamp must be ISO-8601") }
+            var parsed = formatter.date(from: text)
+            if parsed == nil { formatter.formatOptions = [.withInternetDateTime]; parsed = formatter.date(from: text) }
+            guard let parsed else { throw TrackingError("INVALID_ARGUMENT", "timestamp must be ISO-8601") }
+            time = parsed.timeIntervalSince1970 * 1000
+        }
+        event = input["event"] == nil || input["event"] is NSNull ? "location" : input.text("event")
+        guard Self.events.contains(event) else { throw TrackingError("INVALID_ARGUMENT", "Unknown event") }
+        if let value = input["is_moving"], !(value is NSNull) {
+            if let number = value as? NSNumber, CFGetTypeID(number) == CFBooleanGetTypeID() { moving = number.boolValue }
+            else if let text = value as? String, ["true", "false"].contains(text.lowercased()) { moving = text.lowercased() == "true" }
+            else { throw TrackingError("INVALID_ARGUMENT", "is_moving must be a boolean") }
+        } else { moving = nil }
+        if let value = input["extras"], !(value is NSNull) {
+            guard let object = value as? TrackingJSON else { throw TrackingError("INVALID_ARGUMENT", "extras must be an object") }
+            extras = object
+        } else { extras = [:] }
+        func nonNegative(_ key: String) -> Double? { Self.number(coords[key]).flatMap { $0 >= 0 ? $0 : nil } }
+        location = TrackedLocation(latitude: latitude, longitude: longitude, accuracy: accuracy, altitude: Self.number(coords["altitude"]), altitudeAccuracy: nonNegative("altitude_accuracy"), speed: nonNegative("speed"), speedAccuracy: nonNegative("speed_accuracy"), heading: nonNegative("heading"), headingAccuracy: nonNegative("heading_accuracy"), time: time)
+    }
+    var coordinates: TrackingJSON {
+        ["latitude": location.latitude, "longitude": location.longitude, "accuracy": location.accuracy,
+         "altitude": location.altitude as Any? ?? NSNull(), "altitude_accuracy": location.altitudeAccuracy as Any? ?? NSNull(),
+         "speed": location.speed as Any? ?? NSNull(), "speed_accuracy": location.speedAccuracy as Any? ?? NSNull(),
+         "heading": location.heading as Any? ?? NSNull(), "heading_accuracy": location.headingAccuracy as Any? ?? NSNull()]
+    }
+    private static func number(_ value: Any?) -> Double? {
+        let parsed: Double?
+        if let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() { parsed = number.doubleValue }
+        else if let text = value as? String { parsed = Double(text.trimmingCharacters(in: .whitespacesAndNewlines)) }
+        else { parsed = nil }
+        return parsed.flatMap { $0.isFinite ? $0 : nil }
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Record/RecordFactory.swift

@@ -0,0 +1,27 @@
+import Foundation
+import CoreLocation
+import UIKit
+
+struct RecordFactory {
+    static func make(event: String, fix: CLLocation?, extras: TrackingJSON, odometer: Double, provider: TrackingJSON, network: String) -> TrackingJSON {
+        var coords: Any = NSNull()
+        if let fix {
+            coords = ["latitude": fix.coordinate.latitude, "longitude": fix.coordinate.longitude, "accuracy": fix.horizontalAccuracy,
+                      "altitude": fix.verticalAccuracy >= 0 ? fix.altitude as Any : NSNull(), "altitude_accuracy": fix.verticalAccuracy >= 0 ? fix.verticalAccuracy as Any : NSNull(),
+                      "speed": fix.speed >= 0 ? fix.speed as Any : NSNull(), "speed_accuracy": fix.speedAccuracy >= 0 ? fix.speedAccuracy as Any : NSNull(),
+                      "heading": fix.course >= 0 ? fix.course as Any : NSNull(), "heading_accuracy": fix.courseAccuracy >= 0 ? fix.courseAccuracy as Any : NSNull()]
+        }
+        let readings = DeviceReadings.shared.snapshot(event: event)
+        var wire: TrackingJSON = ["uuid": UUID().uuidString.lowercased(), "event": event, "timestamp": fix.map { iso($0.timestamp) } as Any? ?? NSNull(), "recorded_at": iso(),
+                "elapsed_realtime_ms": continuousMilliseconds(), "boot_count": -1, "is_moving": false, "odometer": odometer,
+                "mock": fix?.sourceInformation?.isSimulatedBySoftware ?? false, "coords": coords, "activity": ["type": "unknown", "confidence": 0],
+                "battery": readings.battery,
+                "backend": PluginInfo.backend, "extras": extras, "provider": provider, "network": network, "device": readings.device]
+        if extras.isEmpty { wire.removeValue(forKey: "extras") }
+        if readings.device.isEmpty { wire.removeValue(forKey: "device") }
+        return wire
+    }
+    static func continuousMilliseconds() -> Double {
+        TrackingClock.elapsedMilliseconds()
+    }
+}