react-native-bg-geolocation 0.2.0

package/ios/engine/BGMotionDetector.swift

@@ -0,0 +1,377 @@
+import Foundation
+import CoreMotion
+import CoreLocation
+
+@objc public class BGMotionDetector: NSObject, BGMotionActivitySourceDelegate {
+
+    private static var _sharedInstance: BGMotionDetector?
+    private static let instanceLock = NSLock()
+
+    @objc public class func sharedInstance() -> BGMotionDetector {
+        instanceLock.lock()
+        defer { instanceLock.unlock() }
+        if _sharedInstance == nil { _sharedInstance = BGMotionDetector() }
+        return _sharedInstance!
+    }
+
+    public class func motionAuthorizationStatus() -> CMAuthorizationStatus {
+        return CMMotionActivityManager.authorizationStatus()
+    }
+
+    @objc public class func motionHardwareAvailable() -> Bool {
+        return CMMotionActivityManager.isActivityAvailable()
+    }
+
+    // MARK: - State
+
+    @objc public var enabled: Bool = false
+    @objc public var debug: Bool = false
+    @objc public var isMoving: Bool = false
+    @objc public var isUpdatingMotionActivity: Bool = false
+    @objc public var useM7IfAvailable: Bool = true
+    @objc public var useAccelerometerFallback: Bool = true
+    @objc public var autoRequestMotionPermission: Bool = true
+
+    // Activity state
+    @objc public var motionType: String = "unknown"
+    @objc public var previousMotionType: String = "unknown"
+    @objc public var statedActivity: BGMotionActivity?
+    @objc public var currentActivity: BGMotionActivity?
+    @objc public var motionActivity: CMMotionActivity?
+    @objc public var detectorState: String = "stopped"
+    @objc public var history: [BGMotionActivity] = []
+    @objc public var diagnostics: [String: Any] = [:]
+
+    // Speed/location state
+    @objc public var location: CLLocation?
+    @objc public var currentSpeed: Double = 0
+
+    // Confidence tracking
+    @objc public var lastConfidence: Int = 0
+    @objc public var lastEmittedType: String = "unknown"
+    @objc public var lastEmittedConfidence: Int = 0
+    @objc public var lastTypeChangeAt: Date?
+    @objc public var confidenceDeltaThreshold: Int = 1
+    @objc public var minimumMotionActivityConfidence: Int = 1
+
+    // Sensor state
+    public var acceleration: CMAcceleration = CMAcceleration()
+    @objc public var accelerometerUpdateInterval: TimeInterval = 0.1
+    @objc public var samplesPerInterval: Int = 50
+    @objc public var detectMotionWindow: TimeInterval = 5.0
+
+    // M7 detection thresholds
+    @objc public var isUsingM7: Bool = false
+    @objc public var M7Authorized: Bool = false
+
+    // Motion probe settings (adaptive polling)
+    @objc public var probeMinInterval: TimeInterval = 5.0
+    @objc public var probeCooldownBase: TimeInterval = 15.0
+    @objc public var probeCooldownMax: TimeInterval = 120.0
+    @objc public var probeFreshSpeedAge: TimeInterval = 10.0
+    @objc public var probeFreshSpeedThreshold: Double = 0.5
+    @objc public var probeHighConfidence: Int = 75
+    @objc public var probeDwellWins: Int = 3
+
+    // Stop detection
+    @objc public var stopDwellWins: Int = 3
+    @objc public var stopHighConfidence: Int = 90
+    @objc public var sdConsecutiveStillWins: Int = 0
+    @objc public var mdConsecutiveMovingWins: Int = 0
+    @objc public var mdBackoffLevel: Int = 0
+    @objc public var mdLastProbeAt: Date?
+    @objc public var mdLastSpeedAt: Date?
+    @objc public var mdLastSpeedValue: Double = 0
+    @objc public var mdSuppressUntil: Date?
+
+    // Type debounce
+    @objc public var motionDebounceInterval: TimeInterval = 1.0
+    @objc public var typeDebounceInterval: TimeInterval = 2.0
+    @objc public var motionDetectionInterval: TimeInterval = 10.0
+
+    // Speed thresholds
+    @objc public var minimumSpeed: Double = 0.5
+    @objc public var maximumWalkingSpeed: Double = 3.0
+    @objc public var maximumRunningSpeed: Double = 10.0
+
+    // Sensors
+    @objc public var motionManager: CMMotionManager?
+    @objc public var motionActivityManager: CMMotionActivityManager?
+    @objc public var activitySource: BGMotionActivitySource?
+    @objc public var activityClassifier: BGMotionActivityClassifier?
+    @objc public var permissionMgr: BGMotionPermissionManager?
+    @objc public var activityProvider: AnyObject?
+
+    var accelerometerQueue: OperationQueue?
+    var windowTimer: Timer?
+    var stateQueue: DispatchQueue?
+
+    @objc public var accelerationChangedBlock: ((CMAccelerometerData) -> Void)?
+    @objc public var motionActivityChangedBlock: ((CMMotionActivity) -> Void)?
+
+    @objc public override init() {
+        super.init()
+        stateQueue = DispatchQueue(label: "BGMotionDetector.state")
+        activityClassifier = BGMotionActivityClassifier()
+        activityClassifier?.configureWithSampleInterval(0.1, windowSeconds: 5.0)
+        permissionMgr = BGMotionPermissionManager()
+    }
+
+    // MARK: - Authorization
+
+    @objc public func isAccelerometerAvailable() -> Bool {
+        return motionManager?.isAccelerometerAvailable ?? false
+    }
+
+    @objc public func isGyroAvailable() -> Bool {
+        return motionManager?.isGyroAvailable ?? false
+    }
+
+    @objc public func isDeviceMotionAvailable() -> Bool {
+        return motionManager?.isDeviceMotionAvailable ?? false
+    }
+
+    @objc public func isMagnetometerAvailable() -> Bool {
+        return motionManager?.isMagnetometerAvailable ?? false
+    }
+
+    @objc public func isConfidentlyStationary() -> Bool {
+        guard motionType == "still" else { return false }
+        return sdConsecutiveStillWins >= stopDwellWins
+    }
+
+    // MARK: - Lifecycle
+
+    @objc public func start() {
+        guard !enabled else { return }
+        enabled = true
+        detectorState = "running"
+
+        motionManager = CMMotionManager()
+        motionManager?.accelerometerUpdateInterval = accelerometerUpdateInterval
+
+        if useM7IfAvailable && BGMotionDetector.motionHardwareAvailable() {
+            startM7Detection()
+        } else if useAccelerometerFallback {
+            startSensorDetection()
+        }
+    }
+
+    @objc public func stop() {
+        guard enabled else { return }
+        enabled = false
+        detectorState = "stopped"
+        stopSensorDetection()
+        activitySource?.stop()
+        windowTimer?.invalidate()
+        windowTimer = nil
+    }
+
+    @objc public func startSensorDetection() {
+        guard let mgr = motionManager, mgr.isAccelerometerAvailable else { return }
+        accelerometerQueue = OperationQueue()
+        accelerometerQueue?.name = "BGMotionDetector.accelerometer"
+        mgr.startAccelerometerUpdates(to: accelerometerQueue!) { [weak self] data, error in
+            guard let self = self, let data = data else { return }
+            self.activityClassifier?.ingestAcceleration(data)
+            self.accelerationChangedBlock?(data)
+        }
+
+        if mgr.isGyroAvailable {
+            mgr.startGyroUpdates(to: accelerometerQueue!) { [weak self] data, error in
+                guard let self = self, let data = data else { return }
+                self.activityClassifier?.ingestRotationRate(data)
+            }
+        }
+
+        scheduleWindowTimer()
+    }
+
+    @objc public func stopSensorDetection() {
+        motionManager?.stopAccelerometerUpdates()
+        motionManager?.stopGyroUpdates()
+        accelerometerQueue?.cancelAllOperations()
+        accelerometerQueue = nil
+        windowTimer?.invalidate()
+        windowTimer = nil
+    }
+
+    private func startM7Detection() {
+        isUsingM7 = true
+        let queue = DispatchQueue(label: "BGMotionDetector.M7")
+        activitySource = BGMotionActivitySource()
+        activitySource?.delegate = self
+        activitySource?.start()
+    }
+
+    private func scheduleWindowTimer() {
+        DispatchQueue.main.async {
+            self.windowTimer?.invalidate()
+            self.windowTimer = Timer.scheduledTimer(withTimeInterval: self.detectMotionWindow, repeats: true) { [weak self] _ in
+                self?._calculateMotionTypeLocked()
+            }
+        }
+    }
+
+    // MARK: - Motion type calculation
+
+    @objc public func calculateMotionType() {
+        stateQueue?.async { self._calculateMotionTypeLocked() }
+    }
+
+    @objc public func _calculateMotionTypeLocked() {
+        guard let classifier = activityClassifier, classifier.isWindowReady() else { return }
+        let newType = classifier.classifyWithSpeed(currentSpeed)
+        _applyMotionType(fromClassifier: newType, confidence: 80, emit: true)
+    }
+
+    @objc public func _applyMotionType(fromClassifier type: String, confidence: Int, emit: Bool) {
+        previousMotionType = motionType
+        motionType = type
+
+        if type != previousMotionType {
+            lastTypeChangeAt = Date()
+            sdConsecutiveStillWins = 0
+            mdConsecutiveMovingWins = 0
+        }
+
+        if type == "still" {
+            sdConsecutiveStillWins += 1
+            mdConsecutiveMovingWins = 0
+        } else {
+            mdConsecutiveMovingWins += 1
+            sdConsecutiveStillWins = 0
+        }
+
+        lastEmittedType = type
+        lastEmittedConfidence = confidence
+        lastConfidence = confidence
+
+        if emit {
+            let activity = BGMotionActivity(type: type, confidence: confidence)
+            currentActivity = activity
+            motionActivityChangedBlock.map { _ in }
+            NotificationCenter.default.post(name: NSNotification.Name("BGMotionDetectorDidUpdateActivity"), object: activity)
+        }
+    }
+
+    @objc public func _applySamplingIntervalLocked(_ interval: TimeInterval) {
+        accelerometerUpdateInterval = interval
+        motionManager?.accelerometerUpdateInterval = interval
+    }
+
+    @objc public func _recalcFromM7Locked() {
+        guard let activity = motionActivity else { return }
+        var type = "unknown"
+        if activity.stationary { type = "still" }
+        else if activity.walking { type = "walking" }
+        else if activity.running { type = "running" }
+        else if activity.automotive { type = "in_vehicle" }
+        else if activity.cycling { type = "on_bicycle" }
+        _applyMotionType(fromClassifier: type, confidence: Int(activity.confidence.rawValue) * 25, emit: true)
+    }
+
+    @objc public func _maybeAdjustSamplingForActivity(_ type: String) {
+        switch type {
+        case "still":
+            _applySamplingIntervalLocked(0.5)
+        case "walking", "running":
+            _applySamplingIntervalLocked(0.1)
+        default:
+            _applySamplingIntervalLocked(0.2)
+        }
+    }
+
+    // MARK: - BGMotionActivitySourceDelegate
+
+    @objc public func activitySource(_ source: BGMotionActivitySource, didUpdate activity: CMMotionActivity) {
+        stateQueue?.async {
+            self.motionActivity = activity
+            self._recalcFromM7Locked()
+            self._maybeAdjustSamplingForActivity(self.motionType)
+        }
+    }
+
+    @objc public func activitySourceDidUpdate(_ activity: BGMotionActivity) {
+        stateQueue?.async {
+            self.motionActivity = nil
+            self._recalcFromM7Locked()
+            self._maybeAdjustSamplingForActivity(self.motionType)
+        }
+    }
+
+    // MARK: - Location / speed
+
+    @objc public func setLocation(_ loc: CLLocation, isMoving moving: Bool) {
+        location = loc
+        currentSpeed = max(0, loc.speed)
+        isMoving = moving
+        activityClassifier?.updateSpeed(currentSpeed)
+    }
+
+    @objc public func updateSpeed(_ speed: Double) {
+        currentSpeed = speed
+        activityClassifier?.updateSpeed(speed)
+    }
+
+    @objc public func isMoving(_ moving: Bool) -> Bool {
+        return isMoving
+    }
+
+    @objc public func threadSafeMotionType() -> String {
+        var result = "unknown"
+        stateQueue?.sync { result = self.motionType }
+        return result
+    }
+
+    @objc public func threadSafeMotionActivity() -> BGMotionActivity? {
+        var result: BGMotionActivity?
+        stateQueue?.sync { result = self.currentActivity }
+        return result
+    }
+
+    @objc public func classifyWithSpeed(_ speed: Double) -> String {
+        return activityClassifier?.classifyWithSpeed(speed) ?? "unknown"
+    }
+
+    @objc public func shouldRequestLocationProbe() -> Bool {
+        guard enabled else { return false }
+        if let suppressUntil = mdSuppressUntil, Date() < suppressUntil { return false }
+        if let lastProbe = mdLastProbeAt {
+            return Date().timeIntervalSince(lastProbe) >= probeMinInterval
+        }
+        return true
+    }
+
+    @objc public func noteWillRequestLocationProbe() {
+        mdLastProbeAt = Date()
+    }
+
+    public func requestMotionPermission(_ completion: @escaping (CMAuthorizationStatus) -> Void) {
+        permissionMgr?.requestPermission(completion: completion)
+    }
+
+    @objc public func queryMotionActivityHistory() {
+        guard let mgr = motionActivityManager else { return }
+        let end = Date()
+        let start = end.addingTimeInterval(-3600)
+        mgr.queryActivityStarting(from: start, to: end, to: OperationQueue.main) { [weak self] (activities: [CMMotionActivity]?, error: Error?) in
+            guard let self = self, let acts = activities else { return }
+            for act in acts {
+                self.motionActivityChangedBlock?(act)
+            }
+        }
+    }
+
+    @objc public func getDiagnosticsData() -> [String: Any] {
+        return [
+            "motionType": motionType,
+            "isMoving": isMoving,
+            "enabled": enabled,
+            "lastEmittedType": lastEmittedType,
+            "lastEmittedConfidence": lastEmittedConfidence,
+            "sdConsecutiveStillWins": sdConsecutiveStillWins,
+            "mdConsecutiveMovingWins": mdConsecutiveMovingWins
+        ]
+    }
+}

