react-native-bg-geolocation 0.2.0

package/ios/engine/BGLiveActivityManager.swift

@@ -0,0 +1,327 @@
+import Foundation
+import CoreLocation
+import UIKit
+
+#if canImport(ActivityKit)
+import ActivityKit
+#endif
+
+@objc public final class BGLiveActivityManager: NSObject {
+    private static let tokenDefaultsKey = "BGLocationManager_liveActivityPushToken"
+    private static let idDefaultsKey = "BGLocationManager_liveActivityId"
+    private static let trackingIdDefaultsKey = "BGLocationManager_liveActivityTrackingId"
+
+    @objc public static let shared = BGLiveActivityManager()
+
+    private let stateQueue = DispatchQueue(label: "BGLiveActivityManager.state")
+    private var lastUpdateAt: Date = .distantPast
+    private var locationCount = 0
+    private var pushTokenTask: Task<Void, Never>?
+    private var pendingStartIsMoving: Bool?
+    private var lastError: String?
+
+    private override init() {
+        super.init()
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(applicationDidBecomeActive),
+            name: UIApplication.didBecomeActiveNotification,
+            object: nil
+        )
+    }
+
+    @objc public var pushToken: String? {
+        UserDefaults.standard.string(forKey: Self.tokenDefaultsKey)
+    }
+
+    @objc public var activityId: String? {
+        UserDefaults.standard.string(forKey: Self.idDefaultsKey)
+    }
+
+    @objc public func startIfNeeded(isMoving: Bool) {
+        guard BGConfig.sharedInstance().app.liveActivityEnabled else { return }
+        guard UIApplication.shared.applicationState == .active else {
+            pendingStartIsMoving = isMoving
+            log("Live Activity waiting for the app to become active")
+            return
+        }
+
+        if #available(iOS 16.2, *) {
+            Task { @MainActor in
+                await self.startOrRecover(isMoving: isMoving)
+            }
+        } else {
+            lastError = "Live Activities require iOS 16.2 or later"
+            log(lastError!)
+        }
+    }
+
+    @objc private func applicationDidBecomeActive() {
+        guard let isMoving = pendingStartIsMoving else { return }
+        pendingStartIsMoving = nil
+        startIfNeeded(isMoving: isMoving)
+    }
+
+    @objc public func update(
+        location: CLLocation?,
+        isMoving: Bool,
+        activity: String,
+        force: Bool
+    ) {
+        guard BGConfig.sharedInstance().app.liveActivityEnabled else { return }
+
+        stateQueue.async {
+            let minimumInterval = max(5, BGConfig.sharedInstance().app.liveActivityUpdateInterval)
+            guard force || Date().timeIntervalSince(self.lastUpdateAt) >= minimumInterval else { return }
+            self.lastUpdateAt = Date()
+            if location != nil {
+                self.locationCount += 1
+            }
+            let count = self.locationCount
+
+            if #available(iOS 16.2, *) {
+                Task { @MainActor in
+                    await self.updateActivities(
+                        location: location,
+                        isMoving: isMoving,
+                        activity: activity,
+                        locationCount: count
+                    )
+                }
+            }
+        }
+    }
+
+    @objc public func end() {
+        pushTokenTask?.cancel()
+        pushTokenTask = nil
+
+        if #available(iOS 16.2, *) {
+            Task { @MainActor in
+                let final = self.makeState(
+                    location: BGTrackingService.sharedInstance().lastGoodLocation,
+                    isMoving: false,
+                    activity: "stopped",
+                    locationCount: self.locationCount,
+                    status: "Tracking stopped"
+                )
+                let content = ActivityContent(
+                    state: final,
+                    staleDate: nil,
+                    relevanceScore: 0
+                )
+                for activity in Activity<BGLiveTrackingAttributes>.activities {
+                    await activity.end(content, dismissalPolicy: .immediate)
+                }
+                self.clearStoredActivity()
+            }
+        } else {
+            clearStoredActivity()
+        }
+    }
+
+    @objc public func stateDictionary() -> [String: Any] {
+        let activitiesEnabled: Bool = {
+            if #available(iOS 16.2, *) {
+                return ActivityAuthorizationInfo().areActivitiesEnabled
+            }
+            return false
+        }()
+        let active: Bool = {
+            if #available(iOS 16.2, *) {
+                return !Activity<BGLiveTrackingAttributes>.activities.isEmpty
+            }
+            return false
+        }()
+        var state: [String: Any] = [
+            "supported": {
+                if #available(iOS 16.2, *) { return true }
+                return false
+            }(),
+            "enabled": BGConfig.sharedInstance().app.liveActivityEnabled,
+            "activitiesEnabled": activitiesEnabled,
+            "active": active,
+            "pushUpdates": BGConfig.sharedInstance().app.liveActivityPushUpdates
+        ]
+        if let activityId {
+            state["activityId"] = activityId
+        }
+        if let pushToken {
+            state["pushToken"] = pushToken
+        }
+        if let lastError {
+            state["error"] = lastError
+        }
+        return state
+    }
+
+    @available(iOS 16.2, *)
+    @MainActor
+    private func startOrRecover(isMoving: Bool) async {
+        guard ActivityAuthorizationInfo().areActivitiesEnabled else {
+            lastError = "Live Activities are disabled in iOS Settings"
+            log(lastError!)
+            return
+        }
+
+        if let activity = Activity<BGLiveTrackingAttributes>.activities.first {
+            lastError = nil
+            persist(activity: activity)
+            observePushToken(for: activity)
+            log("Recovered Live Activity \(activity.id)")
+            await updateActivities(
+                location: BGTrackingService.sharedInstance().lastGoodLocation,
+                isMoving: isMoving,
+                activity: BGTrackingService.sharedInstance().currentMotionActivity?.type ?? "unknown",
+                locationCount: locationCount
+            )
+            return
+        }
+
+        let config = BGConfig.sharedInstance().app
+        let trackingId = UserDefaults.standard.string(forKey: Self.trackingIdDefaultsKey)
+            ?? UUID().uuidString
+        let attributes = BGLiveTrackingAttributes(
+            trackingId: trackingId,
+            title: config.liveActivityTitle,
+            subtitle: config.liveActivitySubtitle
+        )
+        let initial = makeState(
+            location: BGTrackingService.sharedInstance().lastGoodLocation,
+            isMoving: isMoving,
+            activity: BGTrackingService.sharedInstance().currentMotionActivity?.type ?? "unknown",
+            locationCount: locationCount
+        )
+        let staleDate = Date().addingTimeInterval(max(60, config.liveActivityStaleSeconds))
+        let content = ActivityContent(state: initial, staleDate: staleDate, relevanceScore: 100)
+
+        do {
+            let pushType: PushType? = config.liveActivityPushUpdates ? .token : nil
+            let activity = try Activity.request(
+                attributes: attributes,
+                content: content,
+                pushType: pushType
+            )
+            lastError = nil
+            UserDefaults.standard.set(trackingId, forKey: Self.trackingIdDefaultsKey)
+            persist(activity: activity)
+            observePushToken(for: activity)
+            log("Started Live Activity \(activity.id), pushUpdates=\(config.liveActivityPushUpdates)")
+        } catch {
+            let firstError = error.localizedDescription
+            guard config.liveActivityPushUpdates else {
+                lastError = firstError
+                log("Unable to start Live Activity: \(firstError)")
+                return
+            }
+
+            // A push-enabled request requires the Push Notifications capability.
+            // Keep local tracking useful when the host app has not configured it.
+            do {
+                let activity = try Activity.request(
+                    attributes: attributes,
+                    content: content,
+                    pushType: nil
+                )
+                lastError = nil
+                UserDefaults.standard.set(trackingId, forKey: Self.trackingIdDefaultsKey)
+                persist(activity: activity)
+                log("Started local Live Activity after push request failed: \(firstError)")
+            } catch {
+                lastError = error.localizedDescription
+                log("Unable to start local Live Activity: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    @available(iOS 16.2, *)
+    @MainActor
+    private func updateActivities(
+        location: CLLocation?,
+        isMoving: Bool,
+        activity: String,
+        locationCount: Int
+    ) async {
+        let activities = Activity<BGLiveTrackingAttributes>.activities
+        if activities.isEmpty {
+            if UIApplication.shared.applicationState == .active {
+                await startOrRecover(isMoving: isMoving)
+            }
+            return
+        }
+
+        let state = makeState(
+            location: location,
+            isMoving: isMoving,
+            activity: activity,
+            locationCount: locationCount
+        )
+        let config = BGConfig.sharedInstance().app
+        let content = ActivityContent(
+            state: state,
+            staleDate: Date().addingTimeInterval(max(60, config.liveActivityStaleSeconds)),
+            relevanceScore: isMoving ? 100 : 70
+        )
+
+        for liveActivity in activities {
+            persist(activity: liveActivity)
+            await liveActivity.update(content)
+        }
+    }
+
+    @available(iOS 16.2, *)
+    private func makeState(
+        location: CLLocation?,
+        isMoving: Bool,
+        activity: String,
+        locationCount: Int,
+        status: String? = nil
+    ) -> BGLiveTrackingAttributes.ContentState {
+        BGLiveTrackingAttributes.ContentState(
+            status: status ?? (isMoving ? "Live tracking" : "Stationary"),
+            isMoving: isMoving,
+            activity: activity.replacingOccurrences(of: "_", with: " "),
+            latitude: location?.coordinate.latitude ?? 0,
+            longitude: location?.coordinate.longitude ?? 0,
+            accuracy: max(0, location?.horizontalAccuracy ?? 0),
+            speed: max(0, location?.speed ?? 0),
+            distance: BGOdometer.sharedInstance().getOdometer(),
+            locationCount: locationCount,
+            updatedAt: location?.timestamp ?? Date()
+        )
+    }
+
+    @available(iOS 16.2, *)
+    private func persist(activity: Activity<BGLiveTrackingAttributes>) {
+        UserDefaults.standard.set(activity.id, forKey: Self.idDefaultsKey)
+    }
+
+    @available(iOS 16.2, *)
+    private func observePushToken(for activity: Activity<BGLiveTrackingAttributes>) {
+        guard BGConfig.sharedInstance().app.liveActivityPushUpdates else { return }
+        pushTokenTask?.cancel()
+        pushTokenTask = Task {
+            for await tokenData in activity.pushTokenUpdates {
+                guard !Task.isCancelled else { return }
+                let token = tokenData.map { String(format: "%02x", $0) }.joined()
+                UserDefaults.standard.set(token, forKey: Self.tokenDefaultsKey)
+                BGLog.sharedInstance().notify("Live Activity push token: \(token)", debug: true)
+            }
+        }
+    }
+
+    private func clearStoredActivity() {
+        UserDefaults.standard.removeObject(forKey: Self.idDefaultsKey)
+        UserDefaults.standard.removeObject(forKey: Self.trackingIdDefaultsKey)
+        UserDefaults.standard.removeObject(forKey: Self.tokenDefaultsKey)
+        stateQueue.async {
+            self.locationCount = 0
+            self.lastUpdateAt = .distantPast
+        }
+    }
+
+    private func log(_ message: String) {
+        NSLog("[BGGEO][LiveActivity] \(message)")
+        BGLog.sharedInstance().notify(message, debug: true)
+    }
+}

package/ios/engine/BGLocation.swift

@@ -0,0 +1,311 @@
+import Foundation
+import CoreLocation
+import UIKit
+
+@objc public class BGLocation: NSObject {
+
+    @objc public var location: CLLocation?
+    @objc public var uuid: String = UUID().uuidString
+    @objc public var event: String = ""
+    @objc public var type: String = ""
+    @objc public var isMoving: Bool = false
+    @objc public var isSample: Bool = false
+    @objc public var isHeartbeat: Bool = false
+    @objc public var odometer: Double = 0
+    @objc public var odometerError: Double = 0
+    @objc public var mock: Bool = false
+    @objc public var extras: [String: Any]?
+    @objc public var config: AnyObject?
+    @objc public var geofence: BGGeofence?
+    @objc public var geofenceEvent: BGGeofenceEvent?
+    @objc public var rawTimestampMs: Int64 = 0
+    @objc public var rawRecordedAtMs: Int64 = 0
+
+    private var batteryLevel: Float = 0
+    private var batteryIsCharging: Bool = false
+    private var activityType: String = "unknown"
+    private var activityConfidence: Int = 0
+    private var cachedDictionary: [String: Any]?
+    private var _uptime: TimeInterval = 0
+
+    @objc public class func isValidCoordinate(_ coordinate: CLLocationCoordinate2D) -> Bool {
+        return CLLocationCoordinate2DIsValid(coordinate) &&
+               coordinate.latitude != 0 &&
+               coordinate.longitude != 0
+    }
+
+    @objc public class func uptime() -> TimeInterval {
+        return ProcessInfo.processInfo.systemUptime
+    }
+
+    @objc public override init() {
+        super.init()
+        setupDefaultValues()
+    }
+
+    @objc public init(location: CLLocation) {
+        self.location = location
+        super.init()
+        setupDefaultValues()
+        extractLocationData(location)
+    }
+
+    @objc public init(location: CLLocation, geofence: BGGeofence) {
+        self.location = location
+        self.geofence = geofence
+        super.init()
+        setupDefaultValues()
+        extractLocationData(location)
+        event = "geofence"
+    }
+
+    @objc public init(location: CLLocation, geofenceEvent: BGGeofenceEvent) {
+        self.location = location
+        self.geofenceEvent = geofenceEvent
+        super.init()
+        setupDefaultValues()
+        extractLocationData(location)
+        event = "geofence"
+    }
+
+    @objc public init(location: CLLocation, type: String, extras: [String: Any]?) {
+        self.location = location
+        self.type = type
+        self.extras = extras
+        super.init()
+        setupDefaultValues()
+        extractLocationData(location)
+    }
+
+    @objc public func setupDefaultValues() {
+        _uptime = ProcessInfo.processInfo.systemUptime
+        updateDeviceStatus()
+    }
+
+    @objc public func configureWithType(_ type: String, extras: [String: Any]?) {
+        self.type = type
+        self.extras = extras
+        invalidateCache()
+    }
+
+    @objc public func extractLocationData(_ loc: CLLocation) {
+        rawTimestampMs = Int64(loc.timestamp.timeIntervalSince1970 * 1000)
+        rawRecordedAtMs = Int64(Date().timeIntervalSince1970 * 1000)
+    }
+
+    @objc public func updateDeviceStatus() {
+        let device = UIDevice.current
+        device.isBatteryMonitoringEnabled = true
+        batteryLevel = device.batteryLevel
+        batteryIsCharging = device.batteryState == .charging || device.batteryState == .full
+    }
+
+    @objc public func updateActivityData() {
+        invalidateCache()
+    }
+
+    @objc public func invalidateCache() {
+        cachedDictionary = nil
+    }
+
+    @objc public func age() -> TimeInterval {
+        guard let loc = location else { return 0 }
+        return Date().timeIntervalSince(loc.timestamp)
+    }
+
+    @objc public func timestamp() -> Date {
+        return location?.timestamp ?? Date()
+    }
+
+    @objc public func recordedAt() -> Date {
+        if rawRecordedAtMs > 0 {
+            return Date(timeIntervalSince1970: Double(rawRecordedAtMs) / 1000.0)
+        }
+        return Date()
+    }
+
+    @objc public func isValidCoordinate(_ coord: CLLocationCoordinate2D) -> Bool {
+        return BGLocation.isValidCoordinate(coord)
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        if let cached = cachedDictionary { return cached }
+        let dict = buildDictionary()
+        cachedDictionary = dict
+        return dict
+    }
+
+    @objc public func buildDictionary() -> [String: Any] {
+        var dict: [String: Any] = [:]
+        dict["uuid"] = uuid
+        dict["event"] = event.isEmpty ? NSNull() : event
+        dict["is_moving"] = isMoving
+        dict["odometer"] = odometer
+
+        if let loc = location {
+            dict["coords"] = buildCoordinatesDictionary()
+            dict["timestamp"] = ISO8601DateFormatter().string(from: loc.timestamp)
+        }
+
+        dict["activity"] = activityDictionary()
+        dict["battery"] = batteryDictionary()
+        dict["timestamp_meta"] = timestampMetaDictionary()
+
+        if mock { dict["mock"] = true }
+        if isSample { dict["sample"] = true }
+
+        if let geofenceEvent = geofenceEvent {
+            dict["geofence"] = geofenceTemplateData()
+        }
+
+        if let extras = extras {
+            dict["extras"] = extras
+        }
+
+        return dict
+    }
+
+    @objc public func buildCoordinatesDictionary() -> [String: Any] {
+        guard let loc = location else { return [:] }
+        var coords: [String: Any] = [:]
+        coords["latitude"] = loc.coordinate.latitude
+        coords["longitude"] = loc.coordinate.longitude
+        coords["accuracy"] = loc.horizontalAccuracy
+        coords["altitude"] = loc.altitude
+        coords["altitude_accuracy"] = loc.verticalAccuracy
+        coords["heading"] = loc.course
+        coords["speed"] = loc.speed
+        if let heading = speedAccuracyNumber(loc) { coords["speed_accuracy"] = heading }
+        if let headingAccuracy = headingAccuracyNumber(loc) { coords["heading_accuracy"] = headingAccuracy }
+        if let ellipsoidal = ellipsoidalAltitudeNumber(loc) { coords["ellipsoidal_altitude"] = ellipsoidal }
+        return coords
+    }
+
+    @objc public func activityDictionary() -> [String: Any] {
+        return ["type": activityType, "confidence": activityConfidence]
+    }
+
+    @objc public func batteryDictionary() -> [String: Any] {
+        return ["level": batteryLevel, "is_charging": batteryIsCharging]
+    }
+
+    @objc public func timestampMetaDictionary() -> [String: Any] {
+        var meta: [String: Any] = [:]
+        meta["system_time"] = Date().timeIntervalSince1970 * 1000
+        meta["system_clock_elapsed"] = ProcessInfo.processInfo.systemUptime * 1000
+        if rawTimestampMs > 0 { meta["event_elapsed"] = Double(rawTimestampMs) }
+        if rawRecordedAtMs > 0 { meta["recorded_at"] = Double(rawRecordedAtMs) }
+        return meta
+    }
+
+    @objc public func timestampMetaJSONString() -> String {
+        let dict = timestampMetaDictionary()
+        guard let data = try? JSONSerialization.data(withJSONObject: dict) else { return "{}" }
+        return String(data: data, encoding: .utf8) ?? "{}"
+    }
+
+    @objc public func geofenceTemplateData() -> [String: Any] {
+        guard let event = geofenceEvent else { return [:] }
+        return event.toDictionary()
+    }
+
+    @objc public func locationTemplateData() -> [String: Any] {
+        return toDictionary()
+    }
+
+    @objc public func combinedGeofenceExtras() -> [String: Any]? {
+        var combined: [String: Any] = [:]
+        if let e = extras { combined.merge(e) { $1 } }
+        if let ge = geofenceEvent?.extras as? [String: Any] { combined.merge(ge) { $1 } }
+        return combined.isEmpty ? nil : combined
+    }
+
+    @objc public func toJson(_ error: UnsafeMutablePointer<NSError?>?) -> String? {
+        let dict = toDictionary()
+        guard let data = try? JSONSerialization.data(withJSONObject: dict) else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    @objc public func serializeClassicFormat(_ error: UnsafeMutablePointer<NSError?>?) -> Data? {
+        let dict = toDictionary()
+        return try? JSONSerialization.data(withJSONObject: dict)
+    }
+
+    @objc public func serializeJSONObject(_ error: UnsafeMutablePointer<NSError?>?) -> Data? {
+        let dict = toDictionary()
+        return try? JSONSerialization.data(withJSONObject: dict)
+    }
+
+    @objc public func renderTemplate(_ template: BGTemplate, error: UnsafeMutablePointer<NSError?>?) -> String? {
+        let data = toDictionary()
+        let rendered = template.render(with: data)
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: rendered) else { return nil }
+        return String(data: jsonData, encoding: .utf8)
+    }
+
+    @objc public func finalizeTemplateJSON(_ json: String, error: UnsafeMutablePointer<NSError?>?) -> String? {
+        return json
+    }
+
+    @objc public func handleTemplateError(_ error: Error, template: BGTemplate) {
+    }
+
+    @objc public func selectTemplate() -> BGTemplate? {
+        return nil
+    }
+
+    @objc public func templateName(forTemplate template: BGTemplate) -> String {
+        return template.name
+    }
+
+    @objc public func processLocation(_ location: CLLocation, error: UnsafeMutablePointer<NSError?>?) -> Bool {
+        self.location = location
+        extractLocationData(location)
+        invalidateCache()
+        return true
+    }
+
+    @objc public func mergeExtras(_ newExtras: [String: Any]) {
+        if extras == nil { extras = [:] }
+        extras?.merge(newExtras) { $1 }
+        invalidateCache()
+    }
+
+    @objc public func applyExtras(toDictionary dict: NSMutableDictionary) {
+        guard let extras = extras else { return }
+        dict["extras"] = extras
+    }
+
+    @objc public func applyExtras(toArray array: NSMutableArray) {
+    }
+
+    @objc public func applyExtras(toJSONObject obj: NSMutableDictionary) {
+        applyExtras(toDictionary: obj)
+    }
+
+    @objc public func errorWithCode(_ code: Int, description: String) -> NSError {
+        return NSError(domain: "BGLocation", code: code, userInfo: [NSLocalizedDescriptionKey: description])
+    }
+
+    @objc public func roundValue(_ value: Double) -> Double {
+        return (value * 10000).rounded() / 10000
+    }
+
+    func speedAccuracyNumber(_ loc: CLLocation) -> Double? {
+        if #available(iOS 13.4, *) {
+            return loc.speedAccuracy >= 0 ? loc.speedAccuracy : nil
+        }
+        return nil
+    }
+
+    func headingAccuracyNumber(_ loc: CLLocation) -> Double? {
+        return loc.courseAccuracy >= 0 ? loc.courseAccuracy : nil
+    }
+
+    func ellipsoidalAltitudeNumber(_ loc: CLLocation) -> Double? {
+        if #available(iOS 15.0, *) {
+            return loc.ellipsoidalAltitude
+        }
+        return nil
+    }
+}