react-native-bg-geolocation 0.2.0

package/ios/engine/BGLog.swift

@@ -0,0 +1,337 @@
+import Foundation
+import MessageUI
+import CoreLocation
+
+@objc public class BGLog: NSObject {
+
+    private static var _sharedInstance: BGLog?
+    private static let lock = NSLock()
+
+    @objc public var logLevel: Int = 5
+    @objc public var maxAge: Int = 3
+    @objc public var deviceInfo: [String: Any] = [:]
+    @objc public var pendingEmailSuccess: (() -> Void)?
+
+    @objc public var locationCompleteListener: AnyObject?
+    @objc public var locationErrorListener: AnyObject?
+    @objc public var locationSampleListener: AnyObject?
+    @objc public var locationTrackingListener: AnyObject?
+    @objc public var heartbeatListener: AnyObject?
+    @objc public var motionChangeCompleteListener: AnyObject?
+    @objc public var motionChangeSampleListener: AnyObject?
+    @objc public var motionChangeErrorListener: AnyObject?
+    @objc public var geofenceCompleteListener: AnyObject?
+    @objc public var watchPositionCompleteListener: AnyObject?
+
+    private let logQueue = DispatchQueue(label: "BGLog.queue", attributes: .concurrent)
+    private var logEntries: [String] = []
+    private var dbQueue: BGDatabaseQueue?
+
+    @objc public class func sharedInstance() -> BGLog {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGLog()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public func configure() {
+        setupDatabase()
+        subscribeEventBus()
+    }
+
+    private func setupDatabase() {
+        let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
+        guard let docPath = paths.first else { return }
+        let dbPath = docPath.appendingPathComponent("BGLog.db")
+        dbQueue = BGDatabaseQueue(path: dbPath.path)
+        dbQueue?.inDatabase { db in
+            _ = db.executeUpdate("""
+                CREATE TABLE IF NOT EXISTS logs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp REAL NOT NULL,
+                    level INTEGER NOT NULL,
+                    tag TEXT,
+                    message TEXT NOT NULL
+                )
+            """)
+            _ = db.executeUpdate("CREATE INDEX IF NOT EXISTS logs_timestamp ON logs (timestamp)")
+        }
+    }
+
+    @objc public func subscribeEventBus() {
+        let bus = BGEventBus.sharedInstance()
+        locationCompleteListener = bus.on(BGEventNames.locationComplete) { [weak self] _ in
+            self?.onLocationComplete()
+        } as AnyObject
+        locationErrorListener = bus.on(BGEventNames.locationError) { [weak self] _ in
+            self?.onLocationError()
+        } as AnyObject
+        locationSampleListener = bus.on(BGEventNames.locationSample) { [weak self] _ in
+            self?.onLocationSample()
+        } as AnyObject
+        heartbeatListener = bus.on(BGEventNames.heartbeat) { [weak self] payload in
+            self?.onHeartbeat(payload as? [String: Any])
+        } as AnyObject
+        geofenceCompleteListener = bus.on(BGEventNames.geofenceComplete) { [weak self] payload in
+            self?.onGeofence(payload as? [String: Any])
+        } as AnyObject
+        motionChangeCompleteListener = bus.on(BGEventNames.motionChangeComplete) { [weak self] payload in
+            self?.onMotionChangeComplete(payload as? [String: Any])
+        } as AnyObject
+    }
+
+    @objc public func unsubscribeEventBus() {
+        let bus = BGEventBus.sharedInstance()
+        if let token = locationCompleteListener as? String { bus.off(BGEventNames.locationComplete, token: token) }
+        if let token = locationErrorListener as? String { bus.off(BGEventNames.locationError, token: token) }
+        if let token = locationSampleListener as? String { bus.off(BGEventNames.locationSample, token: token) }
+        if let token = heartbeatListener as? String { bus.off(BGEventNames.heartbeat, token: token) }
+        if let token = geofenceCompleteListener as? String { bus.off(BGEventNames.geofenceComplete, token: token) }
+        if let token = motionChangeCompleteListener as? String { bus.off(BGEventNames.motionChangeComplete, token: token) }
+    }
+
+    public func setLogLevel(_ level: Int) {
+        self.logLevel = level
+    }
+
+    public func setMaxAge(_ days: Int) {
+        self.maxAge = days
+        purgeOldEntries()
+    }
+
+    @objc public func notify(_ message: String, debug: Bool) {
+        let level = debug ? 5 : 3
+        guard level <= logLevel else { return }
+        let entry = "[BGLocationManager \(timestamp())] \(message)"
+        logQueue.async(flags: .barrier) {
+            self.logEntries.append(entry)
+            self.writeToDatabase(level: level, tag: "BGLocationManager", message: message)
+        }
+    }
+
+    @objc public func alert(_ tag: String, message: String) {
+        guard 2 <= logLevel else { return }
+        let entry = "[\(timestamp())] [\(tag)] \(message)"
+        logQueue.async(flags: .barrier) {
+            self.logEntries.append(entry)
+            self.writeToDatabase(level: 2, tag: tag, message: message)
+        }
+    }
+
+    @objc public func commit() {
+        logQueue.sync(flags: .barrier) {
+            self.logEntries.removeAll()
+        }
+    }
+
+    @objc public func destroy() {
+        logQueue.async(flags: .barrier) {
+            self.logEntries.removeAll()
+        }
+        dbQueue?.inDatabase { db in
+            _ = db.executeUpdate("DELETE FROM logs")
+        }
+    }
+
+    @objc public func getLog(_ query: LogQuery) -> [[String: Any]] {
+        var results: [[String: Any]] = []
+        dbQueue?.inDatabase { db in
+            let sql = buildQuery(query)
+            guard let rs = db.executeQuery(sql, withArgumentsInArray: query.arguments as! [Any]) else { return }
+            defer { rs.close() }
+            while rs.next() {
+                var entry: [String: Any] = [:]
+                if let ts = rs.string(forColumn: "timestamp") { entry["timestamp"] = ts }
+                if let level = rs.string(forColumn: "level") { entry["level"] = level }
+                if let tag = rs.string(forColumn: "tag") { entry["tag"] = tag }
+                if let msg = rs.string(forColumn: "message") { entry["message"] = msg }
+                results.append(entry)
+            }
+        }
+        return results
+    }
+
+    @objc public func emailLog(_ to: String, query: LogQuery, success: (() -> Void)?, failure: ((Error) -> Void)?) {
+        guard MFMailComposeViewController.canSendMail() else {
+            failure?(NSError(domain: "BGLog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Mail not available"]))
+            return
+        }
+        let entries = getLog(query)
+        let body = entries.map { entry -> String in
+            let ts = entry["timestamp"] as? String ?? ""
+            let tag = entry["tag"] as? String ?? ""
+            let msg = entry["message"] as? String ?? ""
+            return "[\(ts)] [\(tag)] \(msg)"
+        }.joined(separator: "\n")
+
+        DispatchQueue.main.async {
+            let vc = MFMailComposeViewController()
+            vc.mailComposeDelegate = self
+            vc.setToRecipients([to])
+            vc.setSubject("BGLocationManager Log")
+            vc.setMessageBody(body, isHTML: false)
+            self.pendingEmailSuccess = success
+            // Present from top-most view controller
+            if let rootVC = UIApplication.shared.windows.first?.rootViewController {
+                var topVC = rootVC
+                while let presented = topVC.presentedViewController { topVC = presented }
+                topVC.present(vc, animated: true)
+            }
+        }
+    }
+
+    @objc public func uploadLog(_ url: String, query: LogQuery, success: (([String: Any]) -> Void)?, failure: ((Error) -> Void)?) {
+        let entries = getLog(query)
+        guard let requestURL = URL(string: url) else {
+            failure?(NSError(domain: "BGLog", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"]))
+            return
+        }
+        var request = URLRequest(url: requestURL)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        let body: [String: Any] = ["logs": entries, "deviceInfo": deviceInfo]
+        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                failure?(error)
+                return
+            }
+            if let data = data, let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                success?(json)
+            } else {
+                success?([:])
+            }
+        }.resume()
+    }
+
+    @objc public func gzip(_ data: Data) -> Data? {
+        return data
+    }
+
+    @objc public func playSound(_ soundId: SystemSoundID) {
+        AudioServicesPlaySystemSound(soundId)
+    }
+
+    @objc public func playSound(_ soundId: SystemSoundID, debug: Bool) {
+        guard debug else { return }
+        playSound(soundId)
+    }
+
+    // MARK: - Event handlers
+
+    @objc public func onLocationComplete() {
+        notify("Location complete", debug: true)
+    }
+
+    @objc public func onLocationError() {
+        notify("Location error", debug: false)
+    }
+
+    @objc public func onLocationSample() {
+        notify("Location sample", debug: true)
+    }
+
+    @objc public func onHeartbeat(_ payload: [String: Any]?) {
+        notify("Heartbeat", debug: true)
+    }
+
+    @objc public func onGeofence(_ payload: [String: Any]?) {
+        notify("Geofence event", debug: true)
+    }
+
+    @objc public func onMotionChangeComplete(_ payload: [String: Any]?) {
+        notify("Motion change complete", debug: true)
+    }
+
+    @objc public func onChangeDebug(_ debug: Bool) {
+    }
+
+    @objc public func onChangeLogLevel(_ level: Int) {
+        logLevel = level
+    }
+
+    @objc public func onChangeLogMaxDays(_ days: Int) {
+        maxAge = days
+        purgeOldEntries()
+    }
+
+
+    // MARK: - Logging interface
+
+    @objc public func shouldLog(_ level: Int) -> Bool {
+        return level <= logLevel
+    }
+
+    @objc public func log(_ level: Int, tag: Int, function: String, message: String) {
+        guard shouldLog(level) else { return }
+        let tagName = "tag:\(tag)"
+        let entry = "[\(timestamp())] [\(tagName)] [\(function)] \(message)"
+        logQueue.async(flags: .barrier) {
+            self.logEntries.append(entry)
+            self.writeToDatabase(level: level, tag: tagName, message: "\(function): \(message)")
+        }
+    }
+
+    // MARK: - Private helpers
+
+    private func timestamp() -> String {
+        let fmt = DateFormatter()
+        fmt.dateFormat = "yyyy-MM-dd HH:mm:ss.SSS"
+        return fmt.string(from: Date())
+    }
+
+    private func writeToDatabase(level: Int, tag: String, message: String) {
+        dbQueue?.inDatabase { db in
+            _ = db.executeUpdate(
+                "INSERT INTO logs (timestamp, level, tag, message) VALUES (?, ?, ?, ?)",
+                withArgumentsInArray: [Date().timeIntervalSince1970, level, tag, message]
+            )
+        }
+    }
+
+    private func purgeOldEntries() {
+        let cutoff = Date().timeIntervalSince1970 - Double(maxAge) * 86400
+        dbQueue?.inDatabase { db in
+            _ = db.executeUpdate("DELETE FROM logs WHERE timestamp < ?", withArgumentsInArray: [cutoff])
+        }
+    }
+
+    private func buildQuery(_ query: LogQuery) -> String {
+        var conditions: [String] = []
+        if query.start > 0 {
+            conditions.append("timestamp >= \(query.start)")
+        }
+        if query.end > 0 {
+            conditions.append("timestamp <= \(query.end)")
+        }
+        var sql = "SELECT * FROM logs"
+        if !conditions.isEmpty {
+            sql += " WHERE " + conditions.joined(separator: " AND ")
+        }
+        sql += " ORDER BY timestamp \(query.order == 0 ? "DESC" : "ASC")"
+        if query.limit > 0 {
+            sql += " LIMIT \(query.limit)"
+        }
+        return sql
+    }
+}
+
+import AudioToolbox
+import UIKit
+
+extension BGLog: MFMailComposeViewControllerDelegate {
+    public func mailComposeController(_ controller: MFMailComposeViewController,
+                                      didFinishWith result: MFMailComposeResult,
+                                      error: Error?) {
+        controller.dismiss(animated: true) {
+            if result == .sent { self.pendingEmailSuccess?() }
+            self.pendingEmailSuccess = nil
+        }
+    }
+}

