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

package/ios/Sources/LocationTrackingPlugin/Geofence/GeofenceSpec.swift

@@ -0,0 +1,103 @@
+import Foundation
+import CoreFoundation
+
+struct GeofenceSpec: Equatable {
+    var identifier: String
+    var latitude: Double
+    var longitude: Double
+    var radius: Double
+    var vertices: [LatLng]? = nil
+    var notifyOnEntry = true
+    var notifyOnExit = true
+    var notifyOnDwell = false
+    var loiteringDelay: Double = 30000
+    var extras: TrackingJSON? = nil
+
+    var isPolygon: Bool { vertices != nil }
+    var isActive: Bool { notifyOnEntry || notifyOnExit || notifyOnDwell }
+
+    static func == (a: GeofenceSpec, b: GeofenceSpec) -> Bool {
+        a.identifier == b.identifier && a.latitude == b.latitude && a.longitude == b.longitude && a.radius == b.radius && a.vertices == b.vertices && a.notifyOnEntry == b.notifyOnEntry && a.notifyOnExit == b.notifyOnExit && a.notifyOnDwell == b.notifyOnDwell && a.loiteringDelay == b.loiteringDelay && NSDictionary(dictionary: a.extras ?? [:]).isEqual(to: b.extras ?? [:]) && (a.extras == nil) == (b.extras == nil)
+    }
+
+    var json: TrackingJSON {
+        var value: TrackingJSON = ["identifier": identifier, "latitude": latitude, "longitude": longitude, "radius": radius, "notifyOnEntry": notifyOnEntry, "notifyOnExit": notifyOnExit, "notifyOnDwell": notifyOnDwell, "loiteringDelay": loiteringDelay]
+        if let vertices { value["vertices"] = vertices.map { [$0.latitude, $0.longitude] } }
+        if let extras { value["extras"] = extras }
+        return value
+    }
+
+    static func stored(_ json: TrackingJSON) -> GeofenceSpec? {
+        guard let identifier = json["identifier"] as? String else { return nil }
+        let vertices = (json["vertices"] as? [[Double]]).map { $0.map { LatLng(latitude: $0[0], longitude: $0[1]) } }
+        return GeofenceSpec(identifier: identifier, latitude: json.number("latitude"), longitude: json.number("longitude"), radius: json.number("radius"), vertices: vertices, notifyOnEntry: json.flag("notifyOnEntry", true), notifyOnExit: json.flag("notifyOnExit", true), notifyOnDwell: json.flag("notifyOnDwell"), loiteringDelay: json.number("loiteringDelay", 30000), extras: json["extras"] as? TrackingJSON)
+    }
+
+    static func parse(_ json: TrackingJSON) throws -> GeofenceSpec {
+        guard let identifier = json["identifier"] as? String, !identifier.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { throw invalid("geofence.identifier is required") }
+        for key in ["latitude", "longitude", "radius", "loiteringDelay"] where !isNull(json[key]) && number(json[key]) == nil { throw invalid("geofence '\(identifier)' \(key) must be a number") }
+        for key in ["notifyOnEntry", "notifyOnExit", "notifyOnDwell"] where !isNull(json[key]) && !isBoolean(json[key]) { throw invalid("geofence '\(identifier)' \(key) must be a boolean") }
+        if !isNull(json["extras"]) && !(json["extras"] is TrackingJSON) { throw invalid("geofence '\(identifier)' extras must be an object") }
+        var vertices: [LatLng]?
+        if !isNull(json["vertices"]) {
+            guard let array = json["vertices"] as? [Any] else { throw invalid("geofence '\(identifier)': vertices must be [[lat,lng],...]") }
+            vertices = try array.enumerated().map { index, item in
+                guard let pair = item as? [Any], pair.count == 2, let latitude = number(pair[0]), let longitude = number(pair[1]) else { throw invalid("geofence '\(identifier)': vertices[\(index)] must be [lat,lng]") }
+                return LatLng(latitude: latitude, longitude: longitude)
+            }
+        }
+        let latitude = number(json["latitude"]), longitude = number(json["longitude"]), radius = number(json["radius"])
+        if vertices == nil && (latitude == nil || longitude == nil || radius == nil) { throw invalid("geofence '\(identifier)' needs latitude, longitude and radius, or vertices") }
+        let delay = number(json["loiteringDelay"]) ?? 30000
+        if delay < 0 { throw invalid("geofence '\(identifier)' loiteringDelay must be >= 0") }
+        let spec = GeofenceSpec(identifier: identifier, latitude: latitude ?? 0, longitude: longitude ?? 0, radius: radius ?? 0, vertices: vertices, notifyOnEntry: (json["notifyOnEntry"] as? Bool) ?? true, notifyOnExit: (json["notifyOnExit"] as? Bool) ?? true, notifyOnDwell: (json["notifyOnDwell"] as? Bool) ?? false, loiteringDelay: delay.rounded(.towardZero), extras: json["extras"] as? TrackingJSON)
+        if let vertices {
+            if vertices.count < 3 { throw invalid("geofence '\(identifier)' needs at least 3 vertices") }
+            for (index, vertex) in vertices.enumerated() {
+                if !(-90...90).contains(vertex.latitude) || !vertex.latitude.isFinite { throw invalid("geofence '\(identifier)' vertices[\(index)] latitude is out of range") }
+                if !(-180...180).contains(vertex.longitude) || !vertex.longitude.isFinite { throw invalid("geofence '\(identifier)' vertices[\(index)] longitude is out of range") }
+            }
+        } else {
+            if !(-90...90).contains(spec.latitude) || !spec.latitude.isFinite { throw invalid("geofence '\(identifier)' latitude is out of range") }
+            if !(-180...180).contains(spec.longitude) || !spec.longitude.isFinite { throw invalid("geofence '\(identifier)' longitude is out of range") }
+            if !(spec.radius > 0) || spec.radius.isInfinite { throw invalid("geofence '\(identifier)' radius must be > 0") }
+        }
+        return spec
+    }
+
+    private static func isNull(_ value: Any?) -> Bool { value == nil || value is NSNull }
+    private static func isBoolean(_ value: Any?) -> Bool { (value as? NSNumber).map { CFGetTypeID($0) == CFBooleanGetTypeID() } ?? false }
+    private static func number(_ value: Any?) -> Double? {
+        guard let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID(), number.doubleValue.isFinite else { return nil }
+        return number.doubleValue
+    }
+    private static func invalid(_ message: String) -> TrackingError { TrackingError("INVALID_ARGUMENT", message) }
+}
+
+struct GeofenceRuntime: Equatable {
+    var insideCircle = false
+    var insidePolygon = false
+    var enteredAt: Double? = nil
+    static let unknown = GeofenceRuntime()
+    var json: TrackingJSON { ["insideCircle": insideCircle, "insidePolygon": insidePolygon, "enteredAt": enteredAt as Any? ?? NSNull()] }
+    static func from(_ json: TrackingJSON) -> GeofenceRuntime { GeofenceRuntime(insideCircle: json.flag("insideCircle"), insidePolygon: json.flag("insidePolygon"), enteredAt: json["enteredAt"] as? Double) }
+}
+
+enum GeofenceAction: String { case enter = "ENTER", exit = "EXIT", dwell = "DWELL" }
+
+struct OsGeofence: Equatable {
+    var id: String
+    var latitude: Double
+    var longitude: Double
+    var radius: Double
+    var onEntry: Bool
+    var onExit: Bool
+    var initialTriggerEntry: Bool
+}
+
+struct OsGeofenceTransition: Equatable {
+    var id: String
+    var action: GeofenceAction
+    var location: TrackedLocation?
+    var initial = false
+}

