react-native-bg-geolocation 0.2.0

package/ios/engine/BGLocationErrors.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+public let BGLocationErrorDomain = "BGLocationManager"
+
+private let BGLocationErrorMessages: [Int: String] = [
+    0: "Location unknown",
+    100: "Location did not meet desired accuracy.",
+    404: "No location available.",
+    408: "Timed out.",
+    499: "Request was cancelled",
+    503: "Service unavailable"
+]
+
+public func BGLocationErrorMessage(_ code: Int) -> String {
+    return BGLocationErrorMessages[code] ?? "Location error."
+}
+
+public func BGMakeLocationError(_ code: Int) -> NSError {
+    return NSError(domain: BGLocationErrorDomain,
+                   code: code,
+                   userInfo: [NSLocalizedDescriptionKey: BGLocationErrorMessage(code)])
+}
+
+public func BGMakeError(_ domain: String, _ code: Int) -> NSError {
+    return NSError(domain: domain,
+                   code: code,
+                   userInfo: [NSLocalizedDescriptionKey: BGLocationErrorMessage(code)])
+}

package/ios/engine/BGLocationEvent.swift

@@ -0,0 +1,43 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGLocationEvent: NSObject {
+
+    @objc public var location: CLLocation?
+    @objc public var data: [String: Any]
+    @objc public var event: String
+    @objc public var isMoving: Bool
+    @objc public var recordedAt: Date
+    @objc public var timestamp: Date
+
+    @objc public class func create(withTSLocation tsLocation: Any) -> BGLocationEvent {
+        let event = BGLocationEvent()
+        return event
+    }
+
+    @objc public init(locationDictionary: [String: Any], location: CLLocation?) {
+        self.data = locationDictionary
+        self.location = location
+        self.event = locationDictionary["event"] as? String ?? ""
+        self.isMoving = locationDictionary["is_moving"] as? Bool ?? false
+        self.timestamp = Date()
+        self.recordedAt = Date()
+        super.init()
+    }
+
+    @objc public override init() {
+        data = [:]
+        event = ""
+        isMoving = false
+        timestamp = Date()
+        recordedAt = Date()
+        super.init()
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        var dict = data
+        dict["event"] = event
+        dict["is_moving"] = isMoving
+        return dict
+    }
+}

package/ios/engine/BGLocationFilter.swift

@@ -0,0 +1,82 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGLocationFilterResult: NSObject {
+
+    @objc public var decision: Bool = true
+    @objc public var reason: String = ""
+    @objc public var accuracy: CLLocationAccuracy = 0
+    @objc public var speed: CLLocationSpeed = 0
+    @objc public var deltaRaw: Double = 0
+    @objc public var deltaSmoothed: Double = 0
+    @objc public var deltaEffective: Double = 0
+    @objc public var distanceFilter: CLLocationDistance = 0
+    @objc public var odometerSigma: Double = 0
+    @objc public var cap: Double = 0
+
+    @objc public override var description: String {
+        return "<BGLocationFilterResult decision=\(decision) reason=\(reason) delta=\(deltaEffective)>"
+    }
+}
+
+@objc public class BGLocationFilter: NSObject {
+
+    @objc public var type: String = "NONE"
+    @objc public var policy: String = "NONE"
+    @objc public var configured: Bool = false
+    @objc public var debug: Bool = false
+    @objc public var useKalman: Bool = false
+    @objc public var kalmanDebug: Bool = false
+    @objc public var kalmanProfile: String = "default"
+    @objc public var accuracyThreshold: CLLocationAccuracy = 0
+
+    private var accumulatedAccuracySquaredValue: Double = 0
+    private var kalman: BGKalmanFilter?
+
+    @objc public init(type: String) {
+        self.type = type
+        super.init()
+    }
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public func configure(_ config: BGLocationFilterConfig) {
+        applyConfig(config)
+    }
+
+    @objc public func applyConfig(_ config: BGLocationFilterConfig) {
+        policy = config.policy
+        debug = config.filterDebug
+        useKalman = config.useKalman
+        kalmanDebug = config.kalmanDebug
+        kalmanProfile = config.kalmanProfile
+        accuracyThreshold = config.odometerAccuracyThreshold
+        configured = true
+    }
+
+    @objc public func evaluateWithMetrics(_ metrics: BGLocationMetrics) -> BGLocationFilterResult {
+        let result = BGLocationFilterResult()
+        result.decision = true
+        result.reason = "PASS"
+        return result
+    }
+
+    @objc public func reset() {
+        accumulatedAccuracySquaredValue = 0
+        kalman = nil
+    }
+
+    @objc public func onMotionChange(_ isMoving: Bool) {
+        reset()
+    }
+
+    @objc public func accumulateAccuracy(withMeasurement measurement: Double) {
+        accumulatedAccuracySquaredValue += measurement * measurement
+    }
+
+    @objc public func seedAccumulatedAccuracySquared(_ value: Double) {
+        accumulatedAccuracySquaredValue = value
+    }
+}