package/ios/engine/BGMotionPermissionManager.swift

@@ -0,0 +1,50 @@
+import Foundation
+import CoreMotion
+
+@objc public class BGMotionPermissionManager: NSObject {
+
+    private static var _sharedInstance: BGMotionPermissionManager?
+    private static let lock = NSLock()
+
+    private let motionManager = CMMotionActivityManager()
+
+    @objc public class func sharedInstance() -> BGMotionPermissionManager {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGMotionPermissionManager()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+    }
+
+    public class func authorizationStatus() -> CMAuthorizationStatus {
+        return CMMotionActivityManager.authorizationStatus()
+    }
+
+    public func requestPermission(completion: @escaping (_ status: CMAuthorizationStatus) -> Void) {
+        motionManager.queryActivityStarting(from: Date(), to: Date(), to: .main) { _, _ in
+            completion(CMMotionActivityManager.authorizationStatus())
+            self.motionManager.stopActivityUpdates()
+        }
+    }
+
+    @objc public func isAuthorized() -> Bool {
+        return CMMotionActivityManager.authorizationStatus() == .authorized
+    }
+
+    @objc public func isDenied() -> Bool {
+        return CMMotionActivityManager.authorizationStatus() == .denied
+    }
+
+    @objc public func isRestricted() -> Bool {
+        return CMMotionActivityManager.authorizationStatus() == .restricted
+    }
+
+    @objc public func notDetermined() -> Bool {
+        return CMMotionActivityManager.authorizationStatus() == .notDetermined
+    }
+}

