@bglocation/capacitor 1.1.0

package/ios/Sources/BGLocationCore/Http/BGLHttpSender.swift

@@ -0,0 +1,227 @@
+import Foundation
+
+public struct BGLHttpResult {
+    public let statusCode: Int
+    public let success: Bool
+    public let responseText: String
+    public let error: String?
+    public let bufferedCount: Int
+
+    public init(
+        statusCode: Int, success: Bool, responseText: String, error: String?, bufferedCount: Int = 0
+    ) {
+        self.statusCode = statusCode
+        self.success = success
+        self.responseText = responseText
+        self.error = error
+        self.bufferedCount = bufferedCount
+    }
+}
+
+public class BGLHttpSender {
+
+    private var url: URL?
+    private var headers: [String: String] = [:]
+    private let session: URLSession
+    private var buffer: BGLLocationBuffer?
+    private var isFlushing = false
+    private let flushLock = NSLock()
+    private static let flushBatchSize = 50
+
+    /// Called for each HTTP result during buffer flush. Set this to receive onHttp events for flushed items.
+    public var onFlushProgress: ((BGLHttpResult) -> Void)?
+
+    public init(session: URLSession = .shared) {
+        self.session = session
+    }
+
+    public func configure(url: String?, headers: [String: String]) {
+        if let url = url {
+            self.url = URL(string: url)
+        } else {
+            self.url = nil
+        }
+        self.headers = headers
+    }
+
+    public func setBuffer(_ locationBuffer: BGLLocationBuffer?) {
+        buffer = locationBuffer
+    }
+
+    public var isConfigured: Bool {
+        url != nil
+    }
+
+    public func sendLocation(
+        _ location: BGLLocationData, completion: @escaping (BGLHttpResult) -> Void
+    ) {
+        guard let url = url else { return }
+
+        let locationDict = location.toDict()
+        executePost(url: url, locationDict: locationDict) { [weak self] result in
+            guard let self = self else { return }
+
+            if !result.success, let buf = self.buffer {
+                buf.add(location)
+                let count = buf.count()
+                print("BGLocation: HTTP failed, location buffered (buffer=\(count))")
+                completion(
+                    BGLHttpResult(
+                        statusCode: result.statusCode,
+                        success: false,
+                        responseText: result.responseText,
+                        error: result.error,
+                        bufferedCount: count
+                    ))
+            } else {
+                let count = self.buffer?.count() ?? 0
+                completion(
+                    BGLHttpResult(
+                        statusCode: result.statusCode,
+                        success: result.success,
+                        responseText: result.responseText,
+                        error: result.error,
+                        bufferedCount: count
+                    ))
+                // After a successful send, try to flush buffered items
+                if result.success && count > 0 {
+                    self.flushBuffer(onProgress: self.onFlushProgress)
+                }
+            }
+        }
+    }
+
+    /// Flush buffered locations to the server.
+    public func flushBuffer(onProgress: ((BGLHttpResult) -> Void)?) {
+        guard let url = url, let buf = buffer else { return }
+        flushLock.lock()
+        guard !isFlushing else {
+            flushLock.unlock()
+            return
+        }
+        isFlushing = true
+        flushLock.unlock()
+
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            guard let self = self else { return }
+            defer {
+                self.flushLock.lock()
+                self.isFlushing = false
+                self.flushLock.unlock()
+            }
+
+            while true {
+                let batch = buf.peek(limit: BGLHttpSender.flushBatchSize)
+                if batch.isEmpty { break }
+
+                var successIds: [Int64] = []
+                let group = DispatchGroup()
+
+                for (id, location) in batch {
+                    var sendResult: BGLHttpResult?
+                    group.enter()
+                    self.executePost(url: url, locationDict: location.toDict()) { result in
+                        sendResult = result
+                        group.leave()
+                    }
+                    group.wait()
+
+                    if let result = sendResult, result.success {
+                        successIds.append(id)
+                    } else {
+                        // Stop flushing on first failure
+                        if !successIds.isEmpty {
+                            buf.remove(ids: successIds)
+                        }
+                        let count = buf.count()
+                        if let progress = onProgress {
+                            DispatchQueue.main.async {
+                                progress(
+                                    BGLHttpResult(
+                                        statusCode: sendResult?.statusCode ?? 0,
+                                        success: false,
+                                        responseText: sendResult?.responseText ?? "",
+                                        error: sendResult?.error,
+                                        bufferedCount: count
+                                    ))
+                            }
+                        }
+                        return
+                    }
+                }
+                if !successIds.isEmpty {
+                    buf.remove(ids: successIds)
+                }
+            }
+
+            let count = buf.count()
+            if count == 0 {
+                print("BGLocation: Buffer flush complete — all locations sent")
+            }
+            if let progress = onProgress {
+                DispatchQueue.main.async {
+                    progress(
+                        BGLHttpResult(
+                            statusCode: 200,
+                            success: true,
+                            responseText: "",
+                            error: nil,
+                            bufferedCount: count
+                        ))
+                }
+            }
+        }
+    }
+
+    // MARK: - Private
+
+    private func executePost(
+        url: URL, locationDict: [String: Any], completion: @escaping (BGLHttpResult) -> Void
+    ) {
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.timeoutInterval = 10
+
+        for (key, value) in headers {
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+
+        let body: [String: Any] = ["location": locationDict]
+
+        do {
+            request.httpBody = try JSONSerialization.data(withJSONObject: body)
+        } catch {
+            completion(
+                BGLHttpResult(
+                    statusCode: 0, success: false, responseText: "",
+                    error: error.localizedDescription))
+            return
+        }
+
+        session.dataTask(with: request) { data, response, error in
+            if let error = error {
+                print("BGLocation: HTTP POST failed — \(error.localizedDescription)")
+                completion(
+                    BGLHttpResult(
+                        statusCode: 0, success: false, responseText: "",
+                        error: error.localizedDescription))
+                return
+            }
+
+            let httpResponse = response as? HTTPURLResponse
+            let statusCode = httpResponse?.statusCode ?? 0
+            let responseText = data.flatMap { String(data: $0, encoding: .utf8) } ?? ""
+
+            print("BGLocation: HTTP POST → \(url) → \(statusCode)")
+
+            completion(
+                BGLHttpResult(
+                    statusCode: statusCode,
+                    success: (200...299).contains(statusCode),
+                    responseText: responseText,
+                    error: nil
+                ))
+        }.resume()
+    }
+}