package/ios/engine/BGLogLevel.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+public func BGLogLevelToString(_ level: Int) -> String {
+    switch level {
+    case 0: return "off"
+    case 1: return "error"
+    case 2: return "warning"
+    case 3: return "info"
+    case 4: return "debug"
+    case 5: return "verbose"
+    default: return "unknown"
+    }
+}
+
+public func BGLogLevelFromString(_ string: String?, _ defaultLevel: Int) -> Int {
+    guard let string = string, !string.isEmpty else { return defaultLevel }
+    switch string.lowercased() {
+    case "off": return 0
+    case "error": return 1
+    case "warning": return 2
+    case "info": return 3
+    case "debug": return 4
+    case "verbose": return 5
+    default: return defaultLevel
+    }
+}

package/ios/engine/BGLoggerConfig.swift

@@ -0,0 +1,60 @@
+import Foundation
+
+@objc public class BGLoggerConfig: BGConfigModuleBase {
+
+    @objc public var logLevel: Int = 5
+    @objc public var logMaxDays: Int = 3
+    @objc public var debug: Bool = false
+
+    @objc public class func logLevel(fromString s: String) -> Int {
+        switch s.uppercased() {
+        case "OFF": return 0
+        case "ERROR": return 1
+        case "WARN", "WARNING": return 2
+        case "INFO": return 3
+        case "DEBUG": return 4
+        case "VERBOSE", "TRACE": return 5
+        default: return 3
+        }
+    }
+
+    @objc public class func string(forLogLevel level: Int) -> String {
+        switch level {
+        case 0: return "OFF"
+        case 1: return "ERROR"
+        case 2: return "WARN"
+        case 3: return "INFO"
+        case 4: return "DEBUG"
+        case 5: return "VERBOSE"
+        default: return "INFO"
+        }
+    }
+
+    @objc public override func applyDefaults() {
+        logLevel = 5
+        logMaxDays = 3
+        debug = false
+    }
+
+    @objc public override func contributeDeprecatedProperties(_ dict: NSMutableDictionary, redact: Bool) {
+        dict["logLevel"] = logLevel
+        dict["logMaxDays"] = logMaxDays
+        dict["debug"] = debug
+    }
+
+    @objc public override func propertySpecs() -> [BGPropertySpecImpl] {
+        return [
+            BGPropertySpec(name: "logLevel", type: "int"),
+            BGPropertySpec(name: "logMaxDays", type: "int"),
+            BGPropertySpec(name: "debug", type: "bool")
+        ]
+    }
+
+    @objc public override func validateConfiguration() -> Bool {
+        return true
+    }
+
+    @objc public override var description: String {
+        return "<BGLoggerConfig logLevel=\(logLevel) logMaxDays=\(logMaxDays) debug=\(debug)>"
+    }
+}