package/ios/engine/BGNativeLogger.swift

@@ -0,0 +1,48 @@
+import Foundation
+import os.log
+
+@objc public class BGNativeLogger: NSObject {
+
+    private static let subsystem = "com.transistorsoft.BGLocationManager"
+    private static let category = "general"
+
+    @objc public class func log(_ level: Int, tag: String, message: String) {
+        if #available(iOS 14.0, *) {
+            let logger = Logger(subsystem: subsystem, category: tag)
+            switch level {
+            case 0: break
+            case 1: logger.error("\(message)")
+            case 2: logger.warning("\(message)")
+            case 3: logger.info("\(message)")
+            case 4: logger.debug("\(message)")
+            default: logger.log("\(message)")
+            }
+        } else {
+            let prefix: String
+            switch level {
+            case 1: prefix = "ERROR"
+            case 2: prefix = "WARN"
+            case 3: prefix = "INFO"
+            case 4: prefix = "DEBUG"
+            default: prefix = "LOG"
+            }
+            print("[\(prefix)] [\(tag)] \(message)")
+        }
+    }
+
+    @objc public class func error(_ tag: String, message: String) {
+        log(1, tag: tag, message: message)
+    }
+
+    @objc public class func warn(_ tag: String, message: String) {
+        log(2, tag: tag, message: message)
+    }
+
+    @objc public class func info(_ tag: String, message: String) {
+        log(3, tag: tag, message: message)
+    }
+
+    @objc public class func debug(_ tag: String, message: String) {
+        log(4, tag: tag, message: message)
+    }
+}

