react-native-bg-geolocation 0.2.0

package/ios/engine/BGWatchPositionRequest.swift

@@ -0,0 +1,63 @@
+import Foundation
+import CoreLocation
+
+public typealias BGWatchPositionSuccessBlock = (Any?) -> Void
+public typealias BGWatchPositionFailureBlock = (Int) -> Void
+
+@objc public final class BGWatchPositionRequest: NSObject {
+
+    @objc public var persist: Bool
+    @objc public var desiredAccuracy: CLLocationAccuracy
+    @objc public private(set) var interval: Double
+    @objc public var extras: [AnyHashable: Any]?
+    @objc public var timeout: Double
+    @objc public var success: BGWatchPositionSuccessBlock?
+    @objc public var failure: BGWatchPositionFailureBlock?
+
+    @objc public class func request(success: @escaping BGWatchPositionSuccessBlock,
+                                     failure: @escaping BGWatchPositionFailureBlock) -> BGWatchPositionRequest {
+        let config = BGConfig.sharedInstance()
+        let geo = config.geolocation
+        return BGWatchPositionRequest(interval: 60000.0,
+                                      timeout: geo.locationTimeout,
+                                      persist: config.enabled,
+                                      extras: nil,
+                                      success: success,
+                                      failure: failure)
+    }
+
+    @objc public class func request(interval: Double,
+                                     success: @escaping BGWatchPositionSuccessBlock,
+                                     failure: @escaping BGWatchPositionFailureBlock) -> BGWatchPositionRequest {
+        let config = BGConfig.sharedInstance()
+        let geo = config.geolocation
+        return BGWatchPositionRequest(interval: interval,
+                                      timeout: geo.locationTimeout,
+                                      persist: config.enabled,
+                                      extras: nil,
+                                      success: success,
+                                      failure: failure)
+    }
+
+    @objc public init(interval: Double,
+                       timeout: Double,
+                       persist: Bool,
+                       extras: [AnyHashable: Any]?,
+                       success: @escaping BGWatchPositionSuccessBlock,
+                       failure: @escaping BGWatchPositionFailureBlock) {
+        self.desiredAccuracy = kCLLocationAccuracyBest
+        self.interval = max(interval, 1000.0)
+        self.timeout = max(timeout, 0.0)
+        self.persist = persist
+        self.extras = extras
+        self.success = success
+        self.failure = failure
+        super.init()
+    }
+
+    public func setInterval(_ newValue: Double) {
+        objc_sync_enter(self)
+        interval = max(newValue, 1000.0)
+        objc_sync_exit(self)
+    }
+}

package/ios/engine/DatabaseQueue.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+@objc public class DatabaseQueue: NSObject {
+
+    private static var _sharedInstance: DatabaseQueue?
+    private static let lock = NSLock()
+
+    @objc public var queue: Any?
+
+    @objc public class func sharedInstance() -> DatabaseQueue {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = DatabaseQueue()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+        openDatabase()
+    }
+
+    private func databasePath() -> String {
+        let docs = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).first!
+        return (docs as NSString).appendingPathComponent("BGDatabase.db")
+    }
+
+    private func openDatabase() {
+        let path = databasePath()
+        queue = path
+    }
+
+    @objc public func migrateDatabase(_ db: Any?) {
+    }
+
+    @objc public func hasMigratedLocations() -> Bool {
+        return false
+    }
+
+    @objc public func getMigratedLocations() -> [[String: Any]] {
+        return []
+    }
+
+    @objc public func finishMigration() {
+    }
+}

package/ios/engine/LogQuery.swift

@@ -0,0 +1,10 @@
+import Foundation
+
+@objc public class LogQuery: SQLQuery {
+
+    @objc public override init() {
+        super.init()
+        self.order = 1
+        self.limit = -1
+    }
+}

package/ios/engine/SQLQuery.swift

