react-native-bg-geolocation 0.2.0

package/ios/engine/BGHeartbeatEvent.swift

@@ -0,0 +1,31 @@
+import Foundation
+import CoreLocation
+
+@objc public final class BGHeartbeatEvent: NSObject {
+
+    @objc public private(set) var location: CLLocation?
+    @objc public private(set) var data: [AnyHashable: Any]?
+
+    @objc public init(location: CLLocation?) {
+        super.init()
+        guard let location = location else {
+            self.location = nil
+            self.data = nil
+            return
+        }
+        let rebuilt = CLLocation(coordinate: location.coordinate,
+                                 altitude: location.altitude,
+                                 horizontalAccuracy: location.horizontalAccuracy,
+                                 verticalAccuracy: location.verticalAccuracy,
+                                 course: location.course,
+                                 speed: location.speed,
+                                 timestamp: location.timestamp)
+        self.location = rebuilt
+        let tsLocation = BGLocation(location: rebuilt, type: "heartbeat", extras: nil)
+        self.data = tsLocation.toDictionary()
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        return ["location": data ?? NSNull()]
+    }
+}

package/ios/engine/BGHeartbeatService.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+@objc public class BGHeartbeatService: NSObject {
+
+    private static var _sharedInstance: BGHeartbeatService?
+    private static let lock = NSLock()
+
+    @objc public var timer: Timer?
+    @objc public var callback: ((Any?) -> Void)?
+
+    @objc public class func sharedInstance() -> BGHeartbeatService {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGHeartbeatService()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public var isRunning: Bool {
+        return timer != nil && timer!.isValid
+    }
+
+    @objc public func startWithInterval(_ interval: TimeInterval, callback: @escaping (Any?) -> Void) {
+        stop()
+        self.callback = callback
+        timer = Timer.scheduledTimer(timeInterval: interval,
+                                     target: self,
+                                     selector: #selector(onHeartbeat(_:)),
+                                     userInfo: nil,
+                                     repeats: true)
+    }
+
+    @objc public func stop() {
+        timer?.invalidate()
+        timer = nil
+        callback = nil
+    }
+
+    @objc public func evaluate() {
+        onHeartbeat(timer)
+    }
+
+    @objc private func onHeartbeat(_ timer: Timer?) {
+        callback?(nil)
+    }
+}

package/ios/engine/BGHttpConfig.swift

@@ -0,0 +1,105 @@
+import Foundation
+
+@objc public class BGHttpConfig: BGConfigModuleBase {
+
+    @objc public var url: String = ""
+    @objc public var method: String = "POST"
+    @objc public var headers: [String: String] = [:]
+    @objc public var params: [String: Any] = [:]
+    @objc public var rootProperty: String = "location"
+    @objc public var timeout: Double = 60.0
+    @objc public var autoSync: Bool = true
+    @objc public var autoSyncThreshold: Int = 0
+    @objc public var batchSync: Bool = false
+    @objc public var maxBatchSize: Int = -1
+    @objc public var disableAutoSyncOnCellular: Bool = false
+
+    @objc public override func applyDefaults() {
+        url = ""
+        method = "POST"
+        headers = [:]
+        params = [:]
+        rootProperty = "location"
+        timeout = 60.0
+        autoSync = true
+        autoSyncThreshold = 0
+        batchSync = false
+        maxBatchSize = -1
+        disableAutoSyncOnCellular = false
+    }
+
+    @objc public var hasValidUrl: Bool {
+        return !url.isEmpty && URL(string: url) != nil
+    }
+
+    @objc public var timeoutSeconds: TimeInterval {
+        return timeout
+    }
+
+    @objc public var effectiveBatchSize: Int {
+        return maxBatchSize > 0 ? maxBatchSize : 50
+    }
+
+    @objc public var isImmediateSyncEnabled: Bool {
+        return autoSync && autoSyncThreshold == 0
+    }
+
+    @objc public func fullUrlWithParams() -> String {
+        guard !url.isEmpty else { return url }
+        if params.isEmpty { return url }
+        var components = URLComponents(string: url)
+        let queryItems = params.map { URLQueryItem(name: $0.key, value: "\($0.value)") }
+        let existing = components?.queryItems ?? []
+        components?.queryItems = existing + queryItems
+        return components?.url?.absoluteString ?? url
+    }
+
+    @objc public func validateAndCleanUrl(_ rawUrl: String) -> String? {
+        let trimmed = rawUrl.trimmingCharacters(in: .whitespaces)
+        guard !trimmed.isEmpty, URL(string: trimmed) != nil else { return nil }
+        return trimmed
+    }
+
+    @objc public func headersWithAuth(_ auth: BGAuthorization?) -> [String: String] {
+        var result = headers
+        if let auth = auth, let token = auth.accessToken, !token.isEmpty {
+            result["Authorization"] = "Bearer \(token)"
+        }
+        return result
+    }
+
+    @objc public override func sensitivePropertyNames() -> [String] {
+        return ["headers"]
+    }
+
+    @objc public override func deprecatedPropertyMappings() -> [String: String] {
+        return [
+            "httpRootProperty": "rootProperty",
+            "httpTimeout": "timeout"
+        ]
+    }
+
+    @objc public override func propertySpecs() -> [BGPropertySpecImpl] {
+        return [
+            BGPropertySpec(name: "url", type: "string"),
+            BGPropertySpec(name: "method", type: "string"),
+            BGPropertySpec(name: "headers", type: "object"),
+            BGPropertySpec(name: "params", type: "object"),
+            BGPropertySpec(name: "rootProperty", type: "string"),
+            BGPropertySpec(name: "timeout", type: "double"),
+            BGPropertySpec(name: "autoSync", type: "bool"),
+            BGPropertySpec(name: "autoSyncThreshold", type: "int"),
+            BGPropertySpec(name: "batchSync", type: "bool"),
+            BGPropertySpec(name: "maxBatchSize", type: "int"),
+            BGPropertySpec(name: "disableAutoSyncOnCellular", type: "bool")
+        ]
+    }
+
+    @objc public override func validateConfiguration() -> Bool {
+        return true
+    }
+
+    @objc public override var description: String {
+        return "<BGHttpConfig url=\(url) method=\(method) autoSync=\(autoSync)>"
+    }
+}

package/ios/engine/BGHttpErrorCodes.swift

@@ -0,0 +1,63 @@
+import Foundation
+
+public let BGHttpServiceErrorDomain = "BGHttpServiceErrorDomain"
+public let BGHttpErrorKeyUnderlying = "BGHttpErrorKeyUnderlying"
+public let BGHttpErrorKeyStatus = "BGHttpErrorKeyStatus"
+public let BGHttpErrorKeyResponseBody = "BGHttpErrorKeyResponseBody"
+public let BGHttpErrorKeyURL = "BGHttpErrorKeyURL"
+public let BGHttpErrorKeyFromURL = "BGHttpErrorKeyFromURL"
+public let BGHttpErrorKeyToURL = "BGHttpErrorKeyToURL"
+
+@objc public final class BGHttpErrorCodes: NSObject {
+
+    @objc public class func localizedDescription(forErrorCode code: Int) -> String {
+        switch code {
+        case 1: return "Invalid URL"
+        case 2: return "Network connection failed"
+        case 3: return "Sync operation already in progress"
+        case 4: return "HTTP response error"
+        case 5: return "HTTP redirect disallowed"
+        default: return ""
+        }
+    }
+
+    @objc public class func error(withCode code: Int, description: String?, userInfo: [AnyHashable: Any]?) -> NSError {
+        var info: [String: Any] = [:]
+        info[NSLocalizedDescriptionKey] = description ?? localizedDescription(forErrorCode: code)
+        if let userInfo = userInfo {
+            for (key, value) in userInfo {
+                if let key = key as? String { info[key] = value }
+            }
+        }
+        return NSError(domain: BGHttpServiceErrorDomain, code: code, userInfo: info)
+    }
+
+    @objc public class func invalidURLError(_ url: String?) -> NSError {
+        let userInfo: [AnyHashable: Any] = [BGHttpErrorKeyURL: url ?? ""]
+        return error(withCode: 1, description: localizedDescription(forErrorCode: 1), userInfo: userInfo)
+    }
+
+    @objc public class func noNetworkError() -> NSError {
+        return error(withCode: 2, description: localizedDescription(forErrorCode: 2), userInfo: nil)
+    }
+
+    @objc public class func syncInProgressError() -> NSError {
+        return error(withCode: 3, description: localizedDescription(forErrorCode: 3), userInfo: nil)
+    }
+
+    @objc public class func responseError(withStatus status: Int, url: String?, bodyBytes: Any?, underlying: Error?) -> NSError {
+        var userInfo: [AnyHashable: Any] = [BGHttpErrorKeyStatus: status]
+        if let url = url { userInfo[BGHttpErrorKeyURL] = url }
+        if let bodyBytes = bodyBytes { userInfo[BGHttpErrorKeyResponseBody] = bodyBytes }
+        if let underlying = underlying { userInfo[BGHttpErrorKeyUnderlying] = underlying }
+        return error(withCode: 4, description: localizedDescription(forErrorCode: 4), userInfo: userInfo)
+    }
+
+    @objc public class func redirectError(from fromURL: String?, to toURL: String?) -> NSError {
+        let userInfo: [AnyHashable: Any] = [
+            BGHttpErrorKeyFromURL: fromURL ?? "",
+            BGHttpErrorKeyToURL: toURL ?? ""
+        ]
+        return error(withCode: 5, description: localizedDescription(forErrorCode: 5), userInfo: userInfo)
+    }
+}

package/ios/engine/BGHttpEvent.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+@objc public final class BGHttpEvent: NSObject {
+
+    @objc public private(set) var isSuccess: Bool = false
+    @objc public private(set) var statusCode: Int = 0
+    @objc public private(set) var requestData: String?
+    @objc public private(set) var responseText: String?
+    @objc public private(set) var error: Error?
+
+    @objc public init(statusCode: Int, requestData: String?, responseData: Data?, error: Error?) {
+        super.init()
+        self.isSuccess = (statusCode >= 200 && statusCode < 205)
+        self.statusCode = statusCode
+        self.requestData = requestData
+        if let responseData = responseData {
+            self.responseText = String(data: responseData, encoding: .utf8) ?? ""
+        } else {
+            self.responseText = ""
+        }
+        self.error = error
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        let dict = NSMutableDictionary()
+        dict["success"] = isSuccess
+        dict["status"] = statusCode
+        dict["responseText"] = responseText ?? ""
+        if let error = error as NSError? {
+            dict["error"] = error.localizedDescription
+        }
+        return dict as! [String: Any]
+    }
+}

package/ios/engine/BGHttpRequest.swift

@@ -0,0 +1,126 @@
+import Foundation
+
+@objc public final class BGHttpRequest: NSObject {
+
+    @objc public private(set) var records: [Any]
+    @objc public var completion: ((BGHttpRequest, BGHttpResponse) -> Void)?
+    @objc public private(set) var requestData: Any?
+    @objc public private(set) var url: URL?
+
+    @objc public static func execute(_ records: [Any], callback: @escaping (BGHttpRequest, BGHttpResponse) -> Void) -> BGHttpRequest {
+        let request = BGHttpRequest(records: records, callback: callback)
+        request.run()
+        return request
+    }
+
+    @objc public init(records: [Any], callback: ((BGHttpRequest, BGHttpResponse) -> Void)?) {
+        self.records = records
+        super.init()
+        let urlString = BGConfig.sharedInstance().http.url
+        if !urlString.isEmpty {
+            self.url = URL(string: urlString)
+        }
+        self.completion = callback
+    }
+
+    @objc public func run() {
+        let config = BGConfig.sharedInstance()
+        let http = config.http
+
+        guard let url = url else { return }
+        let request = NSMutableURLRequest(url: url,
+                                          cachePolicy: .reloadIgnoringLocalCacheData,
+                                          timeoutInterval: http.timeoutSeconds)
+        request.httpMethod = http.method
+        request.setValue("application/json; charset=utf-8", forHTTPHeaderField: "Content-Type")
+
+        // Build the JSON payload from the records' "location" entries.
+        let rootProperty = http.rootProperty
+        var payload: Any
+        if http.batchSync {
+            var array: [Any] = []
+            for record in records {
+                if let dict = record as? [AnyHashable: Any], let location = dict["location"] {
+                    array.append(location)
+                }
+            }
+            payload = array
+        } else {
+            payload = (records.first as? [AnyHashable: Any])?["location"] ?? [:]
+        }
+
+        var requestObject: Any
+        if rootProperty == "." {
+            requestObject = payload
+        } else {
+            requestObject = [rootProperty ?? "": payload]
+        }
+
+        // Merge #params (only valid when the payload is an object).
+        let params = http.params
+        if !params.isEmpty {
+            if var dict = requestObject as? [AnyHashable: Any] {
+                dict.merge(params) { _, new in new }
+                requestObject = dict
+            } else {
+                let logger = BGLog.sharedInstance()
+                if logger.shouldLog(2) {
+                    let message = "Cannot attach HTTP #params to an HTTP request with JSON data of type [Array], not an {Object].  Specify an #httpRootProperty other than '.' (eg: 'data')"
+                    logger.log(2, tag: 9, function: "-[BGHttpRequest run]", message: message)
+                }
+            }
+        }
+
+        // Custom headers.
+        let headers = http.headers
+        for (key, value) in headers {
+            request.setValue(String(format: "%@", "\(value)"), forHTTPHeaderField: "\(key)")
+        }
+
+        // Authorization strategy: apply auth headers if configured.
+        if let token = config.authorization.accessToken, !token.isEmpty {
+            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        }
+
+        // Serialize body.
+        var jsonError: NSError?
+        let body: Data?
+        do {
+            body = try JSONSerialization.data(withJSONObject: requestObject, options: [])
+        } catch let error as NSError {
+            jsonError = error
+            body = nil
+        }
+
+        if let jsonError = jsonError {
+            let logger = BGLog.sharedInstance()
+            if logger.shouldLog(1) {
+                let message = String(format: "JSON error composing HTTP POST data: %@", jsonError.localizedDescription)
+                logger.log(1, tag: 0, function: "-[BGHttpRequest run]", message: message)
+            }
+            let response = BGHttpResponse(status: 200, data: nil, error: jsonError)
+            completion?(self, response)
+            return
+        }
+
+        guard let body = body else { return }
+
+        let logger = BGLog.sharedInstance()
+        if logger.shouldLog(1) {
+            let bodyString = String(data: body, encoding: .utf8) ?? ""
+            let message = String(format: "%@", bodyString)
+            logger.log(1, tag: 0, function: "-[BGHttpRequest run]", message: message)
+        }
+
+        request.setValue(String(format: "%lu", body.count), forHTTPHeaderField: "Content-Length")
+        request.httpBody = body
+
+        let session = URLSession(configuration: .default)
+        let task = session.dataTask(with: request as URLRequest) { [weak self] (data, response, error) in
+            guard let self = self else { return }
+            let httpResponse = BGHttpResponse(data: data, response: response, error: error)
+            self.completion?(self, httpResponse)
+        }
+        task.resume()
+    }
+}

package/ios/engine/BGHttpResponse.swift

@@ -0,0 +1,93 @@
+import Foundation
+
+@objc public final class BGHttpResponse: NSObject {
+
+    @objc public var error: Error?
+    @objc public var data: Data?
+    @objc public var response: URLResponse?
+    @objc public var status: Int = 0
+
+    @objc public init(data: Data?, response: URLResponse?, error: Error?) {
+        super.init()
+        self.data = data
+        self.response = response
+        self.error = error
+        if let httpResponse = response as? HTTPURLResponse {
+            self.status = httpResponse.statusCode
+        }
+        handleResponse()
+    }
+
+    @objc public init(status: Int, data: Data?, error: Error?) {
+        super.init()
+        self.data = data
+        self.response = nil
+        self.error = error
+        self.status = status
+        handleResponse()
+    }
+
+    @objc public func handleResponse() {
+        let config = BGConfig.sharedInstance()
+        var requestURL: URL? = nil
+        let urlString = config.http.url
+        if !urlString.isEmpty {
+            requestURL = URL(string: urlString)
+        }
+
+        // Redirect detection (301, 302, 307, 308) → flag redirect error.
+        if [301, 302, 307, 308].contains(status) {
+            let requestUrlString = requestURL?.absoluteString ?? ""
+            let responseUrlString = (response as? HTTPURLResponse)?.url?.absoluteString ?? ""
+            if !requestUrlString.isEmpty && !responseUrlString.isEmpty {
+                self.error = NSError(domain: NSURLErrorDomain, code: status, userInfo: [NSLocalizedDescriptionKey: "Redirect from \(requestUrlString) to \(responseUrlString)"])
+            }
+        }
+
+        // NSURLErrorUserCancelledAuthentication (-1012) → treat as 401.
+        if let err = error as NSError?, err.code == -1012 {
+            self.status = 401
+        } else if [200, 201, 204].contains(status) {
+            // Success — log and return.
+            let logger = BGLog.sharedInstance()
+            if logger.shouldLog(3) {
+                let message = String(format: "Response: %ld", status)
+                logger.log(3, tag: 1, function: "-[BGHttpResponse handleResponse]", message: message)
+            }
+            return
+        } else if status == 410 {
+            // Gone — destroy auth token for host if present.
+            if let host = requestURL?.host, !host.isEmpty,
+               let hostURL = URL(string: "https://\(host)") {
+                if TransistorAuthorizationToken.hasToken(forHost: host) {
+                    TransistorAuthorizationToken.destroy(url: hostURL)
+                }
+            }
+        }
+
+        // Build a descriptive error for any non-success response.
+        var bodyString = ""
+        if let data = data {
+            bodyString = String(data: data, encoding: .utf8) ?? ""
+        }
+        var message = String(format: "HTTP ERROR: %ld", status)
+        if !bodyString.isEmpty {
+            message = message + String(format: "* %@\n", bodyString)
+        }
+        if let err = error as NSError? {
+            message = message + String(format: "* %@\n*\n%@", err.localizedDescription, err.userInfo)
+        }
+
+        let logger = BGLog.sharedInstance()
+        if logger.shouldLog(2) {
+            let logMessage = String(format: "%@", message)
+            logger.log(2, tag: 9, function: "-[BGHttpResponse handleResponse]", message: logMessage)
+        }
+
+        if error == nil {
+            self.error = NSError(domain: NSURLErrorDomain,
+                                 code: status,
+                                 userInfo: [NSUnderlyingErrorKey: message])
+        }
+    }
+}