package/ios/engine/BGNotificaitons.swift

@@ -0,0 +1,37 @@
+import Foundation
+import UserNotifications
+
+@objc public final class BGNotifications: NSObject {
+
+    @objc public var prepared: Bool = false
+
+    @objc public static let shared = BGNotifications()
+
+    @objc public func prepareIfNeeded(_ context: Any?) {
+        guard !prepared else { return }
+        prepared = true
+        let center = UNUserNotificationCenter.current()
+        center.delegate = self
+        center.getNotificationSettings { settings in
+            if settings.authorizationStatus != .notDetermined {
+                NSLog("[TS] notif status=%ld", settings.authorizationStatus.rawValue)
+            } else {
+                center.requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
+                    NSLog("[TS] notif auth: granted=%d err=%@", granted, error?.localizedDescription ?? "")
+                }
+            }
+        }
+    }
+
+    public func userNotificationCenter(_ center: UNUserNotificationCenter,
+                                       willPresent notification: UNNotification,
+                                       withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+        if #available(iOS 14.0, *) {
+            completionHandler([.banner, .list, .sound])
+        } else {
+            completionHandler([.alert, .badge, .sound])
+        }
+    }
+}
+
+extension BGNotifications: UNUserNotificationCenterDelegate {}

package/ios/engine/BGOdometer.swift