@@ -0,0 +1,65 @@
+import Foundation
+
+@objc public class SQLQuery: NSObject {
+
+    @objc public var start: Double = 0
+    @objc public var end: Double = 0
+    @objc public var limit: Int = -1
+    @objc public var order: Int = 1
+    @objc public var arguments: NSMutableArray = NSMutableArray()
+
+    private var _orderString: String = "ASC"
+
+    @objc public override init() {
+        super.init()
+        self.limit = -1
+        self.order = 1
+        self.start = 0
+        self.end = 0
+        self.arguments = NSMutableArray()
+    }
+
+    @objc public init(dictionary: [String: Any]) {
+        super.init()
+        if let s = dictionary["start"] as? Double { self.start = s }
+        if let e = dictionary["end"] as? Double { self.end = e }
+        if let l = dictionary["limit"] as? Int { self.limit = l }
+        if let o = dictionary["order"] as? Int { self.order = o }
+    }
+
+    @objc public func addArgument(_ arg: Any) {
+        arguments.add(arg)
+    }
+
+    @objc public func render() -> String {
+        var clauses: [String] = []
+        var args: [Any] = []
+
+        if start > 0 {
+            clauses.append("timestamp >= ?")
+            args.append(start)
+        }
+        if end > 0 {
+            clauses.append("timestamp <= ?")
+            args.append(end)
+        }
+
+        arguments.addObjects(from: args)
+
+        var sql = clauses.isEmpty ? "" : "WHERE " + clauses.joined(separator: " AND ")
+        let orderDir = order >= 0 ? "ASC" : "DESC"
+        sql += " ORDER BY timestamp \(orderDir)"
+        if limit > 0 {
+            sql += " LIMIT \(limit)"
+        }
+        return sql
+    }
+
+    @objc public func toString() -> String {
+        return render()
+    }
+
+    @objc public override var description: String {
+        return "<SQLQuery start=\(start) end=\(end) limit=\(limit) order=\(order)>"
+    }
+}

package/ios/engine/TransistorAuthorizationToken.swift