package/ios/engine/BGMotionActivity.swift

@@ -0,0 +1,31 @@
+import Foundation
+
+@objc public final class BGMotionActivity: NSObject {
+
+    @objc public var type: String = "unknown"
+    @objc public var confidence: Int = 0
+    @objc public var name: String { return type }
+
+    @objc public override convenience init() {
+        self.init(type: "unknown", confidence: 0)
+    }
+
+    @objc public init(type: String, confidence: Int) {
+        super.init()
+        self.type = type
+        self.confidence = confidence
+    }
+
+    // Integer-based type value for legacy ObjC compatibility
+    @objc public var typeCode: Int {
+        switch type {
+        case "still": return 1
+        case "on_foot": return 2
+        case "running": return 3
+        case "in_vehicle": return 4
+        case "on_bicycle": return 5
+        case "moving": return 7
+        default: return 6
+        }
+    }
+}

package/ios/engine/BGMotionActivityClassifier.swift

@@ -0,0 +1,108 @@
+import Foundation
+import CoreMotion
+
+@objc public class BGMotionActivityClassifier: NSObject {
+
+    @objc public var sampleInterval: Double = 0.1
+    @objc public var samplesPerWindow: Int = 50
+    @objc public var windowSeconds: Double = 5.0
+    @objc public var n: Int = 0
+    @objc public var decay: Double = 0.95
+
+    @objc public var sumMag: Double = 0
+    @objc public var sumMag2: Double = 0
+    @objc public var sumGyro2: Double = 0
+    @objc public var lastMag: Double = 0
+    @objc public var hasLastMag: Bool = false
+    @objc public var jerkSum: Double = 0
+    @objc public var jerkStill: Double = 0.05
+    @objc public var jerkShakeThreshold: Double = 2.0
+    @objc public var varStill: Double = 0.01
+    @objc public var gyroShake: Double = 0.5
+    @objc public var gyroStill: Double = 0.05
+
+    @objc public var gzWalk_c: Double = 0
+    @objc public var gzWalk_s: Double = 0
+    @objc public var gzWalk_q1: Double = 0
+    @objc public var gzWalk_q2: Double = 0
+    @objc public var gzWalk_pow: Double = 0
+
+    @objc public var gzRun_c: Double = 0
+    @objc public var gzRun_s: Double = 0
+    @objc public var gzRun_q1: Double = 0
+    @objc public var gzRun_q2: Double = 0
+    @objc public var gzRun_pow: Double = 0
+
+    @objc public var walkWins: Int = 0
+    @objc public var runWins: Int = 0
+    @objc public var lastSpeed: Double = 0
+    @objc public var maxWalkSpeed: Double = 3.0
+    @objc public var maxRunSpeed: Double = 12.0
+    @objc public var minSpeed: Double = 0.5
+    @objc public var cadenceConfirmWindows: Int = 3
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public func configureWithSampleInterval(_ interval: Double, windowSeconds: Double) {
+        self.sampleInterval = interval
+        self.windowSeconds = windowSeconds
+        self.samplesPerWindow = Int(windowSeconds / interval)
+        reset()
+    }
+
+    @objc public func ingestAcceleration(_ data: CMAccelerometerData) {
+        let ax = data.acceleration.x
+        let ay = data.acceleration.y
+        let az = data.acceleration.z
+        let mag = sqrt(ax*ax + ay*ay + az*az)
+
+        if hasLastMag {
+            let jerk = abs(mag - lastMag) / sampleInterval
+            jerkSum = jerkSum * decay + jerk
+            sumGyro2 = sumGyro2 * decay
+        }
+
+        sumMag = sumMag * decay + mag
+        sumMag2 = sumMag2 * decay + mag * mag
+        lastMag = mag
+        hasLastMag = true
+        n = min(n + 1, samplesPerWindow)
+    }
+
+    @objc public func ingestRotationRate(_ data: CMGyroData) {
+        let rx = data.rotationRate.x
+        let ry = data.rotationRate.y
+        let rz = data.rotationRate.z
+        let gyroMag = sqrt(rx*rx + ry*ry + rz*rz)
+        sumGyro2 = sumGyro2 * decay + gyroMag * gyroMag
+    }
+
+    @objc public func isWindowReady() -> Bool {
+        return n >= samplesPerWindow
+    }
+
+    @objc public func classifyWithSpeed(_ speed: Double) -> String {
+        lastSpeed = speed
+        if speed < minSpeed { return "still" }
+        if speed <= maxWalkSpeed { return "walking" }
+        if speed <= maxRunSpeed { return "running" }
+        return "in_vehicle"
+    }
+
+    @objc public func updateSpeed(_ speed: Double) {
+        lastSpeed = speed
+    }
+
+    @objc public func reset() {
+        n = 0
+        sumMag = 0
+        sumMag2 = 0
+        sumGyro2 = 0
+        jerkSum = 0
+        hasLastMag = false
+        walkWins = 0
+        runWins = 0
+    }
+}