@@ -0,0 +1,66 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGOdometer: NSObject {
+
+    private static var _sharedInstance: BGOdometer?
+    private static let lock = NSLock()
+
+    @objc public var value: Double = 0
+    private var lastLocation: CLLocation?
+    private let userDefaultsKey = "BGLocationManager_odometer"
+
+    @objc public class func sharedInstance() -> BGOdometer {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGOdometer()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+        value = UserDefaults.standard.double(forKey: userDefaultsKey)
+    }
+
+    @objc public func addDistance(from location: CLLocation) -> Double {
+        guard let last = lastLocation else {
+            lastLocation = location
+            return value
+        }
+        let delta = location.distance(from: last)
+        value += delta
+        lastLocation = location
+        persist()
+        return value
+    }
+
+    @objc public func setOdometer(_ newValue: Double, location: CLLocation?) {
+        value = newValue
+        lastLocation = location
+        persist()
+    }
+
+    @objc public func reset() {
+        value = 0
+        lastLocation = nil
+        persist()
+    }
+
+    @objc public func getOdometer() -> Double {
+        return value
+    }
+
+    @objc public func setLastLocation(_ location: CLLocation?) {
+        lastLocation = location
+    }
+
+    @objc public func lastKnownLocation() -> CLLocation? {
+        return lastLocation
+    }
+
+    private func persist() {
+        UserDefaults.standard.set(value, forKey: userDefaultsKey)
+    }
+}