package/ios/Sources/BGLocationCore/Http/BGLLocationBuffer.swift

@@ -0,0 +1,198 @@
+import Foundation
+import SQLite3
+
+/// SQLite-backed offline buffer for location data.
+///
+/// When HTTP upload fails, locations are stored locally and retried later.
+/// The buffer enforces a configurable maximum size — oldest entries are dropped
+/// when the limit is exceeded.
+public class BGLLocationBuffer {
+
+    public static let dbName = "bgl_location_buffer.db"
+
+    private var db: OpaquePointer?
+    private var maxSize: Int = 1000
+    private let dbPath: String
+
+    /// Called when buffer overflow triggers auto-trim. Parameter is the number of dropped entries.
+    public var onOverflow: ((Int) -> Void)?
+
+    public init(dbPath: String? = nil, maxSize: Int = 1000) {
+        if let dbPath = dbPath {
+            self.dbPath = dbPath
+        } else {
+            let docsUrl = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
+                .first!
+            self.dbPath = docsUrl.appendingPathComponent(BGLLocationBuffer.dbName).path
+        }
+        self.maxSize = maxSize
+        openDatabase()
+        createTable()
+    }
+
+    deinit {
+        close()
+    }
+
+    public func close() {
+        if let db = db {
+            sqlite3_close(db)
+            self.db = nil
+        }
+    }
+
+    public func configure(maxSize: Int) {
+        self.maxSize = maxSize
+    }
+
+    // MARK: - Public API
+
+    /// Store a failed location in the buffer.
+    public func add(_ location: BGLLocationData) {
+        guard let db = db else { return }
+
+        let sql = """
+                INSERT INTO buffered_locations
+                (latitude, longitude, accuracy, speed, heading, altitude, timestamp, is_moving, is_mock)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return }
+        defer { sqlite3_finalize(stmt) }
+
+        sqlite3_bind_double(stmt, 1, location.latitude)
+        sqlite3_bind_double(stmt, 2, location.longitude)
+        sqlite3_bind_double(stmt, 3, location.accuracy)
+        sqlite3_bind_double(stmt, 4, location.speed)
+        sqlite3_bind_double(stmt, 5, location.heading)
+        sqlite3_bind_double(stmt, 6, location.altitude)
+        sqlite3_bind_int64(stmt, 7, Int64(location.timestamp))
+        sqlite3_bind_int(stmt, 8, location.isMoving ? 1 : 0)
+        sqlite3_bind_int(stmt, 9, location.isMock ? 1 : 0)
+
+        sqlite3_step(stmt)
+        trimBuffer()
+    }
+
+    /// Retrieve the oldest `limit` buffered locations (FIFO order).
+    /// Returns pairs of (rowId, BGLLocationData) for deletion after successful send.
+    public func peek(limit: Int = 50) -> [(Int64, BGLLocationData)] {
+        guard let db = db else { return [] }
+
+        let sql =
+            "SELECT id, latitude, longitude, accuracy, speed, heading, altitude, timestamp, is_moving, is_mock FROM buffered_locations ORDER BY id ASC LIMIT ?"
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return [] }
+        defer { sqlite3_finalize(stmt) }
+
+        sqlite3_bind_int(stmt, 1, Int32(limit))
+
+        var results: [(Int64, BGLLocationData)] = []
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            let id = sqlite3_column_int64(stmt, 0)
+            let data = BGLLocationData(
+                latitude: sqlite3_column_double(stmt, 1),
+                longitude: sqlite3_column_double(stmt, 2),
+                accuracy: sqlite3_column_double(stmt, 3),
+                speed: sqlite3_column_double(stmt, 4),
+                heading: sqlite3_column_double(stmt, 5),
+                altitude: sqlite3_column_double(stmt, 6),
+                timestamp: Double(sqlite3_column_int64(stmt, 7)),
+                isMoving: sqlite3_column_int(stmt, 8) == 1,
+                isMock: sqlite3_column_int(stmt, 9) == 1
+            )
+            results.append((id, data))
+        }
+        return results
+    }
+
+    /// Remove specific entries by their row IDs after successful send.
+    public func remove(ids: [Int64]) {
+        guard let db = db, !ids.isEmpty else { return }
+
+        let placeholders = ids.map { _ in "?" }.joined(separator: ",")
+        let sql = "DELETE FROM buffered_locations WHERE id IN (\(placeholders))"
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return }
+        defer { sqlite3_finalize(stmt) }
+
+        for (index, id) in ids.enumerated() {
+            sqlite3_bind_int64(stmt, Int32(index + 1), id)
+        }
+        sqlite3_step(stmt)
+    }
+
+    /// Current number of buffered locations.
+    public func count() -> Int {
+        guard let db = db else { return 0 }
+
+        let sql = "SELECT COUNT(*) FROM buffered_locations"
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return 0 }
+        defer { sqlite3_finalize(stmt) }
+
+        if sqlite3_step(stmt) == SQLITE_ROW {
+            return Int(sqlite3_column_int(stmt, 0))
+        }
+        return 0
+    }
+
+    /// Remove all buffered locations.
+    public func clear() {
+        guard let db = db else { return }
+        sqlite3_exec(db, "DELETE FROM buffered_locations", nil, nil, nil)
+    }
+
+    // MARK: - Private
+
+    private func openDatabase() {
+        let flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX
+        if sqlite3_open_v2(dbPath, &db, flags, nil) != SQLITE_OK {
+            print("BGLocation: Failed to open BGLLocationBuffer database")
+            db = nil
+        }
+    }
+
+    private func createTable() {
+        guard let db = db else { return }
+
+        let sql = """
+                CREATE TABLE IF NOT EXISTS buffered_locations (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    latitude REAL NOT NULL,
+                    longitude REAL NOT NULL,
+                    accuracy REAL NOT NULL,
+                    speed REAL NOT NULL,
+                    heading REAL NOT NULL,
+                    altitude REAL NOT NULL,
+                    timestamp INTEGER NOT NULL,
+                    is_moving INTEGER NOT NULL,
+                    is_mock INTEGER NOT NULL DEFAULT 0,
+                    created_at INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)
+                )
+            """
+        sqlite3_exec(db, sql, nil, nil, nil)
+    }
+
+    private func trimBuffer() {
+        let currentCount = count()
+        let overflow = currentCount - maxSize
+        if overflow <= 0 { return }
+
+        guard let db = db else { return }
+        let sql =
+            "DELETE FROM buffered_locations WHERE id IN (SELECT id FROM buffered_locations ORDER BY id ASC LIMIT ?)"
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return }
+        defer { sqlite3_finalize(stmt) }
+
+        sqlite3_bind_int(stmt, 1, Int32(overflow))
+        sqlite3_step(stmt)
+        print(
+            "BGLocation: BGLLocationBuffer trimmed \(overflow) oldest entries (maxSize=\(maxSize))")
+        onOverflow?(overflow)
+    }
+}

package/ios/Sources/BGLocationCore/License/BGLBuildConfig.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+/// Build-time configuration injected by the consuming plugin bridge.
+/// The bridge sets `buildEpoch` during plugin initialization.
+/// Used for update gating: licenses with `exp < buildEpoch` degrade to trial mode.
+public enum BGLBuildConfig {
+    /// Unix epoch seconds when the consuming plugin was built.
+    /// Set by the bridge during initialization (e.g. from Xcode build-phase script).
+    /// Default 0 means update gating is disabled.
+    public static var buildEpoch: Int = 0
+}

package/ios/Sources/BGLocationCore/License/BGLLicenseEnforcer.swift

@@ -0,0 +1,134 @@
+import Foundation
+
+/// Manages license validation, trial timer lifecycle, and cooldown enforcement.
+/// Extracted from BackgroundLocationPlugin to reduce bridge complexity.
+public class BGLLicenseEnforcer {
+
+    private let licenseDefaults: UserDefaults
+    public let licenseValidator: BGLLicenseValidator
+
+    public var licenseMode: LicenseMode = .trial
+    public var trialTimer: BGLTrialTimer?
+
+    public init(defaults: UserDefaults) {
+        self.licenseDefaults = defaults
+        self.licenseValidator = BGLLicenseValidator(defaults: defaults)
+    }
+
+    /// Validate license key and populate configure result.
+    /// - Parameters:
+    ///   - licenseKey: the license key from plugin config
+    ///   - isDebug: user's original debug setting (restored in full mode)
+    ///   - debugSounds: user's original debugSounds setting
+    ///   - debug: the debug logger to reconfigure
+    ///   - configureResult: dictionary to populate with license status
+    ///   - onTrialExpired: callback for when trial expires
+    public func validateLicense(
+        licenseKey: String?,
+        isDebug: Bool,
+        debugSounds: Bool,
+        debug: BGLDebugLogger,
+        configureResult: inout [String: Any],
+        onTrialExpired: @escaping () -> Void,
+        bundleId: String = Bundle.main.bundleIdentifier ?? ""
+    ) {
+        let licenseResult = licenseValidator.validate(
+            licenseKey: licenseKey, bundleId: bundleId, buildEpoch: BGLBuildConfig.buildEpoch)
+
+        switch licenseResult {
+        case .valid(let updatesUntil):
+            licenseMode = .full
+            trialTimer?.stop()
+            trialTimer = nil
+            debug.configure(debug: isDebug, debugSounds: debugSounds)
+            configureResult["licenseMode"] = "full"
+            if let updatesUntil = updatesUntil {
+                let updatesDate = ISO8601DateFormatter().string(
+                    from: Date(timeIntervalSince1970: TimeInterval(updatesUntil)))
+                configureResult["licenseUpdatesUntil"] = updatesDate
+                print("BGLocation: License valid — full mode, updates until \(updatesDate)")
+            } else {
+                print("BGLocation: License valid — full mode, no update expiry")
+            }
+
+        case .updatesExpired(let updatesUntil):
+            licenseMode = .trial
+            debug.configure(debug: true, debugSounds: debugSounds)
+            let updatesDate = ISO8601DateFormatter().string(
+                from: Date(timeIntervalSince1970: TimeInterval(updatesUntil)))
+            let buildDate = ISO8601DateFormatter().string(
+                from: Date(timeIntervalSince1970: TimeInterval(BGLBuildConfig.buildEpoch)))
+            configureResult["licenseMode"] = "trial"
+            configureResult["licenseUpdateExpired"] = true
+            configureResult["licenseUpdatesUntil"] = updatesDate
+            configureResult["licenseError"] =
+                "Updates expired. This plugin version requires a license with updates valid until \(buildDate). Please renew at bglocation.dev/portal"
+
+            if trialTimer == nil {
+                trialTimer = BGLTrialTimer(defaults: licenseDefaults, onExpired: onTrialExpired)
+            }
+
+            print(
+                "BGLocation: License updates expired (until \(updatesDate)). Running in TRIAL mode."
+            )
+
+        case .invalid(let reason):
+            licenseMode = .trial
+            debug.configure(debug: true, debugSounds: debugSounds)
+            configureResult["licenseMode"] = "trial"
+            configureResult["licenseError"] = reason
+
+            if trialTimer == nil {
+                trialTimer = BGLTrialTimer(defaults: licenseDefaults, onExpired: onTrialExpired)
+            }
+
+            print(
+                "BGLocation: License: \(reason). Running in TRIAL mode (30 min limit, 1h cooldown)."
+            )
+        }
+    }
+
+    /// Result of a cooldown check.
+    public struct CooldownResult {
+        public let remainingSeconds: Int
+        public let message: String
+    }
+
+    /// Check if trial cooldown is active.
+    /// Returns CooldownResult if cooldown is active, or nil if the operation can proceed.
+    public func checkCooldown() -> CooldownResult? {
+        guard licenseMode == .trial,
+            let timer = trialTimer,
+            timer.isInCooldown()
+        else {
+            return nil
+        }
+        let remaining = timer.remainingCooldownSeconds()
+        return CooldownResult(
+            remainingSeconds: remaining,
+            message:
+                "Trial cooldown active. Please wait \(remaining) seconds or provide a license key."
+        )
+    }
+
+    /// Start trial timer if in trial mode.
+    public func startTrialIfNeeded() {
+        if licenseMode == .trial {
+            trialTimer?.start()
+        }
+    }
+
+    /// Stop trial timer if no geofences are active and tracking is stopped.
+    public func stopTrialIfIdle(hasGeofences: Bool, isTracking: Bool) {
+        if licenseMode == .trial && !hasGeofences && !isTracking {
+            trialTimer?.stop()
+        }
+    }
+
+    /// Stop trial timer if no geofences are active.
+    public func stopTrialIfNoGeofences(hasGeofences: Bool) {
+        if !hasGeofences {
+            trialTimer?.stop()
+        }
+    }
+}