package/ios/engine/BGLocationFilterConfig.swift

@@ -0,0 +1,57 @@
+import Foundation
+
+@objc public class BGLocationFilterConfig: BGConfigModuleBase {
+
+    @objc public var policy: String = "NONE"
+    @objc public var burstWindow: Double = 60.0
+    @objc public var maxBurstDistance: Double = 100.0
+    @objc public var rollingWindow: Int = 10
+    @objc public var maxImpliedSpeed: Double = 514.0
+    @objc public var odometerAccuracyThreshold: Double = 100.0
+    @objc public var odometerUseKalmanFilter: Bool = true
+    @objc public var trackingAccuracyThreshold: Double = 0.0
+    @objc public var filterDebug: Bool = false
+    @objc public var useKalman: Bool = false
+    @objc public var kalmanDebug: Bool = false
+    @objc public var kalmanProfile: String = "default"
+
+    @objc public override func applyDefaults() {
+        policy = "NONE"
+        burstWindow = 60.0
+        maxBurstDistance = 100.0
+        rollingWindow = 10
+        maxImpliedSpeed = 514.0
+        odometerAccuracyThreshold = 100.0
+        odometerUseKalmanFilter = true
+        trackingAccuracyThreshold = 0.0
+        filterDebug = false
+        useKalman = false
+        kalmanDebug = false
+        kalmanProfile = "default"
+    }
+
+    @objc public func moduleKey() -> String {
+        return "filter"
+    }
+
+    @objc public override func deprecatedPropertyMappings() -> [String: String] {
+        return [:]
+    }
+
+    @objc public override func propertySpecs() -> [BGPropertySpecImpl] {
+        return [
+            BGPropertySpec(name: "policy", type: "string"),
+            BGPropertySpec(name: "burstWindow", type: "double"),
+            BGPropertySpec(name: "maxBurstDistance", type: "double"),
+            BGPropertySpec(name: "rollingWindow", type: "int"),
+            BGPropertySpec(name: "maxImpliedSpeed", type: "double"),
+            BGPropertySpec(name: "odometerAccuracyThreshold", type: "double"),
+            BGPropertySpec(name: "odometerUseKalmanFilter", type: "bool"),
+            BGPropertySpec(name: "trackingAccuracyThreshold", type: "double"),
+            BGPropertySpec(name: "filterDebug", type: "bool"),
+            BGPropertySpec(name: "useKalman", type: "bool"),
+            BGPropertySpec(name: "kalmanDebug", type: "bool"),
+            BGPropertySpec(name: "kalmanProfile", type: "string")
+        ]
+    }
+}

package/ios/engine/BGLocationHelper.swift

@@ -0,0 +1,54 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGLocationHelper: NSObject {
+
+    @objc public class func isAccurate(
+        _ location: CLLocation,
+        desiredAccuracy: CLLocationAccuracy
+    ) -> Bool {
+        guard location.horizontalAccuracy >= 0 else { return false }
+        if desiredAccuracy == kCLLocationAccuracyBest ||
+           desiredAccuracy == kCLLocationAccuracyBestForNavigation {
+            return location.horizontalAccuracy < 100
+        }
+        return location.horizontalAccuracy <= desiredAccuracy
+    }
+
+    @objc public class func locationAge(_ location: CLLocation) -> TimeInterval {
+        return Date().timeIntervalSince(location.timestamp)
+    }
+
+    @objc public class func sameTimestamp(_ a: CLLocation, as b: CLLocation) -> Bool {
+        return abs(a.timestamp.timeIntervalSince(b.timestamp)) < 0.001
+    }
+
+    @objc public class func pickBestLocation(
+        between a: CLLocation?,
+        and b: CLLocation?,
+        desiredAccuracy: CLLocationAccuracy
+    ) -> CLLocation? {
+        guard let a = a else { return b }
+        guard let b = b else { return a }
+        if a.horizontalAccuracy < 0 { return b }
+        if b.horizontalAccuracy < 0 { return a }
+        return a.horizontalAccuracy <= b.horizontalAccuracy ? a : b
+    }
+
+    @objc public class func resolveLocation(
+        withNow now: Date,
+        desiredAccuracy: CLLocationAccuracy,
+        allowStale: Bool,
+        maximumAgeSeconds: Double,
+        bestLocation: CLLocation?,
+        mostAccurateLocation: CLLocation?,
+        freshestLocation: CLLocation?
+    ) -> CLLocation? {
+        let candidates = [bestLocation, mostAccurateLocation, freshestLocation].compactMap { $0 }
+        let fresh = candidates.filter { now.timeIntervalSince($0.timestamp) <= maximumAgeSeconds }
+        if allowStale || fresh.isEmpty {
+            return candidates.min(by: { $0.horizontalAccuracy < $1.horizontalAccuracy })
+        }
+        return fresh.min(by: { $0.horizontalAccuracy < $1.horizontalAccuracy })
+    }
+}