package/ios/engine/BGPersistenceConfig.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+@objc public class BGPersistenceConfig: BGConfigModuleBase {
+
+    @objc public var maxDaysToPersist: Int = 1
+    @objc public var maxRecordsToPersist: Int = -1
+    @objc public var persistMode: Int = 2
+    @objc public var locationsOrderDirection: String = "ASC"
+
+    @objc public override func applyDefaults() {
+        maxDaysToPersist = 1
+        maxRecordsToPersist = -1
+        persistMode = 2
+        locationsOrderDirection = "ASC"
+    }
+
+    @objc public override func propertySpecs() -> [BGPropertySpecImpl] {
+        return [
+            BGPropertySpec(name: "maxDaysToPersist", type: "int"),
+            BGPropertySpec(name: "maxRecordsToPersist", type: "int"),
+            BGPropertySpec(name: "persistMode", type: "int"),
+            BGPropertySpec(name: "locationsOrderDirection", type: "string")
+        ]
+    }
+
+    @objc public override var description: String {
+        return "<BGPersistenceConfig maxDaysToPersist=\(maxDaysToPersist) maxRecordsToPersist=\(maxRecordsToPersist)>"
+    }
+}

package/ios/engine/BGPolygonStreamRequest.swift

@@ -0,0 +1,48 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGPolygonStreamRequest: NSObject {
+
+    @objc public var identifier: String
+    @objc public var vertices: [[CLLocationDegrees]]
+    @objc public var interval: Double
+    @objc public var success: ((Any?) -> Void)?
+    @objc public var failure: ((Int) -> Void)?
+
+    @objc public init(
+        identifier: String,
+        vertices: [[CLLocationDegrees]],
+        interval: Double,
+        success: @escaping (Any?) -> Void,
+        failure: @escaping (Int) -> Void
+    ) {
+        self.identifier = identifier
+        self.vertices = vertices
+        self.interval = interval
+        self.success = success
+        self.failure = failure
+        super.init()
+    }
+
+    @objc public override init() {
+        identifier = UUID().uuidString
+        vertices = []
+        interval = 1000
+        super.init()
+    }
+
+    @objc public func containsCoordinate(_ coord: CLLocationCoordinate2D) -> Bool {
+        guard vertices.count >= 3 else { return false }
+        var inside = false
+        var j = vertices.count - 1
+        for i in 0..<vertices.count {
+            let xi = vertices[i][0], yi = vertices[i][1]
+            let xj = vertices[j][0], yj = vertices[j][1]
+            let intersect = ((yi > coord.latitude) != (yj > coord.latitude)) &&
+                (coord.longitude < (xj - xi) * (coord.latitude - yi) / (yj - yi) + xi)
+            if intersect { inside = !inside }
+            j = i
+        }
+        return inside
+    }
+}

package/ios/engine/BGPowerSaveChangeEvent.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+@objc public final class BGPowerSaveChangeEvent: NSObject {
+
+    @objc public private(set) var isPowerSaveMode: Bool
+
+    @objc public override init() {
+        self.isPowerSaveMode = false
+        super.init()
+        self.isPowerSaveMode = ProcessInfo.processInfo.isLowPowerModeEnabled
+    }
+}