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

package/ios/Sources/LocationTrackingPlugin/Http/Syncer.swift

@@ -0,0 +1,313 @@
+import Foundation
+
+final class Syncer {
+    let transport = HTTPTransport()
+    private let queue: DispatchQueue
+    private let store: TrackingStore
+    private let config: TrackingConfig
+    private let emit: (String, TrackingJSON) -> Void
+    private var callbacks: [(Result<[TrackingJSON], Error>) -> Void] = []
+    private var followUp: [(Result<[TrackingJSON], Error>) -> Void] = []
+    private var connectivityWaiters: [() -> Void] = []
+    private var uploaded: [TrackingJSON] = []
+    private var reducedBatch: Int?
+    private var busy = false
+    private var closed = false
+    private var pendingAutomatic = false
+    private var pendingRecovery = false
+    private var changedUntil: Date?
+    private var rejectedPriority = Set<String>()
+    private var passFailure: (Error, TrackingJSON, Int, Double?)?
+    private enum Renewal { case renewed(TrackingJSON), changed, failed(Error) }
+    var connectivityKnown = false
+    private var priorityOnly = false
+    private var generation = 0
+    private var shortLivedToken: String?
+    private var failures = 0
+    private var retryTimer: DispatchWorkItem?
+    var connected = true
+    var cellular = false
+    var tracking = false
+    private let priority = Set(["heartbeat", "tracking_start", "tracking_stop", "providerchange"])
+    init(queue: DispatchQueue, store: TrackingStore, config: TrackingConfig, emit: @escaping (String, TrackingJSON) -> Void) {
+        self.queue = queue; self.store = store; self.config = config; self.emit = emit
+        failures = Int((try? store.load("uploadWait"))?.number("failures") ?? 0)
+    }
+    static func needsRefresh(_ auth: TrackingJSON, now: Double, shortLivedToken: String? = nil) -> Bool {
+        let token = auth.text("accessToken")
+        if token.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { return true }
+        let expires = auth.number("expires", -1)
+        if expires <= 0 { return false }
+        return now >= expires || (now >= expires - 60000 && token != shortLivedToken)
+    }
+    func close() {
+        guard !closed else { return }
+        closed = true
+        retryTimer?.cancel()
+        cancel()
+        transport.close()
+        let waiters = connectivityWaiters; connectivityWaiters = []
+        waiters.forEach { $0() }
+    }
+    func cancel() {
+        generation += 1
+        pendingAutomatic = false
+        transport.cancel()
+        if busy { finish(.failure(TrackingError("NETWORK_ERROR", "Upload cancelled"))) }
+    }
+    func connectivity(connected: Bool, cellular: Bool) {
+        let recovered = connectivityKnown && !self.connected && connected
+        connectivityKnown = true
+        self.connected = connected
+        self.cellular = cellular
+        if recovered && busy { pendingRecovery = true }
+        if recovered, let wait = try? store.load("uploadWait"), wait.text("reason") == "server" {
+            try? store.save("uploadWait", [:])
+            failures = 0
+            retryTimer?.cancel()
+        }
+        let waiters = connectivityWaiters; connectivityWaiters = []
+        waiters.forEach { $0() }
+        automatic()
+    }
+    func whenConnectivityKnown(_ body: @escaping () -> Void) {
+        if connectivityKnown || closed { body() } else { connectivityWaiters.append(body) }
+    }
+    func automatic(completion: ((Result<[TrackingJSON], Error>) -> Void)? = nil) {
+        guard !closed else { completion?(.failure(TrackingError("NETWORK_ERROR", "Syncer is closed"))); return }
+        if busy {
+            pendingAutomatic = true
+            if let completion { followUp.append(completion) }
+            return
+        }
+        guard connectivityKnown && connected else { completion?(.success([])); return }
+        if let until = changedUntil, until > Date() { schedule(until.timeIntervalSince1970 * 1000); completion?(.success([])); return }
+        changedUntil = nil
+        let total: Int, hasPriority: Bool
+        do {
+            total = try store.count
+            hasPriority = try total > 0 && store.contains(events: priority)
+        } catch { completion?(.failure(error)); return }
+        guard total > 0 else { completion?(.success([])); return }
+        let http = config.value.object("http")
+        guard !http.text("url").isEmpty else { completion?(.success([])); return }
+        if hasPriority { run(priorityOnly: cellular && http.flag("disableAutoSyncOnCellular"), completion: completion ?? { _ in }); return }
+        guard http.flag("autoSync", true), !(cellular && http.flag("disableAutoSyncOnCellular")) else { completion?(.success([])); return }
+        if let wait = try? store.load("uploadWait"), wait.number("at") > Date().timeIntervalSince1970 * 1000,
+           wait.text("reason") != "authorization" || wait.text("authKey") == UploadBackoff.authKey(http) { schedule(wait.number("at")); completion?(.success([])); return }
+        let interval = tracking ? http.number("syncInterval") : 0
+        let threshold = http.number("autoSyncThreshold")
+        if interval > 0, let oldest = try? store.locations(limit: 1).first {
+            let age = Date().timeIntervalSince(isoDate(oldest.text("recorded_at")) ?? .distantPast)
+            if age >= 0 && age < interval && !(threshold > 0 && Double(total) >= threshold) { schedule(Date().timeIntervalSince1970 * 1000 + (interval - age) * 1000); completion?(.success([])); return }
+        } else if Double(total) < max(1, threshold) { completion?(.success([])); return }
+        run(completion: completion ?? { _ in })
+    }
+    func run(priorityOnly: Bool = false, completion: @escaping (Result<[TrackingJSON], Error>) -> Void) {
+        guard !closed else { completion(.failure(TrackingError("NETWORK_ERROR", "Syncer is closed"))); return }
+        guard !config.value.object("http").text("url").isEmpty else { completion(.failure(TrackingError("NO_URL", "No http.url configured"))); return }
+        callbacks.append(completion)
+        if busy { if !priorityOnly { self.priorityOnly = false }; return }
+        self.priorityOnly = priorityOnly
+        busy = true; uploaded = []; reducedBatch = nil; rejectedPriority = []; passFailure = nil
+        next()
+    }
+    private func next() {
+        do {
+            let http = config.value.object("http")
+            let limit = http.flag("batchSync") ? max(1, Int(http.number("maxBatchSize", 100))) : 1
+            let size = reducedBatch.map { min(limit, $0) } ?? limit
+            let chunk = priorityOnly ? Array(try store.locations(events: priority).filter { !rejectedPriority.contains($0.text("uuid")) }.prefix(size)) : try store.locations(limit: size)
+            if chunk.isEmpty {
+                if let failure = passFailure { fail(failure.0, http: failure.1, status: failure.2, retryAfter: failure.3, authorizationFailure: false) }
+                else {
+                    if !priorityOnly { failures = 0; try store.save("uploadWait", [:]) }
+                    finish(.success(uploaded))
+                }
+                return
+            }
+            upload(chunk, http: http, attempt: 0, refreshed: false)
+        } catch { finish(.failure(error)) }
+    }
+    private func upload(_ records: [TrackingJSON], http: TrackingJSON, attempt: Int, refreshed: Bool) {
+        let captured = generation
+        let explicitAuthorization = http.object("headers").keys.contains { $0.lowercased() == "authorization" }
+        if config.secretsUnavailable && !explicitAuthorization {
+            emit("authorization", ["success": false, "status": 0, "error": "Stored authorization is unavailable; set http.authorization again"])
+            fail(TrackingError("HTTP_ERROR", "Stored authorization is unavailable; set http.authorization again"), http: http, status: 401, retryAfter: nil)
+            return
+        }
+        guard UploadBackoff.authKey(http) == UploadBackoff.authKey(config.value.object("http")) else { credentialsChanged(); return }
+        let auth = explicitAuthorization ? [:] : http.object("authorization")
+        if !auth.isEmpty && !auth.text("refreshUrl").isEmpty && !refreshed && Self.needsRefresh(auth, now: Date().timeIntervalSince1970 * 1000, shortLivedToken: shortLivedToken) {
+            refresh(http) { result in
+                guard self.generation == captured else { return }
+                switch result {
+                case .renewed(let fresh): self.upload(records, http: fresh, attempt: attempt, refreshed: true)
+                case .changed: self.credentialsChanged()
+                case .failed(let error):
+                    if !auth.text("accessToken").isEmpty { self.upload(records, http: http, attempt: attempt, refreshed: true) }
+                    else { self.fail(error, http: http, status: 401, retryAfter: nil) }
+                }
+            }
+            return
+        }
+        do {
+            guard let url = URL(string: http.text("url")), ["http", "https"].contains(url.scheme ?? "") else { throw TrackingError("INVALID_ARGUMENT", "Invalid upload URL") }
+            var headers = http["headers"] as? [String: String] ?? [:]
+            if !auth.text("accessToken").trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { headers = headers.filter { $0.key.lowercased() != "authorization" }; headers["Authorization"] = "Bearer " + auth.text("accessToken") }
+            let body = try BodyBuilder.build(records, http: http)
+            transport.send(url: url, method: http.text("method", "POST"), headers: headers, body: body, timeout: http.number("timeout", 60000)) { result in
+                self.queue.async {
+                    guard self.generation == captured, self.busy else { return }
+                    let response = try? result.get()
+                    let status = response?.status ?? 0
+                    self.emit("http", ["success": response?.success ?? false, "status": status, "responseText": response.map { String(decoding: $0.body, as: UTF8.self) } ?? "Network request failed", "uuids": records.map { $0.text("uuid") }])
+                    if response?.success == true {
+                        do {
+                            try self.store.transaction { for record in records { try self.store.delete(record.text("uuid")) } }
+                            self.uploaded += records
+                            self.next()
+                        } catch { self.finish(.failure(error)) }
+                        return
+                    }
+                    if UploadBackoff.authKey(http) != UploadBackoff.authKey(self.config.value.object("http")) {
+                        self.credentialsChanged(); return
+                    }
+                    if status == 401 && !refreshed && !auth.isEmpty {
+                        self.refresh(http) { renewal in
+                            guard self.generation == captured else { return }
+                            switch renewal {
+                            case .renewed(let fresh): self.upload(records, http: fresh, attempt: attempt, refreshed: true)
+                            case .changed: self.credentialsChanged()
+                            case .failed(let error): self.fail(error, http: http, status: 401, retryAfter: nil)
+                            }
+                        }
+                        return
+                    }
+                    if status == 413 && records.count > 1 { self.reducedBatch = max(1, records.count / 2); self.next(); return }
+                    let retryAfter = (status == 429 || status == 503) ? UploadBackoff.retryAfter(response?.retryAfter, maximum: http.number("maxRetryAfter", 3600)) : nil
+                    if (status == 0 || status == 429 || status >= 500), attempt < 3 {
+                        let delay = UploadBackoff.retryDelay(attempt, random: Double.random(in: 0..<1))
+                        if (retryAfter ?? 0) <= delay {
+                            self.queue.asyncAfter(deadline: .now() + delay / 1000) {
+                                guard self.generation == captured, self.busy else { return }
+                                self.upload(records, http: http, attempt: attempt + 1, refreshed: refreshed)
+                            }
+                            return
+                        }
+                    }
+                    self.reject(records, error: TrackingError(status == 0 ? "NETWORK_ERROR" : "HTTP_ERROR", status == 0 ? "Network request failed" : "Upload failed: HTTP \(status)"), http: http, status: status, retryAfter: retryAfter)
+                }
+            }
+        } catch { reject(records, error: error, http: http, status: -1, retryAfter: nil) }
+    }
+    private func refresh(_ http: TrackingJSON, completion: @escaping (Renewal) -> Void) {
+        let auth = http.object("authorization")
+        guard let url = URL(string: auth.text("refreshUrl")), ["http", "https"].contains(url.scheme ?? "") else { emit("authorization", ["success": false, "status": 0, "error": "Token refresh is not configured"]); completion(.failed(TrackingError("HTTP_ERROR", "Token refresh is not configured"))); return }
+        var payload = auth.object("refreshPayload")
+        for (key, value) in payload { if let text = value as? String { payload[key] = text.replacingOccurrences(of: "{refreshToken}", with: auth.text("refreshToken")) } }
+        do {
+            var headers = auth["refreshHeaders"] as? [String: String] ?? [:]
+            let body: Data
+            if auth.text("refreshPayloadEncoding", "json") == "form" {
+                var components = URLComponents()
+                components.queryItems = payload.map { URLQueryItem(name: $0.key, value: String(describing: $0.value)) }
+                body = Data((components.percentEncodedQuery ?? "").replacingOccurrences(of: "+", with: "%2B").utf8)
+                headers["Content-Type"] = "application/x-www-form-urlencoded"
+            } else { body = try jsonData(payload) }
+            let captured = generation
+            transport.send(url: url, method: "POST", headers: headers, body: body, timeout: http.number("timeout", 60000), responseLimit: nil) { result in
+                self.queue.async {
+                    guard captured == self.generation else { return }
+                    guard UploadBackoff.authKey(http) == UploadBackoff.authKey(self.config.value.object("http")) else { completion(.changed); return }
+                    let response = try? result.get()
+                    let json = response.flatMap { try? jsonObject($0.body) }
+                    var event: TrackingJSON = ["success": false, "status": response?.status ?? 0]
+                    if let json { event["response"] = json }
+                    do {
+                        guard let response, let json else { throw TrackingError("HTTP_ERROR", "Token refresh failed") }
+                        let access = json.text("accessToken", json.text("access_token"))
+                        guard response.success, !access.isEmpty else { throw TrackingError("HTTP_ERROR", "Token refresh failed") }
+                        var next = auth
+                        next["accessToken"] = access
+                        next["refreshToken"] = json.text("refreshToken", json.text("refresh_token", auth.text("refreshToken")))
+                        var expires = json.number("expires", json.number("expires_at", -1))
+                        if expires > 0 && expires < 1e12 { expires *= 1000 }
+                        if expires <= 0 && json.number("expires_in") > 0 { expires = Date().timeIntervalSince1970 * 1000 + json.number("expires_in") * 1000 }
+                        next["expires"] = expires
+                        try self.config.apply(["http": ["authorization": next]], reset: false)
+                        if expires > 0 && expires - Date().timeIntervalSince1970 * 1000 <= 60000 { self.shortLivedToken = access }
+                        event["success"] = true
+                        self.emit("authorization", event)
+                        completion(.renewed(self.config.value.object("http")))
+                    } catch {
+                        event["error"] = "Token refresh failed"
+                        self.emit("authorization", event)
+                        completion(.failed(error))
+                    }
+                }
+            }
+        } catch {
+            emit("authorization", ["success": false, "status": 0, "error": "Token refresh failed"])
+            completion(.failed(error))
+        }
+    }
+    private func credentialsChanged() {
+        retryTimer?.cancel()
+        let current = config.value.object("http")
+        let hasReplacement = current["authorization"] is TrackingJSON || current.object("headers").keys.contains { $0.lowercased() == "authorization" }
+        if hasReplacement {
+            changedUntil = Date().addingTimeInterval(10)
+            schedule(changedUntil!.timeIntervalSince1970 * 1000)
+        }
+        pendingAutomatic = false
+        finish(.failure(TrackingError("HTTP_ERROR", "Authorization changed; records retained")))
+    }
+    private func reject(_ records: [TrackingJSON], error: Error, http: TrackingJSON, status: Int, retryAfter: Double?) {
+        let usesJWT = !http.object("headers").keys.contains { $0.lowercased() == "authorization" } && !http.object("authorization").isEmpty
+        if status != 0 && !(status == 401 && usesJWT) && (!priorityOnly || passFailure != nil) {
+            if passFailure == nil { passFailure = (error, http, status, retryAfter) }
+            if records.allSatisfy({ priority.contains($0.text("event")) }) { rejectedPriority.formUnion(records.map { $0.text("uuid") }) }
+            priorityOnly = true
+            next()
+        } else { fail(error, http: http, status: status, retryAfter: retryAfter, authorizationFailure: status == 401 && usesJWT) }
+    }
+    private func fail(_ error: Error, http: TrackingJSON, status: Int, retryAfter: Double?, authorizationFailure: Bool? = nil) {
+        let authFailure = authorizationFailure ?? (status == 401)
+        failures += 1
+        let delay = authFailure ? 900000 : UploadBackoff.serverWait(failures, random: Double.random(in: 0..<1), retryAfter: retryAfter, minimum: tracking ? http.number("syncInterval") * 1000 : 0)
+        let at = Date().timeIntervalSince1970 * 1000 + delay
+        do { try store.save("uploadWait", ["at": at, "reason": authFailure ? "authorization" : "server", "failures": failures, "authKey": UploadBackoff.authKey(http)]) }
+        catch { finish(.failure(error)); return }
+        schedule(at)
+        finish(.failure(error))
+    }
+    private func schedule(_ at: Double) {
+        retryTimer?.cancel()
+        let item = DispatchWorkItem { [weak self] in self?.automatic() }
+        retryTimer = item
+        queue.asyncAfter(deadline: .now() + max(0.1, at / 1000 - Date().timeIntervalSince1970), execute: item)
+    }
+    private func finish(_ result: Result<[TrackingJSON], Error>) {
+        busy = false
+        let waiting = callbacks; callbacks = []
+        waiting.forEach { $0(result) }
+        if pendingRecovery {
+            if let wait = try? store.load("uploadWait"), wait.text("reason") == "server" { try? store.save("uploadWait", [:]); failures = 0 }
+            pendingRecovery = false
+        }
+        let requested = pendingAutomatic
+        pendingAutomatic = false
+        let later = followUp; followUp = []
+        if requested {
+            let completion: ((Result<[TrackingJSON], Error>) -> Void)? = later.isEmpty ? nil : { value in later.forEach { $0(value) } }
+            queue.async { [weak self] in
+                if let self { self.automatic(completion: completion) } else { completion?(.failure(TrackingError("NETWORK_ERROR", "Syncer is closed"))) }
+            }
+        } else {
+            later.forEach { $0(result) }
+            if case .success = result { queue.async { [weak self] in self?.automatic() } }
+        }
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Http/UploadBackoff.swift

@@ -0,0 +1,26 @@
+import Foundation
+import CryptoKit
+
+struct UploadBackoff {
+    static func jittered(_ base: Double, random: Double) -> Double { floor(base * (0.8 + 0.4 * random)) }
+    static func retryDelay(_ index: Int, random: Double) -> Double { jittered([2000, 4000, 8000][index], random: random) }
+    static func serverWait(_ failures: Int, random: Double, retryAfter: Double?, minimum: Double) -> Double {
+        max(jittered(min(30000 * pow(2, Double(max(0, min(20, failures - 1)))), 900000), random: random), retryAfter ?? 0, minimum)
+    }
+    static func retryAfter(_ text: String?, maximum: Double, now: Date = Date()) -> Double? {
+        guard let text else { return nil }
+        let cleaned = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let seconds = Double(cleaned), seconds >= 0 { return min(seconds, maximum) * 1000 }
+        let format = DateFormatter()
+        format.locale = Locale(identifier: "en_US_POSIX")
+        format.timeZone = TimeZone(secondsFromGMT: 0)
+        format.dateFormat = "EEE, dd MMM yyyy HH:mm:ss zzz"
+        guard let date = format.date(from: cleaned) else { return nil }
+        return min(max(0, date.timeIntervalSince(now)), maximum) * 1000
+    }
+    static func authKey(_ http: TrackingJSON) -> String {
+        if http.object("headers").keys.contains(where: { $0.lowercased() == "authorization" }) { return "explicit-header" }
+        let auth = http.object("authorization")
+        return SHA256.hash(data: Data((auth.text("accessToken") + "\0" + auth.text("refreshToken")).utf8)).prefix(12).map { String(format: "%02x", $0) }.joined()
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Location/RouteSource.swift

@@ -0,0 +1,124 @@
+import Foundation
+import CoreLocation
+import CoreMotion
+import UIKit
+
+struct RouteProfile: Equatable {
+    var enabled: Bool
+    var moving: Bool
+    var accuracy: String
+    var activityEnabled: Bool
+    var sessionID = ""
+}
+
+final class RouteSource: NSObject, CLLocationManagerDelegate {
+    private let manager: CLLocationManager
+    private let relaunch: CLLocationManager
+    private let motion = CMMotionActivityManager()
+    private var profile = RouteProfile(enabled: false, moving: false, accuracy: "high", activityEnabled: false)
+    private var activityRunning = false
+    private var cachedLocation: TrackedLocation?
+    private let clock: () -> TrackingInstant
+    private var timebase: Double?
+    var locations: (([TrackedLocation], String) -> Void)?
+    var error: ((TrackingError, String) -> Void)?
+    var activity: ((ActivitySample, String) -> Void)?
+    var authorizationChanged: (() -> Void)?
+    var lastLocation: TrackedLocation? {
+        precondition(Thread.isMainThread)
+        return cachedLocation
+    }
+    init(manager: CLLocationManager = CLLocationManager(), relaunch: CLLocationManager = CLLocationManager(), clock: @escaping () -> TrackingInstant = TrackingClock.now) {
+        self.manager = manager; self.relaunch = relaunch; self.clock = clock
+        super.init()
+        manager.delegate = self; relaunch.delegate = self
+        manager.distanceFilter = kCLDistanceFilterNone
+        manager.pausesLocationUpdatesAutomatically = false
+        manager.showsBackgroundLocationIndicator = true
+    }
+    func apply(_ new: RouteProfile, force: Bool = false) {
+        precondition(Thread.isMainThread)
+        guard new != profile || force else { return }
+        if new.sessionID != profile.sessionID { stopMotion() }
+        profile = new
+        guard new.enabled else { manager.stopUpdatingLocation(); relaunch.stopMonitoringSignificantLocationChanges(); stopMotion(); return }
+        guard manager.authorizationStatus == .authorizedAlways || manager.authorizationStatus == .authorizedWhenInUse else {
+            manager.stopUpdatingLocation(); relaunch.stopMonitoringSignificantLocationChanges(); stopMotion(); return
+        }
+        let modes = Bundle.main.object(forInfoDictionaryKey: "UIBackgroundModes") as? [String] ?? []
+        manager.allowsBackgroundLocationUpdates = modes.contains("location")
+        manager.desiredAccuracy = new.moving ? Self.accuracy(new.accuracy) : kCLLocationAccuracyHundredMeters
+        if force { manager.stopUpdatingLocation() }
+        manager.startUpdatingLocation()
+        if manager.authorizationStatus == .authorizedAlways && CLLocationManager.significantLocationChangeMonitoringAvailable() { relaunch.startMonitoringSignificantLocationChanges() }
+        else { relaunch.stopMonitoringSignificantLocationChanges() }
+        if new.activityEnabled && CMMotionActivityManager.isActivityAvailable() && CMMotionActivityManager.authorizationStatus() == .authorized {
+            if !activityRunning {
+                activityRunning = true
+                let session = new.sessionID
+                motion.startActivityUpdates(to: .main) { [weak self] sample in
+                    guard let self, self.profile.enabled, self.profile.activityEnabled, self.activityRunning, self.profile.sessionID == session, let sample else { return }
+                    let confidence: Int
+                    switch sample.confidence { case .low: confidence = 33; case .medium: confidence = 66; case .high: confidence = 100; @unknown default: confidence = 0 }
+                    self.activity?(ActivitySample.map(automotive: sample.automotive, cycling: sample.cycling, running: sample.running, walking: sample.walking, stationary: sample.stationary, confidence: confidence), session)
+                }
+            }
+        } else { stopMotion() }
+    }
+    private func stopMotion() { if activityRunning { activityRunning = false; motion.stopActivityUpdates() } }
+    static func accuracy(_ desired: String) -> CLLocationAccuracy {
+        switch desired { case "balanced": return kCLLocationAccuracyHundredMeters; case "low": return kCLLocationAccuracyKilometer; case "passive": return kCLLocationAccuracyThreeKilometers; default: return kCLLocationAccuracyBest }
+    }
+    func locationManager(_ source: CLLocationManager, didUpdateLocations fixes: [CLLocation]) {
+        guard source === manager else { return }
+        let valid = ordered(fixes.filter { $0.horizontalAccuracy >= 0 && CLLocationCoordinate2DIsValid($0.coordinate) })
+        if let newest = valid.reversed().max(by: { $0.isOlder(than: $1) }), cachedLocation == nil || !newest.isOlder(than: cachedLocation!) { cachedLocation = newest }
+        guard profile.enabled else { return }
+        locations?(valid, profile.sessionID)
+    }
+    private func ordered(_ fixes: [CLLocation]) -> [TrackedLocation] {
+        let now = clock()
+        let offset = now.wall - now.elapsed
+        let previous = timebase
+        timebase = offset
+        var mapped: [TrackedLocation] = []
+        for fix in fixes {
+            var location = TrackedLocation(fix)
+            var elapsed = location.time - offset
+            if elapsed > now.elapsed + 1000 {
+                guard let previous, abs(previous - offset) >= 2000, location.time - previous <= now.elapsed + 1000 else { continue }
+                elapsed = location.time - previous
+            }
+            location.elapsed = min(elapsed, now.elapsed) > 0 ? min(elapsed, now.elapsed) : nil
+            mapped.append(location)
+        }
+        for index in mapped.indices.reversed().dropFirst() {
+            if let current = mapped[index].elapsed, let next = mapped[index + 1].elapsed, current > next { mapped[index].elapsed = next }
+        }
+        return mapped
+    }
+    func locationManager(_ source: CLLocationManager, didFailWithError failure: Error) {
+        guard source === manager, profile.enabled, (failure as? CLError)?.code != .locationUnknown else { return }
+        let session = profile.sessionID
+        LocationServices.shared.refresh { [weak self] in
+            guard let self, self.profile.enabled, self.profile.sessionID == session else { return }
+            self.authorizationChanged?()
+            if LocationServices.shared.enabled { self.error?(TrackingError((failure as? CLError)?.code == .denied ? "PERMISSION_DENIED" : "UNAVAILABLE", "Core Location route updates failed"), session) }
+        }
+    }
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) { authorizationChanged?() }
+}
+
+extension TrackedLocation {
+    init(_ fix: CLLocation) {
+        self.init(latitude: fix.coordinate.latitude, longitude: fix.coordinate.longitude, accuracy: fix.horizontalAccuracy, altitude: fix.verticalAccuracy >= 0 ? fix.altitude : nil, altitudeAccuracy: fix.verticalAccuracy >= 0 ? fix.verticalAccuracy : nil, speed: fix.speed >= 0 ? fix.speed : nil, speedAccuracy: fix.speedAccuracy >= 0 ? fix.speedAccuracy : nil, heading: fix.course >= 0 ? fix.course : nil, headingAccuracy: fix.courseAccuracy >= 0 ? fix.courseAccuracy : nil, time: fix.timestamp.timeIntervalSince1970 * 1000, isMock: fix.sourceInformation?.isSimulatedBySoftware ?? false)
+    }
+    init(_ fix: CLLocation, receivedAt now: TrackingInstant) {
+        self.init(fix)
+        let mapped = now.elapsed - (now.wall - time)
+        elapsed = time <= now.wall + 1000 && min(mapped, now.elapsed) > 0 ? min(mapped, now.elapsed) : nil
+    }
+    var location: CLLocation {
+        CLLocation(coordinate: CLLocationCoordinate2D(latitude: latitude, longitude: longitude), altitude: altitude ?? 0, horizontalAccuracy: accuracy, verticalAccuracy: altitudeAccuracy ?? -1, course: heading ?? -1, courseAccuracy: headingAccuracy ?? -1, speed: speed ?? -1, speedAccuracy: speedAccuracy ?? -1, timestamp: Date(timeIntervalSince1970: time / 1000))
+    }
+}

package/ios/Sources/LocationTrackingPlugin/LocationTrackingPlugin.swift

@@ -0,0 +1,155 @@
+import Foundation
+import Capacitor
+
+@objc(LocationTrackingPlugin)
+public final class LocationTrackingPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "LocationTrackingPlugin"
+    public let jsName = "LocationTracking"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "ready", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setConfig", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "reset", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getState", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "start", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startGeofences", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stop", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "changePace", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getCurrentPosition", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "clearWatch", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getOdometer", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setOdometer", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "resetOdometer", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getLocations", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getCount", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "insertLocation", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "destroyLocations", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "destroyLocation", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "sync", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "addGeofence", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "addGeofences", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeGeofence", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeGeofences", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getGeofences", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getGeofence", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "geofenceExists", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getHeartbeatStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getProviderState", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isPowerSaveMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getBatteryOptimizationStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "openBatteryOptimizationSettings", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPowerManagerInfo", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "openPowerManagerSettings", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "openLocationSettings", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "openAppSettings", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getDeviceInfo", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSensors", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "log", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getLog", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "destroyLog", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "uploadLog", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "emailLog", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "watchPosition", returnType: CAPPluginReturnCallback),
+    ]
+    private var subscription: NativeSubscription?
+    private var watches: [String: CAPPluginCall] = [:]
+    public override func load() {
+        subscription = LocationTrackingNative.addListener(PluginEventForwarder(self))
+        LocationTrackingNative.bootstrap(registerBackgroundTasks: false)
+    }
+    deinit {
+        subscription?.remove()
+        for id in watches.keys { LocationTrackingNative.call("clearWatch", options: ["id": id]) { _ in } }
+    }
+    public func onEvent(_ name: String, payload: TrackingJSON) {
+        DispatchQueue.main.async { [weak self] in self?.notifyListeners(name, data: payload) }
+    }
+    private func invoke(_ method: String, _ call: CAPPluginCall) {
+        LocationTrackingNative.perform(method, options: call.options as? TrackingJSON ?? [:], native: false) { result in
+            DispatchQueue.main.async {
+                switch result {
+                case .success(let value): call.resolve(value)
+                case .failure(let error): call.reject(error.localizedDescription, (error as? TrackingError)?.code ?? "INTERNAL")
+                }
+            }
+        }
+    }
+    @objc public func watchPosition(_ call: CAPPluginCall) {
+        call.keepAlive = true
+        DispatchQueue.main.async { self.beginWatch(call) }
+    }
+    private func beginWatch(_ call: CAPPluginCall) {
+        guard let id = call.callbackId else { call.reject("Missing callback id", "INTERNAL"); return }
+        watches[id] = call
+        var options: TrackingJSON = call.options as? TrackingJSON ?? [:]
+        options["_watchId"] = id
+        LocationTrackingNative.perform("watchPosition", options: options, native: false) { [weak self] result in
+            DispatchQueue.main.async {
+                guard let self, self.watches[id] != nil else { return }
+                switch result {
+                case .success(let wire): call.resolve(wire)
+                case .failure(let error): call.reject(error.localizedDescription, (error as? TrackingError)?.code ?? "INTERNAL")
+                }
+            }
+        }
+    }
+    @objc public func ready(_ call: CAPPluginCall) { invoke("ready", call) }
+    @objc public func setConfig(_ call: CAPPluginCall) { invoke("setConfig", call) }
+    @objc public func reset(_ call: CAPPluginCall) { invoke("reset", call) }
+    @objc public func getState(_ call: CAPPluginCall) { invoke("getState", call) }
+    @objc public func start(_ call: CAPPluginCall) { invoke("start", call) }
+    @objc public func startGeofences(_ call: CAPPluginCall) { invoke("startGeofences", call) }
+    @objc public func stop(_ call: CAPPluginCall) { invoke("stop", call) }
+    @objc public func changePace(_ call: CAPPluginCall) { invoke("changePace", call) }
+    @objc public func getCurrentPosition(_ call: CAPPluginCall) { invoke("getCurrentPosition", call) }
+    @objc public func clearWatch(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            if let id = call.getString("id"), let watch = self.watches.removeValue(forKey: id) {
+                watch.keepAlive = false
+                self.bridge?.releaseCall(watch)
+            }
+            self.invoke("clearWatch", call)
+        }
+    }
+    @objc public func getOdometer(_ call: CAPPluginCall) { invoke("getOdometer", call) }
+    @objc public func setOdometer(_ call: CAPPluginCall) { invoke("setOdometer", call) }
+    @objc public func resetOdometer(_ call: CAPPluginCall) { invoke("resetOdometer", call) }
+    @objc public func getLocations(_ call: CAPPluginCall) { invoke("getLocations", call) }
+    @objc public func getCount(_ call: CAPPluginCall) { invoke("getCount", call) }
+    @objc public func insertLocation(_ call: CAPPluginCall) { invoke("insertLocation", call) }
+    @objc public func destroyLocations(_ call: CAPPluginCall) { invoke("destroyLocations", call) }
+    @objc public func destroyLocation(_ call: CAPPluginCall) { invoke("destroyLocation", call) }
+    @objc public func sync(_ call: CAPPluginCall) { invoke("sync", call) }
+    @objc public func addGeofence(_ call: CAPPluginCall) { invoke("addGeofence", call) }
+    @objc public func addGeofences(_ call: CAPPluginCall) { invoke("addGeofences", call) }
+    @objc public func removeGeofence(_ call: CAPPluginCall) { invoke("removeGeofence", call) }
+    @objc public func removeGeofences(_ call: CAPPluginCall) { invoke("removeGeofences", call) }
+    @objc public func getGeofences(_ call: CAPPluginCall) { invoke("getGeofences", call) }
+    @objc public func getGeofence(_ call: CAPPluginCall) { invoke("getGeofence", call) }
+    @objc public func geofenceExists(_ call: CAPPluginCall) { invoke("geofenceExists", call) }
+    @objc public func getHeartbeatStatus(_ call: CAPPluginCall) { invoke("getHeartbeatStatus", call) }
+    @objc public func getProviderState(_ call: CAPPluginCall) { invoke("getProviderState", call) }
+    @objc public func isPowerSaveMode(_ call: CAPPluginCall) { invoke("isPowerSaveMode", call) }
+    @objc public func getBatteryOptimizationStatus(_ call: CAPPluginCall) { invoke("getBatteryOptimizationStatus", call) }
+    @objc public func openBatteryOptimizationSettings(_ call: CAPPluginCall) { invoke("openBatteryOptimizationSettings", call) }
+    @objc public func getPowerManagerInfo(_ call: CAPPluginCall) { invoke("getPowerManagerInfo", call) }
+    @objc public func openPowerManagerSettings(_ call: CAPPluginCall) { invoke("openPowerManagerSettings", call) }
+    @objc public func openLocationSettings(_ call: CAPPluginCall) { invoke("openLocationSettings", call) }
+    @objc public func openAppSettings(_ call: CAPPluginCall) { invoke("openAppSettings", call) }
+    @objc public func getDeviceInfo(_ call: CAPPluginCall) { invoke("getDeviceInfo", call) }
+    @objc public func getSensors(_ call: CAPPluginCall) { invoke("getSensors", call) }
+    @objc public override func checkPermissions(_ call: CAPPluginCall) { invoke("checkPermissions", call) }
+    @objc public override func requestPermissions(_ call: CAPPluginCall) { invoke("requestPermissions", call) }
+    @objc public func log(_ call: CAPPluginCall) { invoke("log", call) }
+    @objc public func getLog(_ call: CAPPluginCall) { invoke("getLog", call) }
+    @objc public func destroyLog(_ call: CAPPluginCall) { invoke("destroyLog", call) }
+    @objc public func uploadLog(_ call: CAPPluginCall) { invoke("uploadLog", call) }
+    @objc public func emailLog(_ call: CAPPluginCall) { invoke("emailLog", call) }
+}
+
+private final class PluginEventForwarder: LocationTrackingListener {
+    weak var plugin: LocationTrackingPlugin?
+    init(_ plugin: LocationTrackingPlugin) { self.plugin = plugin }
+    func onEvent(_ name: String, payload: TrackingJSON) { plugin?.onEvent(name, payload: payload) }
+}