@@ -0,0 +1,182 @@
+import Foundation
+import UIKit
+
+@objc public class TransistorAuthorizationToken: NSObject {
+
+    @objc public var accessToken: String
+    @objc public var refreshToken: String
+    @objc public var expires: Date
+    @objc public var apiUrl: String?
+    @objc public var refreshUrl: String?
+
+    private static let storagePrefix = "BGLocationManager_transistor_token_"
+
+    @objc public class func storageKey(forHost host: String) -> String {
+        return "\(storagePrefix)\(host)"
+    }
+
+    @objc public class func hasToken(forHost host: String) -> Bool {
+        let key = storageKey(forHost: host)
+        return UserDefaults.standard.dictionary(forKey: key) != nil
+    }
+
+    @objc public class func destroy(url: URL) {
+        guard let host = url.host else { return }
+        let key = storageKey(forHost: host)
+        UserDefaults.standard.removeObject(forKey: key)
+        UserDefaults.standard.synchronize()
+    }
+
+    @objc public class func findOrCreate(
+        org: String,
+        username: String,
+        url: URL,
+        framework: String,
+        success: @escaping (_ token: TransistorAuthorizationToken) -> Void,
+        failure: @escaping (_ error: Error) -> Void
+    ) {
+        guard let host = url.host else {
+            failure(NSError(domain: "TransistorAuthorizationToken", code: -1,
+                            userInfo: [NSLocalizedDescriptionKey: "Invalid URL: missing host"]))
+            return
+        }
+
+        let key = storageKey(forHost: host)
+
+        if let stored = UserDefaults.standard.dictionary(forKey: key) {
+            let token = TransistorAuthorizationToken(dictionary: stored, forUrl: url)
+            if token.expires > Date() {
+                DispatchQueue.main.async { success(token) }
+                return
+            }
+        }
+
+        let registrationURL = buildRegistrationURL(baseURL: url)
+
+        var request = URLRequest(url: registrationURL)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.timeoutInterval = 60.0
+
+        let deviceInfo = BGDeviceInfo.sharedInstance
+        let body: [String: Any] = [
+            "org": org,
+            "device": [
+                "unique_id": UIDevice.current.identifierForVendor?.uuidString ?? "",
+                "model": deviceInfo.model ?? "",
+                "platform": "iOS",
+                "manufacturer": "Apple",
+                "version": deviceInfo.version ?? "",
+                "framework": framework,
+                "username": username
+            ]
+        ]
+
+        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
+
+        let session = URLSession(configuration: .default)
+        let task = session.dataTask(with: request) { data, response, error in
+            if let error = error {
+                DispatchQueue.main.async { failure(error) }
+                return
+            }
+
+            guard let httpResponse = response as? HTTPURLResponse else {
+                DispatchQueue.main.async {
+                    failure(NSError(domain: "TransistorAuthorizationToken", code: -1,
+                                    userInfo: [NSLocalizedDescriptionKey: "Invalid response"]))
+                }
+                return
+            }
+
+            if httpResponse.statusCode == 200 {
+                guard let data = data,
+                      let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+                    DispatchQueue.main.async {
+                        failure(NSError(domain: "TransistorAuthorizationToken", code: -2,
+                                        userInfo: [NSLocalizedDescriptionKey: "Failed to parse response"]))
+                    }
+                    return
+                }
+
+                let token = TransistorAuthorizationToken(dictionary: json, forUrl: url)
+                let stored = token.toDictionary()
+                UserDefaults.standard.set(stored, forKey: key)
+                UserDefaults.standard.synchronize()
+
+                DispatchQueue.main.async { success(token) }
+            } else {
+                guard let data = data,
+                      let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+                    DispatchQueue.main.async {
+                        failure(NSError(domain: "TransistorAuthorizationToken", code: httpResponse.statusCode,
+                                        userInfo: [NSLocalizedDescriptionKey: "HTTP \(httpResponse.statusCode)"]))
+                    }
+                    return
+                }
+                let msg = json["error"] as? String ?? "HTTP \(httpResponse.statusCode)"
+                DispatchQueue.main.async {
+                    failure(NSError(domain: "TransistorAuthorizationToken", code: httpResponse.statusCode,
+                                    userInfo: [NSLocalizedDescriptionKey: msg]))
+                }
+            }
+        }
+        task.resume()
+    }
+
+    private class func buildRegistrationURL(baseURL: URL) -> URL {
+        var urlString = baseURL.absoluteString
+        if urlString.hasSuffix("/") {
+            urlString = String(urlString.dropLast())
+        }
+        let registrationPath = urlString + "/api/devices"
+        return URL(string: registrationPath) ?? baseURL
+    }
+
+    @objc public init(accessToken: String, refreshToken: String, expires: Date) {
+        self.accessToken = accessToken
+        self.refreshToken = refreshToken
+        self.expires = expires
+        super.init()
+    }
+
+    @objc public init(dictionary: [String: Any], forUrl url: URL) {
+        self.accessToken = dictionary["access_token"] as? String ?? ""
+        self.refreshToken = dictionary["refresh_token"] as? String ?? ""
+
+        if let expiresAt = dictionary["expires_at"] as? Double {
+            self.expires = Date(timeIntervalSince1970: expiresAt)
+        } else if let expiresStr = dictionary["expires_at"] as? String {
+            let formatter = ISO8601DateFormatter()
+            self.expires = formatter.date(from: expiresStr) ?? Date.distantFuture
+        } else {
+            self.expires = Date.distantFuture
+        }
+
+        self.apiUrl = url.absoluteString
+        if let baseUrl = dictionary["base_url"] as? String {
+            self.refreshUrl = baseUrl + "/api/refresh_token"
+        }
+        super.init()
+    }
+
+    @objc public override init() {
+        self.accessToken = ""
+        self.refreshToken = ""
+        self.expires = Date.distantFuture
+        super.init()
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        return [
+            "access_token": accessToken,
+            "refresh_token": refreshToken,
+            "expires_at": expires.timeIntervalSince1970,
+            "api_url": apiUrl ?? ""
+        ]
+    }
+
+    @objc public override var description: String {
+        return "<TransistorAuthorizationToken accessToken=\(accessToken) expires=\(expires)>"
+    }
+}

package/ios/liveactivity/BGLiveTrackingAttributes.swift