package/ios/Sources/LocationTrackingPlugin/Geofence/GeofenceStore.swift

@@ -0,0 +1,52 @@
+import Foundation
+
+protocol GeofenceStore: AnyObject {
+    func upsert(_ specs: [GeofenceSpec]) throws
+    func remove(_ ids: [String]) throws
+    func removeAll() throws
+    func all() throws -> [GeofenceSpec]
+    func get(_ id: String) throws -> GeofenceSpec?
+    func setRuntime(_ id: String, _ runtime: GeofenceRuntime) throws
+    func runtimes() throws -> [String: GeofenceRuntime]
+}
+
+final class SQLiteGeofenceStore: GeofenceStore {
+    private let store: TrackingStore
+    private let key = "geofences"
+    init(store: TrackingStore) { self.store = store }
+    private func load() throws -> TrackingJSON { try store.load(key) ?? [:] }
+    private func save(_ rows: TrackingJSON) throws { try store.save(key, rows) }
+    func upsert(_ specs: [GeofenceSpec]) throws {
+        guard !specs.isEmpty else { return }
+        var rows = try load()
+        for spec in specs {
+            var row = rows.object(spec.identifier)
+            row["spec"] = spec.json
+            rows[spec.identifier] = row
+        }
+        try save(rows)
+    }
+    func remove(_ ids: [String]) throws {
+        guard !ids.isEmpty else { return }
+        var rows = try load()
+        ids.forEach { rows.removeValue(forKey: $0) }
+        try save(rows)
+    }
+    func removeAll() throws { try save([:]) }
+    func all() throws -> [GeofenceSpec] {
+        try load().sorted { $0.key.utf8.lexicographicallyPrecedes($1.key.utf8) }.compactMap { GeofenceSpec.stored(($0.value as? TrackingJSON)?.object("spec") ?? [:]) }
+    }
+    func get(_ id: String) throws -> GeofenceSpec? { GeofenceSpec.stored(try load().object(id).object("spec")) }
+    func setRuntime(_ id: String, _ runtime: GeofenceRuntime) throws {
+        var rows = try load()
+        guard var row = rows[id] as? TrackingJSON else { return }
+        row["runtime"] = runtime.json
+        rows[id] = row
+        try save(rows)
+    }
+    func runtimes() throws -> [String: GeofenceRuntime] {
+        var result: [String: GeofenceRuntime] = [:]
+        for (id, value) in try load() { if let runtime = (value as? TrackingJSON)?["runtime"] as? TrackingJSON { result[id] = GeofenceRuntime.from(runtime) } }
+        return result
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Geofence/PolygonMath.swift

@@ -0,0 +1,176 @@
+import Foundation
+
+struct LatLng: Equatable, Hashable {
+    var latitude: Double
+    var longitude: Double
+}
+
+struct XorWowRandom {
+    private var x: Int32, y: Int32, z: Int32, w: Int32, v: Int32, addend: Int32
+    init(seed: Int32) {
+        x = seed; y = seed >> 31; z = 0; w = 0; v = ~seed
+        addend = (seed << 10) ^ Int32(bitPattern: UInt32(bitPattern: seed >> 31) >> 4)
+        for _ in 0..<64 { _ = nextInt() }
+    }
+    mutating func nextInt() -> Int32 {
+        var t = x
+        t = t ^ Int32(bitPattern: UInt32(bitPattern: t) >> 2)
+        x = y; y = z; z = w
+        let v0 = v
+        w = v0
+        t = (t ^ (t << 1)) ^ v0 ^ (v0 << 4)
+        v = t
+        addend = addend &+ 362437
+        return t &+ addend
+    }
+    mutating func nextBits(_ count: Int32) -> Int32 {
+        Int32(bitPattern: UInt32(bitPattern: nextInt()) >> UInt32(32 - count)) & ((-count) >> 31)
+    }
+    mutating func nextInt(_ until: Int32) -> Int32 {
+        if until & -until == until { return nextBits(Int32(31 - until.leadingZeroBitCount)) }
+        while true {
+            let bits = Int32(bitPattern: UInt32(bitPattern: nextInt()) >> 1)
+            let value = bits % until
+            if bits &- value &+ (until - 1) >= 0 { return value }
+        }
+    }
+    mutating func nextDouble() -> Double {
+        let high = Int64(nextBits(26)), low = Int64(nextBits(27))
+        return Double((high << 27) + low) / Double(Int64(1) << 53)
+    }
+    mutating func nextDouble(_ from: Double, _ until: Double) -> Double {
+        let value = from + nextDouble() * (until - from)
+        return value >= until ? until.nextDown : value
+    }
+    mutating func shuffled<T>(_ values: [T]) -> [T] {
+        var result = values
+        for index in stride(from: result.count - 1, through: 1, by: -1) { result.swapAt(index, Int(nextInt(Int32(index + 1)))) }
+        return result
+    }
+}
+
+enum PolygonMath {
+    static let earthRadius = 6371008.8
+    static let padding = 1.1
+    static let minimumEnclosingRadius = 50.0
+    private static let epsilon = 1e-6
+
+    struct Circle: Equatable {
+        var latitude: Double
+        var longitude: Double
+        var radius: Double
+    }
+
+    static func isValidLatLng(_ latitude: Double, _ longitude: Double) -> Bool {
+        latitude.isFinite && longitude.isFinite && (-90...90).contains(latitude) && (-180...180).contains(longitude)
+    }
+
+    static func distanceMeters(_ lat1: Double, _ lng1: Double, _ lat2: Double, _ lng2: Double) -> Double {
+        let phi1 = lat1 * .pi / 180, phi2 = lat2 * .pi / 180
+        let dPhi = phi2 - phi1, dLambda = (lng2 - lng1) * .pi / 180
+        let a = sin(dPhi / 2) * sin(dPhi / 2) + cos(phi1) * cos(phi2) * sin(dLambda / 2) * sin(dLambda / 2)
+        return 2 * earthRadius * asin(min(1, sqrt(a)))
+    }
+
+    static func contains(_ vertices: [LatLng], _ latitude: Double, _ longitude: Double) -> Bool {
+        var inside = false
+        var j = vertices.count - 1
+        for i in vertices.indices {
+            let yi = vertices[i].latitude, xi = vertices[i].longitude, yj = vertices[j].latitude, xj = vertices[j].longitude
+            if (yi > latitude) != (yj > latitude) && longitude < (xj - xi) * (latitude - yi) / (yj - yi) + xi { inside.toggle() }
+            j = i
+        }
+        return inside
+    }
+
+    static func distanceToBoundary(_ vertices: [LatLng], _ latitude: Double, _ longitude: Double) -> Double {
+        guard !vertices.isEmpty else { return .infinity }
+        let projection = Projection(latitude, longitude)
+        let points = vertices.map { projection.point($0.latitude, $0.longitude) }
+        if points.count == 1 { return hypot(points[0].x, points[0].y) }
+        var best = Double.infinity
+        var j = points.count - 1
+        for i in points.indices {
+            best = min(best, distanceToSegment(points[j], points[i]))
+            j = i
+        }
+        return best
+    }
+
+    static func areaSquareMeters(_ vertices: [LatLng]) -> Double {
+        guard vertices.count >= 3 else { return 0 }
+        let projection = Projection.around(vertices)
+        let points = vertices.map { projection.point($0.latitude, $0.longitude) }
+        var sum = 0.0
+        var j = points.count - 1
+        for i in points.indices {
+            sum += points[j].x * points[i].y - points[i].x * points[j].y
+            j = i
+        }
+        return abs(sum) / 2
+    }
+
+    static func minimalEnclosingCircle(_ vertices: [LatLng]) -> Circle {
+        precondition(!vertices.isEmpty)
+        let projection = Projection.around(vertices)
+        var random = XorWowRandom(seed: Int32(vertices.count))
+        let points = random.shuffled(vertices.map { projection.point($0.latitude, $0.longitude) })
+        var c = PlaneCircle(x: points[0].x, y: points[0].y, r: 0)
+        for i in points.indices where !c.contains(points[i]) {
+            c = PlaneCircle(x: points[i].x, y: points[i].y, r: 0)
+            for j in 0..<i where !c.contains(points[j]) {
+                c = PlaneCircle.diameter(points[i], points[j])
+                for k in 0..<j where !c.contains(points[k]) { c = PlaneCircle.through(points[i], points[j], points[k]) }
+            }
+        }
+        let center = projection.latLng(c.x, c.y)
+        let radius = vertices.map { distanceMeters(center.latitude, center.longitude, $0.latitude, $0.longitude) }.max() ?? 0
+        return Circle(latitude: center.latitude, longitude: center.longitude, radius: radius)
+    }
+
+    static func enclosingCircle(_ vertices: [LatLng]) -> Circle {
+        var circle = minimalEnclosingCircle(vertices)
+        circle.radius = max(circle.radius * padding, minimumEnclosingRadius)
+        return circle
+    }
+
+    private static func distanceToSegment(_ a: Point, _ b: Point) -> Double {
+        let dx = b.x - a.x, dy = b.y - a.y
+        let lengthSquared = dx * dx + dy * dy
+        if lengthSquared == 0 { return hypot(a.x, a.y) }
+        let t = min(1, max(0, (-a.x * dx - a.y * dy) / lengthSquared))
+        return hypot(a.x + t * dx, a.y + t * dy)
+    }
+
+    private struct Point { var x: Double; var y: Double }
+
+    private struct Projection {
+        let lat0: Double, lng0: Double, cosLat0: Double
+        init(_ lat0: Double, _ lng0: Double) { self.lat0 = lat0; self.lng0 = lng0; cosLat0 = max(cos(lat0 * .pi / 180), 1e-9) }
+        func point(_ latitude: Double, _ longitude: Double) -> Point {
+            Point(x: (longitude - lng0) * .pi / 180 * cosLat0 * PolygonMath.earthRadius, y: (latitude - lat0) * .pi / 180 * PolygonMath.earthRadius)
+        }
+        func latLng(_ x: Double, _ y: Double) -> LatLng {
+            LatLng(latitude: lat0 + y / PolygonMath.earthRadius * 180 / .pi, longitude: lng0 + x / (PolygonMath.earthRadius * cosLat0) * 180 / .pi)
+        }
+        static func around(_ vertices: [LatLng]) -> Projection {
+            let latitudes = vertices.map(\.latitude), longitudes = vertices.map(\.longitude)
+            return Projection((latitudes.min()! + latitudes.max()!) / 2, (longitudes.min()! + longitudes.max()!) / 2)
+        }
+    }
+
+    private struct PlaneCircle {
+        var x: Double, y: Double, r: Double
+        func contains(_ p: Point) -> Bool { hypot(p.x - x, p.y - y) <= r + PolygonMath.epsilon + r * 1e-12 }
+        static func diameter(_ a: Point, _ b: Point) -> PlaneCircle { PlaneCircle(x: (a.x + b.x) / 2, y: (a.y + b.y) / 2, r: hypot(a.x - b.x, a.y - b.y) / 2) }
+        static func through(_ a: Point, _ b: Point, _ c: Point) -> PlaneCircle {
+            let bx = b.x - a.x, by = b.y - a.y, cx = c.x - a.x, cy = c.y - a.y
+            let d = 2 * (bx * cy - by * cx)
+            let scale = max(bx * bx + by * by, cx * cx + cy * cy)
+            if abs(d) <= 1e-12 * max(scale, 1e-12) { return [diameter(a, b), diameter(a, c), diameter(b, c)].max { $0.r < $1.r }! }
+            let b2 = bx * bx + by * by, c2 = cx * cx + cy * cy
+            let ux = (cy * b2 - by * c2) / d, uy = (bx * c2 - cx * b2) / d
+            return PlaneCircle(x: a.x + ux, y: a.y + uy, r: hypot(ux, uy))
+        }
+    }
+}

package/ios/Sources/LocationTrackingPlugin/Heartbeat/ExecutionAssertion.swift

@@ -0,0 +1,33 @@
+import Foundation
+import UIKit
+
+final class ExecutionAssertion {
+    private let lock = NSLock()
+    private let begin: (@escaping () -> Void) -> Int
+    private let end: (Int) -> Void
+    private var identifier: Int?
+    private var ended = false
+    private var timeout: DispatchWorkItem?
+    init(begin: @escaping (@escaping () -> Void) -> Int = { expiration in UIApplication.shared.beginBackgroundTask(withName: "Location tracking heartbeat", expirationHandler: expiration).rawValue }, end: @escaping (Int) -> Void = { UIApplication.shared.endBackgroundTask(UIBackgroundTaskIdentifier(rawValue: $0)) }) { self.begin = begin; self.end = end }
+    func start(seconds: Double, queue: DispatchQueue) {
+        guard seconds > 0 else { finish(); return }
+        let id = begin { [weak self] in self?.finish() }
+        lock.lock()
+        if ended { lock.unlock(); if id != UIBackgroundTaskIdentifier.invalid.rawValue { end(id) }; return }
+        identifier = id
+        let item = DispatchWorkItem { [weak self] in self?.finish() }
+        timeout = item
+        lock.unlock()
+        queue.asyncAfter(deadline: .now() + seconds, execute: item)
+    }
+    func finish() {
+        lock.lock()
+        guard !ended else { lock.unlock(); return }
+        ended = true
+        timeout?.cancel(); timeout = nil
+        let id = identifier; identifier = nil
+        lock.unlock()
+        if let id, id != UIBackgroundTaskIdentifier.invalid.rawValue { end(id) }
+    }
+    deinit { finish() }
+}

package/ios/Sources/LocationTrackingPlugin/Heartbeat/HeartbeatWindow.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+struct HeartbeatWindow: Equatable {
+    var baseElapsed: Double
+    var dueElapsed: Double
+    var deadlineElapsed: Double
+    var nextHeartbeatAt: Double?
+    var minInterval: Double
+    var enabled: Bool
+    func shouldFire(_ elapsed: Double) -> Bool { elapsed >= dueElapsed - 1000 }
+    func needsRearm(_ armed: HeartbeatWindow?) -> Bool {
+        guard let armed, armed.enabled == enabled else { return true }
+        let move = dueElapsed - armed.dueElapsed
+        return move < 0 || move >= 30000
+    }
+    static func compute(lastRecordAt: Double?, lastRecordElapsed: Double?, sameBoot: Bool?, now: Double, nowElapsed: Double, minInterval: Double = 180, maxInterval: Double = 300, enabled: Bool = true, noRecordBaseElapsed: Double? = nil, lastAttemptElapsed: Double? = nil, trackingStartedAt: Double? = nil) -> HeartbeatWindow {
+        let minimum = max(60, minInterval) * 1000
+        let maximum = max(minimum, maxInterval * 1000)
+        var base: Double
+        if let at = lastRecordAt {
+            if let elapsed = lastRecordElapsed, sameBoot ?? (elapsed <= nowElapsed) { base = elapsed }
+            else { base = nowElapsed - (now - at) }
+            if let started = trackingStartedAt, at < started, started <= now { base = max(base, nowElapsed - (now - started)) }
+        } else { base = noRecordBaseElapsed ?? nowElapsed }
+        base = min(base, nowElapsed)
+        let due = max(base + minimum, lastAttemptElapsed.map { $0 + minimum } ?? -.infinity)
+        return HeartbeatWindow(baseElapsed: base, dueElapsed: due, deadlineElapsed: base + maximum, nextHeartbeatAt: enabled ? now + max(0, due - nowElapsed) : nil, minInterval: minimum, enabled: enabled)
+    }
+}

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

@@ -0,0 +1,52 @@
+import Foundation
+
+struct BodyBuilder {
+    private static let placeholder = try! NSRegularExpression(pattern: "(\"?)<%=\\s*(.*?)\\s*%>(\"?)", options: .dotMatchesLineSeparators)
+    private static let coordinateKeys: Set<String> = ["latitude", "longitude", "accuracy", "altitude", "altitude_accuracy", "speed", "speed_accuracy", "heading", "heading_accuracy"]
+    private static let supported: Set<String> = ["uuid", "event", "timestamp", "recorded_at", "sent_at", "latitude", "longitude", "accuracy", "altitude", "altitude_accuracy", "speed", "speed_accuracy", "heading", "heading_accuracy", "is_moving", "odometer", "mock", "activity.type", "activity.confidence", "battery.level", "battery.is_charging", "battery.temperature", "battery.health", "battery.plugged", "network", "device.device_id", "device.background_restricted", "device.standby_bucket", "device.disk_free_bytes", "device.thermal_status", "device.manufacturer", "device.model", "device.os_version", "device.sdk_int", "device.low_ram_device", "device.ram_total_bytes", "elapsed_realtime_ms", "boot_count", "backend", "reason", "stopped_at", "geofence.identifier", "geofence.action", "provider.enabled", "provider.gps", "provider.network", "provider.permission", "extras", "record", "provider", "device"]
+    static func build(_ records: [TrackingJSON], http: TrackingJSON, sentAt: String = iso()) throws -> Data {
+        let rendered = records.map { record -> Any in
+            var wire = record
+            wire["sent_at"] = sentAt
+            let template = record.text("event") == "geofence" ? http.text("geofenceTemplate", http.text("locationTemplate")) : http.text("locationTemplate")
+            return render(template, record: wire) ?? wire
+        }
+        let root = http.text("rootProperty", "location")
+        let merge = root == "." || root.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        let batch = http.flag("batchSync")
+        if merge && batch { return try jsonData(rendered) }
+        let value: Any = batch ? rendered : rendered[0]
+        var body: TrackingJSON
+        if merge {
+            guard let object = value as? TrackingJSON else { return try jsonData(value) }
+            body = object
+        } else { body = [root: value] }
+        for (key, value) in http.object("params") where body[key] == nil { body[key] = value }
+        return try jsonData(body)
+    }
+    static func render(_ template: String, record: TrackingJSON) -> Any? {
+        guard !template.isEmpty else { return nil }
+        let source = template as NSString
+        var output = template
+        for match in Self.placeholder.matches(in: template, range: NSRange(location: 0, length: source.length)).reversed() {
+            let key = source.substring(with: match.range(at: 2))
+            let open = source.substring(with: match.range(at: 1))
+            let close = source.substring(with: match.range(at: 3))
+            let path = Self.coordinateKeys.contains(key) ? "coords." + key : key
+            var value: Any? = record
+            if key != "record" {
+                for component in path.split(separator: ".") { value = (value as? TrackingJSON)?[String(component)] }
+            }
+            if key == "extras", value == nil { value = TrackingJSON() }
+            let replacement: String
+            if !Self.supported.contains(key) { replacement = open + close }
+            else if value == nil || value is NSNull { replacement = open.isEmpty || close.isEmpty ? open + "null" + close : "null" }
+            else if let data = try? jsonData(value!), let literal = String(data: data, encoding: .utf8) {
+                replacement = open + (value is String ? String(literal.dropFirst().dropLast()) : literal) + close
+            } else { replacement = "null" }
+            if let range = Range(match.range, in: output) { output.replaceSubrange(range, with: replacement) }
+        }
+        guard StrictJSON.isValid(output), let data = output.data(using: .utf8), let value = try? JSONSerialization.jsonObject(with: data), value is TrackingJSON || value is [Any] else { return nil }
+        return value
+    }
+}

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

@@ -0,0 +1,87 @@
+import Foundation
+
+struct HTTPResponse {
+    let status: Int
+    let body: Data
+    let retryAfter: String?
+    var success: Bool { (200..<300).contains(status) }
+}
+
+final class HTTPTransport: NSObject, URLSessionDataDelegate {
+    private struct Pending {
+        var data = Data()
+        var response: HTTPURLResponse?
+        var timeout: DispatchWorkItem?
+        let responseLimit: Int?
+        let completion: (Result<HTTPResponse, Error>) -> Void
+    }
+    private var pending: [Int: Pending] = [:]
+    private let lock = NSLock()
+    private var closed = false
+    private lazy var session: URLSession = {
+        let config = URLSessionConfiguration.ephemeral
+        config.urlCache = nil
+        config.httpCookieStorage = nil
+        config.urlCredentialStorage = nil
+        config.requestCachePolicy = .reloadIgnoringLocalCacheData
+        config.waitsForConnectivity = false
+        return URLSession(configuration: config, delegate: self, delegateQueue: nil)
+    }()
+    func send(url: URL, method: String, headers: [String: String], body: Data, timeout: Double, responseLimit: Int? = 16384, completion: @escaping (Result<HTTPResponse, Error>) -> Void) {
+        var request = URLRequest(url: url, timeoutInterval: timeout / 1000)
+        request.httpMethod = method
+        request.httpBody = body
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        for (name, value) in headers { request.setValue(value, forHTTPHeaderField: name) }
+        lock.lock()
+        guard !closed else { lock.unlock(); completion(.failure(URLError(.cancelled))); return }
+        let task = session.dataTask(with: request)
+        let deadline = DispatchWorkItem { [weak self, weak task] in
+            guard let self, let task else { return }
+            self.lock.lock(); let item = self.pending.removeValue(forKey: task.taskIdentifier); self.lock.unlock()
+            guard let item else { return }
+            task.cancel()
+            item.completion(.failure(URLError(.timedOut)))
+        }
+        pending[task.taskIdentifier] = Pending(timeout: deadline, responseLimit: responseLimit, completion: completion); lock.unlock()
+        DispatchQueue.global().asyncAfter(deadline: .now() + timeout / 1000, execute: deadline)
+        task.resume()
+    }
+    func cancel() {
+        lock.lock()
+        guard !closed else { lock.unlock(); return }
+        let current = session
+        lock.unlock()
+        current.getAllTasks { $0.forEach { $0.cancel() } }
+    }
+    func close() {
+        lock.lock()
+        guard !closed else { lock.unlock(); return }
+        closed = true
+        let current = session
+        lock.unlock()
+        current.invalidateAndCancel()
+    }
+    func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse, newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) { completionHandler(nil) }
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
+        lock.lock(); pending[dataTask.taskIdentifier]?.response = response as? HTTPURLResponse; lock.unlock()
+        completionHandler(.allow)
+    }
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        lock.lock()
+        if var item = pending[dataTask.taskIdentifier] {
+            if let limit = item.responseLimit { item.data.append(data.prefix(max(0, limit - item.data.count))) }
+            else { item.data.append(data) }
+            pending[dataTask.taskIdentifier] = item
+        }
+        lock.unlock()
+    }
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        lock.lock(); let item = pending.removeValue(forKey: task.taskIdentifier); lock.unlock()
+        guard let item else { return }
+        item.timeout?.cancel()
+        if let error { item.completion(.failure(error)) }
+        else if let response = item.response { item.completion(.success(HTTPResponse(status: response.statusCode, body: item.data, retryAfter: response.value(forHTTPHeaderField: "Retry-After")))) }
+        else { item.completion(.failure(TrackingError("NETWORK_ERROR", "No HTTP response"))) }
+    }
+}

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