package/ios/engine/BGMotionActivityManagerAdapter.swift

@@ -0,0 +1,40 @@
+import Foundation
+import CoreMotion
+
+@objc public class BGMotionActivityManagerAdapter: NSObject {
+
+    @objc public var mgr: CMMotionActivityManager?
+
+    @objc public class func isActivityAvailable() -> Bool {
+        return CMMotionActivityManager.isActivityAvailable()
+    }
+
+    public class func authorizationStatus() -> CMAuthorizationStatus {
+        return CMMotionActivityManager.authorizationStatus()
+    }
+
+    @objc public override init() {
+        mgr = CMMotionActivityManager()
+        super.init()
+    }
+
+    @objc public func startActivityUpdates(
+        toQueue queue: OperationQueue,
+        withHandler handler: @escaping CMMotionActivityHandler
+    ) {
+        mgr?.startActivityUpdates(to: queue, withHandler: handler)
+    }
+
+    @objc public func stopActivityUpdates() {
+        mgr?.stopActivityUpdates()
+    }
+
+    @objc public func queryActivityStarting(
+        fromDate start: Date,
+        toDate end: Date,
+        toQueue queue: OperationQueue,
+        withHandler handler: @escaping CMMotionActivityQueryHandler
+    ) {
+        mgr?.queryActivityStarting(from: start, to: end, to: queue, withHandler: handler)
+    }
+}