@@ -0,0 +1,52 @@
+import ActivityKit
+import Foundation
+
+@available(iOS 16.2, *)
+public struct BGLiveTrackingAttributes: ActivityAttributes {
+    public struct ContentState: Codable, Hashable {
+        public var status: String
+        public var isMoving: Bool
+        public var activity: String
+        public var latitude: Double
+        public var longitude: Double
+        public var accuracy: Double
+        public var speed: Double
+        public var distance: Double
+        public var locationCount: Int
+        public var updatedAt: Date
+
+        public init(
+            status: String,
+            isMoving: Bool,
+            activity: String,
+            latitude: Double,
+            longitude: Double,
+            accuracy: Double,
+            speed: Double,
+            distance: Double,
+            locationCount: Int,
+            updatedAt: Date
+        ) {
+            self.status = status
+            self.isMoving = isMoving
+            self.activity = activity
+            self.latitude = latitude
+            self.longitude = longitude
+            self.accuracy = accuracy
+            self.speed = speed
+            self.distance = distance
+            self.locationCount = locationCount
+            self.updatedAt = updatedAt
+        }
+    }
+
+    public var trackingId: String
+    public var title: String
+    public var subtitle: String
+
+    public init(trackingId: String, title: String, subtitle: String) {
+        self.trackingId = trackingId
+        self.title = title
+        self.subtitle = subtitle
+    }
+}

package/ios/locationpush/BGLocationPushDeliverer.swift