@@ -0,0 +1,98 @@
+import Foundation
+
+struct StrictJSON {
+    private let bytes: [UInt8]
+    private var index = 0
+    init(_ text: String) { bytes = Array(text.utf8) }
+    static func isValid(_ text: String) -> Bool {
+        var parser = StrictJSON(text)
+        parser.whitespace()
+        guard parser.value(0) else { return false }
+        parser.whitespace()
+        return parser.index == parser.bytes.count
+    }
+    private mutating func whitespace() { while index < bytes.count && [9, 10, 13, 32].contains(bytes[index]) { index += 1 } }
+    private mutating func consume(_ byte: UInt8) -> Bool {
+        guard index < bytes.count && bytes[index] == byte else { return false }
+        index += 1; return true
+    }
+    private mutating func value(_ depth: Int) -> Bool {
+        guard depth <= 256 && index < bytes.count else { return false }
+        switch bytes[index] {
+        case 123: return object(depth + 1)
+        case 91: return array(depth + 1)
+        case 34: return string()
+        case 116: return literal("true")
+        case 102: return literal("false")
+        case 110: return literal("null")
+        default: return number()
+        }
+    }
+    private mutating func object(_ depth: Int) -> Bool {
+        index += 1; whitespace()
+        if consume(125) { return true }
+        while true {
+            whitespace()
+            guard index < bytes.count && bytes[index] == 34 && string() else { return false }
+            whitespace()
+            guard consume(58) else { return false }
+            whitespace()
+            guard value(depth) else { return false }
+            whitespace()
+            if consume(125) { return true }
+            guard consume(44) else { return false }
+        }
+    }
+    private mutating func array(_ depth: Int) -> Bool {
+        index += 1; whitespace()
+        if consume(93) { return true }
+        while true {
+            whitespace()
+            guard value(depth) else { return false }
+            whitespace()
+            if consume(93) { return true }
+            guard consume(44) else { return false }
+        }
+    }
+    private mutating func string() -> Bool {
+        index += 1
+        while index < bytes.count {
+            let byte = bytes[index]; index += 1
+            if byte == 34 { return true }
+            if byte < 32 { return false }
+            if byte == 92 {
+                guard index < bytes.count else { return false }
+                let escape = bytes[index]; index += 1
+                if escape == 117 {
+                    guard index + 4 <= bytes.count else { return false }
+                    guard bytes[index..<index + 4].allSatisfy({ (48...57).contains($0) || (65...70).contains($0) || (97...102).contains($0) }) else { return false }
+                    index += 4
+                } else if ![34, 92, 47, 98, 102, 110, 114, 116].contains(escape) { return false }
+            }
+        }
+        return false
+    }
+    private mutating func literal(_ text: String) -> Bool {
+        let expected = Array(text.utf8)
+        guard index + expected.count <= bytes.count && Array(bytes[index..<index + expected.count]) == expected else { return false }
+        index += expected.count; return true
+    }
+    private mutating func number() -> Bool {
+        _ = consume(45)
+        guard index < bytes.count else { return false }
+        if bytes[index] == 48 { index += 1 }
+        else if (49...57).contains(bytes[index]) { _ = digits() }
+        else { return false }
+        if consume(46) && !digits() { return false }
+        if consume(101) || consume(69) {
+            if !consume(43) { _ = consume(45) }
+            if !digits() { return false }
+        }
+        return true
+    }
+    private mutating func digits() -> Bool {
+        let start = index
+        while index < bytes.count && (48...57).contains(bytes[index]) { index += 1 }
+        return index > start
+    }
+}