package/ios/engine/BGMotionActivitySource.swift

@@ -0,0 +1,46 @@
+import Foundation
+import CoreMotion
+
+@objc public protocol BGMotionActivitySourceDelegate: AnyObject {
+    func activitySource(_ source: BGMotionActivitySource, didUpdate activity: CMMotionActivity)
+}
+
+@objc public class BGMotionActivitySource: NSObject {
+
+    @objc public weak var delegate: BGMotionActivitySourceDelegate?
+    @objc public var manager: BGMotionActivityManagerAdapter?
+    @objc public var queue: OperationQueue?
+    @objc private(set) var running: Bool = false
+
+    @objc public class func isAvailable() -> Bool {
+        return CMMotionActivityManager.isActivityAvailable()
+    }
+
+    @objc public init(queue: OperationQueue) {
+        self.queue = queue
+        self.manager = BGMotionActivityManagerAdapter()
+        super.init()
+    }
+
+    @objc public override init() {
+        self.queue = OperationQueue()
+        self.manager = BGMotionActivityManagerAdapter()
+        super.init()
+    }
+
+    @objc public func start() {
+        guard !running, let mgr = manager, let q = queue else { return }
+        running = true
+        mgr.startActivityUpdates(toQueue: q) { [weak self] activity in
+            guard let self = self, let activity = activity else { return }
+            self.delegate?.activitySource(self, didUpdate: activity)
+        }
+    }
+
+    @objc public func stop() {
+        manager?.stopActivityUpdates()
+        running = false
+    }
+
+    public func setRunning(_ value: Bool) { running = value }
+}