@@ -0,0 +1,260 @@
+//
+//  BGLocationPushDeliverer.swift
+//
+//  Shared, JS-independent delivery for a push-triggered location. Used by BOTH:
+//    • BGLocationPushService (the kill-state extension, separate process)
+//    • BgGeolocation module (the in-app background-push handler)
+//
+//  Push-triggered delivery CANNOT depend on the React Native bridge: when iOS
+//  wakes the app (or the extension) from a killed/suspended state, JS is often
+//  not booted and emitted events are dropped. So the SDK delivers natively here
+//  — socket first, then REST fallback — reading config the host app provided via
+//  BackgroundGeolocation.setLocationPushConfig({...}).
+//
+//  Extension-safe: Foundation + URLSession only.
+//
+
+import CoreLocation
+import Foundation
+
+@available(iOS 15.0, *)
+@objc public final class BGLocationPushDeliverer: NSObject {
+
+    /// Deliver a location captured for `queryId`. Tries the socket channel first
+    /// (if configured), then the REST fallback. `completion(true)` on the first
+    /// channel that succeeds, `completion(false)` if everything fails.
+    @objc public static func deliver(
+        latitude: Double,
+        longitude: Double,
+        accuracy: Double,
+        speed: Double,
+        heading: Double,
+        altitude: Double,
+        timestampISO: String,
+        queryId: String,
+        completion: @escaping (Bool) -> Void
+    ) {
+        let job = BGLocationPushDeliveryJob(
+            latitude: latitude, longitude: longitude, accuracy: accuracy,
+            speed: speed, heading: heading, altitude: altitude,
+            timestampISO: timestampISO, queryId: queryId, completion: completion
+        )
+        job.start()
+    }
+
+    static func currentTimeHHmm() -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "HH:mm"
+        return formatter.string(from: Date())
+    }
+}
+
+@available(iOS 15.0, *)
+private final class BGLocationPushDeliveryJob {
+    let latitude, longitude, accuracy, speed, heading, altitude: Double
+    let timestampISO: String
+    let queryId: String
+    let completion: (Bool) -> Void
+    private var socketClient: BGLocationPushSocketClient?
+    private var retained: BGLocationPushDeliveryJob?
+
+    init(latitude: Double, longitude: Double, accuracy: Double, speed: Double,
+         heading: Double, altitude: Double, timestampISO: String,
+         queryId: String, completion: @escaping (Bool) -> Void) {
+        self.latitude = latitude; self.longitude = longitude
+        self.accuracy = accuracy; self.speed = speed
+        self.heading = heading; self.altitude = altitude
+        self.timestampISO = timestampISO; self.queryId = queryId
+        self.completion = completion
+    }
+
+    func start() {
+        retained = self // keep alive across async callbacks
+        guard let defaults = BGLocationPushShared.sharedDefaults() else {
+            BGLocationPushLog.log("no shared config — cannot deliver")
+            finish(false)
+            return
+        }
+
+        if let socketUrlString = defaults.string(forKey: BGLocationPushShared.keySocketUrl),
+           !socketUrlString.isEmpty, let socketUrl = URL(string: socketUrlString) {
+            let path  = defaults.string(forKey: BGLocationPushShared.keySocketPath) ?? "/socket.io"
+            let event = defaults.string(forKey: BGLocationPushShared.keySocketEvent) ?? "location:update"
+            let token = defaults.string(forKey: BGLocationPushShared.keySocketAuthToken)
+            let timeout = defaults.object(forKey: BGLocationPushShared.keySocketTimeout) as? Double ?? 8.0
+
+            BGLocationPushLog.log("socket delivery → \(socketUrlString)\(path)")
+            let client = BGLocationPushSocketClient(config: .init(
+                url: socketUrl, path: path, event: event, authToken: token, timeout: timeout
+            ))
+            socketClient = client
+            client.emit(payload(defaults: defaults, default: defaultPayload())) { [weak self] ok in
+                guard let self = self else { return }
+                if ok {
+                    BGLocationPushLog.log("✅ delivered via socket")
+                    self.finish(true)
+                } else {
+                    BGLocationPushLog.log("socket failed → REST fallback")
+                    self.postViaRest(defaults: defaults)
+                }
+            }
+            return
+        }
+
+        postViaRest(defaults: defaults)
+    }
+
+    private func postViaRest(defaults: UserDefaults) {
+        let headers = defaults.dictionary(forKey: BGLocationPushShared.keyHeaders) as? [String: String] ?? [:]
+        let bearer = defaults.string(forKey: BGLocationPushShared.keySocketAuthToken)
+            ?? defaults.string(forKey: BGLocationPushShared.keyAccessToken)
+
+        let url: URL
+        let body: [String: Any]
+
+        if let fallbackString = defaults.string(forKey: BGLocationPushShared.keyFallbackUrl),
+           !fallbackString.isEmpty, let fallbackUrl = URL(string: fallbackString) {
+            url = fallbackUrl
+            body = payload(defaults: defaults, default: defaultPayload())
+            BGLocationPushLog.log("REST fallback → \(fallbackString)")
+        } else {
+            let urlString = defaults.string(forKey: BGLocationPushShared.keyUrl) ?? ""
+            guard !urlString.isEmpty, let generic = URL(string: urlString) else {
+                BGLocationPushLog.log("no REST url configured — giving up")
+                finish(false)
+                return
+            }
+            url = generic
+            let rootProperty = defaults.string(forKey: BGLocationPushShared.keyRootProperty) ?? "location"
+            let params = defaults.dictionary(forKey: BGLocationPushShared.keyParams) ?? [:]
+            let locationDict = restLocation(defaults: defaults)
+            var generated: [String: Any] = [:]
+            if rootProperty.isEmpty || rootProperty == "." { generated = locationDict }
+            else { generated[rootProperty] = locationDict }
+            for (k, v) in params { generated[k] = v }
+            generated["location_query_id"] = queryId
+            body = generated
+            BGLocationPushLog.log("REST → \(urlString)")
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.timeoutInterval = 20
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        if let token = bearer, !token.isEmpty {
+            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        }
+        for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
+        request.httpBody = try? JSONSerialization.data(withJSONObject: body, options: [])
+
+        URLSession.shared.dataTask(with: request) { [weak self] _, response, error in
+            if let error = error {
+                BGLocationPushLog.log("REST error: \(error.localizedDescription)")
+                self?.finish(false)
+            } else if let http = response as? HTTPURLResponse {
+                BGLocationPushLog.log("REST HTTP \(http.statusCode)")
+                self?.finish((200...299).contains(http.statusCode))
+            } else {
+                self?.finish(false)
+            }
+        }.resume()
+    }
+
+    /// Resolve the upload body: if the host supplied a `payloadTemplate` via
+    /// setLocationPushConfig, render it (substituting {tokens} with live values);
+    /// otherwise use the built-in `default` payload.
+    private func payload(defaults: UserDefaults, default fallback: [String: Any]) -> [String: Any] {
+        guard let template = defaults.dictionary(forKey: BGLocationPushShared.keyPayloadTemplate) else {
+            return fallback
+        }
+        return (render(template) as? [String: Any]) ?? fallback
+    }
+
+    /// Live values that template tokens like "{latitude}" / "{fcmToken}" map to.
+    private func tokenValues() -> [String: Any] {
+        let fcm = BGLocationPushShared.sharedDefaults()?
+            .string(forKey: BGLocationPushShared.keyFcmToken) ?? ""
+        let time = BGLocationPushDeliverer.currentTimeHHmm()
+        return [
+            "latitude": latitude, "lat": latitude,
+            "longitude": longitude, "long": longitude,
+            "accuracy": max(accuracy, 0),
+            "speed": speed, "heading": heading, "altitude": altitude,
+            "timestamp": timestampISO,
+            "fcmToken": fcm, "fcm_token": fcm,
+            "queryId": queryId, "locationQueryId": queryId, "location_query_id": queryId,
+            "userCurrentTime": time, "user_current_time": time, "time": time,
+            "deviceType": "ios", "device_type": "ios"
+        ]
+    }
+
+    /// Recursively substitute tokens in a template value. A string that is exactly
+    /// one token ("{latitude}") yields the typed value (Double/String); a string
+    /// with inline tokens is interpolated; dicts/arrays recurse; other values pass
+    /// through unchanged.
+    private func render(_ value: Any) -> Any {
+        let tokens = tokenValues()
+        if let dict = value as? [String: Any] {
+            var out: [String: Any] = [:]
+            for (k, v) in dict { out[k] = render(v) }
+            return out
+        }
+        if let arr = value as? [Any] {
+            return arr.map { render($0) }
+        }
+        if let s = value as? String {
+            if s.hasPrefix("{"), s.hasSuffix("}"),
+               !s.dropFirst().dropLast().contains("{"),
+               let typed = tokens[String(s.dropFirst().dropLast())] {
+                return typed // exact single-token → typed value (keeps numbers numeric)
+            }
+            var result = s
+            for (name, val) in tokens {
+                result = result.replacingOccurrences(of: "{\(name)}", with: "\(val)")
+            }
+            return result
+        }
+        return value
+    }
+
+    /// Built-in default upload body (socket emit + REST fallback) when the host
+    /// does not supply a `payloadTemplate`. Matches the backend's expected shape.
+    private func defaultPayload() -> [String: Any] {
+        let fcm = BGLocationPushShared.sharedDefaults()?
+            .string(forKey: BGLocationPushShared.keyFcmToken) ?? ""
+        return [
+            "lat": latitude,
+            "long": longitude,
+            "fcm_token": fcm,
+            "device_type": "ios",
+            "user_current_time": BGLocationPushDeliverer.currentTimeHHmm(),
+            "location_query_id": queryId
+        ]
+    }
+
+    private func restLocation(defaults: UserDefaults) -> [String: Any] {
+        let extras = defaults.dictionary(forKey: BGLocationPushShared.keyExtras) ?? [:]
+        var mergedExtras: [String: Any] = ["LocationPushService": true, "location_query_id": queryId]
+        for (k, v) in extras { mergedExtras[k] = v }
+        return [
+            "coords": [
+                "latitude": latitude, "longitude": longitude,
+                "accuracy": max(accuracy, 0), "speed": speed,
+                "heading": heading, "altitude": altitude
+            ],
+            "latitude": latitude, "longitude": longitude,
+            "lat": latitude, "long": longitude,
+            "timestamp": timestampISO, "is_moving": false,
+            "event": "location-push", "extras": mergedExtras
+        ]
+    }
+
+    private func finish(_ success: Bool) {
+        let cb = completion
+        socketClient = nil
+        let keepAlive = retained
+        retained = nil
+        cb(success)
+        _ = keepAlive
+    }
+}