react-native-bg-geolocation 0.2.0

package/ios/engine/BGLocationAuthorization.swift

@@ -0,0 +1,427 @@
+import Foundation
+import CoreLocation
+import UIKit
+
+@objc public protocol BGLocationAuthorizationDelegate: NSObjectProtocol {
+    @objc optional func locationAuthorization(_ authorization: BGLocationAuthorization, didChangeAuthorizationStatus status: CLAuthorizationStatus)
+    @objc optional func locationAuthorization(_ authorization: BGLocationAuthorization, didCompleteWith status: CLAuthorizationStatus, error: Error?)
+}
+
+@objc public class BGLocationAuthorization: NSObject, CLLocationManagerDelegate {
+
+    private static var _sharedInstance: BGLocationAuthorization?
+    private static let instanceLock = NSLock()
+
+    @objc public class func sharedInstance() -> BGLocationAuthorization {
+        instanceLock.lock()
+        defer { instanceLock.unlock() }
+        if _sharedInstance == nil { _sharedInstance = BGLocationAuthorization() }
+        return _sharedInstance!
+    }
+
+    @objc public class func configureShared(withLocationManager manager: CLLocationManager) {
+        sharedInstance().locationManager = manager
+        // The CLLocationManager delegate is owned by BGCLRouter, which forwards
+        // authorization callbacks here. Do NOT assign manager.delegate.
+    }
+
+    // MARK: - State
+
+    @objc public var locationManager: CLLocationManager?
+    @objc public weak var delegate: BGLocationAuthorizationDelegate?
+    @objc public var enabled: Bool = true
+    @objc public var automaticPromptEnabled: Bool = true
+    @objc public var authorizationStatus: CLAuthorizationStatus = .notDetermined
+    @objc public var accuracyAuthorization: Int = 0
+    @objc public var desiredPolicy: String = "Always"
+    @objc public var pendingPolicy: String = ""
+    @objc public var hasPendingPolicy: Bool = false
+    @objc public var state: String = "idle"
+    @objc public var authorizationState: String = "not_determined"
+    @objc public var authorizationTimeoutInterval: TimeInterval = 20.0
+    @objc public var currentAlert: UIAlertController?
+    public var pendingCompletion: ((CLAuthorizationStatus, Error?) -> Void)?
+    public var pendingCompletions: [((CLAuthorizationStatus, Error?) -> Void)] = []
+    @objc public var timeoutTimer: Timer?
+
+    @objc public override init() {
+        super.init()
+        authorizationStatus = CLLocationManager.authorizationStatus()
+        authorizationState = stateForAuthorizationStatus(authorizationStatus)
+        registerForApplicationNotifications()
+    }
+
+    @objc public init(locationManager: CLLocationManager) {
+        self.locationManager = locationManager
+        super.init()
+        authorizationStatus = CLLocationManager.authorizationStatus()
+        authorizationState = stateForAuthorizationStatus(authorizationStatus)
+        // Do NOT assign locationManager.delegate here — the single delegate is
+        // owned by BGCLRouter. Assigning it would silently steal callbacks and
+        // re-introduce the multi-delegate bug. (This initializer is unused; the
+        // delegate line is removed to keep the invariant un-violatable.)
+        registerForApplicationNotifications()
+    }
+
+    @objc public func registerForApplicationNotifications() {
+        NotificationCenter.default.addObserver(self, selector: #selector(applicationDidBecomeActive), name: UIApplication.didBecomeActiveNotification, object: nil)
+    }
+
+    // MARK: - Authorization checks
+
+    @objc public func isAuthorized() -> Bool {
+        return authorizationStatus == .authorizedAlways || authorizationStatus == .authorizedWhenInUse
+    }
+
+    @objc public func isAuthorizedAlways() -> Bool {
+        return authorizationStatus == .authorizedAlways
+    }
+
+    @objc public func isAuthorizedForPolicy(_ policy: String) -> Bool {
+        if policy == "Always" {
+            return authorizationStatus == .authorizedAlways
+        }
+        return isAuthorized()
+    }
+
+    @objc public func isAuthorizedForDesiredLocationRequest() -> Bool {
+        return isAuthorizedForPolicy(desiredPolicy)
+    }
+
+    @objc public func isRequestInProgress() -> Bool {
+        return state != "idle"
+    }
+
+    @objc public func canRequestAlwaysUpgrade() -> Bool {
+        return authorizationStatus == .authorizedWhenInUse
+    }
+
+    @objc public func shouldAttemptAlwaysUpgrade() -> Bool {
+        return canRequestAlwaysUpgrade() && desiredPolicy == "Always"
+    }
+
+    @objc public func effectivePolicy() -> String {
+        return desiredPolicy
+    }
+
+    @objc public func updateDesiredPolicyFromConfig() {
+        let config = BGConfig.sharedInstance()
+        desiredPolicy = config.geolocation.locationAuthorizationRequest
+    }
+
+    // MARK: - Authorization flow
+
+    @objc public func requestAuthorization(_ completion: ((CLAuthorizationStatus, Error?) -> Void)?) {
+        updateDesiredPolicyFromConfig()
+        requestAuthorizationForPolicy(desiredPolicy, completion: completion)
+    }
+
+    @objc public func requestAuthorizationForPolicy(_ policy: String, completion: ((CLAuthorizationStatus, Error?) -> Void)?) {
+        desiredPolicy = policy
+        authorizationStatus = locationManager?.authorizationStatus ?? CLLocationManager.authorizationStatus()
+
+        guard enabled else {
+            completion?(authorizationStatus, nil)
+            return
+        }
+
+        guard locationManager != nil else {
+            completion?(
+                authorizationStatus,
+                NSError(
+                    domain: "BGLocationAuthorization",
+                    code: -2,
+                    userInfo: [NSLocalizedDescriptionKey: "CLLocationManager is not ready"]
+                )
+            )
+            return
+        }
+
+        if isAuthorizedForPolicy(policy) {
+            completion?(authorizationStatus, nil)
+            return
+        }
+
+        if let c = completion { pendingCompletions.append(c) }
+        pendingPolicy = policy
+
+        beginAuthorizationFlow()
+    }
+
+    @objc public func requestLocationAuthorization(_ policy: String) {
+        requestLocationAuthorization(policy, onCancel: nil)
+    }
+
+    @objc public func requestLocationAuthorization(_ policy: String, onCancel: (() -> Void)?) {
+        requestAuthorizationForPolicy(policy) { status, error in
+            if status == .denied {
+                onCancel?()
+            }
+        }
+    }
+
+    @objc public func beginAuthorizationFlow() {
+        guard state == "idle" else { return }
+        transitionToState("requesting")
+        startTimeoutTimer()
+
+        if authorizationStatus == .notDetermined {
+            requestInitialAuthorization()
+        } else if shouldAttemptAlwaysUpgrade() {
+            requestAlwaysUpgrade()
+        } else if authorizationStatus == .denied || authorizationStatus == .restricted {
+            completeAuthorizationRequest(authorizationStatus, error: nil)
+        } else {
+            completeAuthorizationRequest(authorizationStatus, error: nil)
+        }
+    }
+
+    @objc public func requestInitialAuthorization() {
+        guard let mgr = locationManager else {
+            completeAuthorizationRequest(
+                authorizationStatus,
+                error: NSError(
+                    domain: "BGLocationAuthorization",
+                    code: -2,
+                    userInfo: [NSLocalizedDescriptionKey: "CLLocationManager is not ready"]
+                )
+            )
+            return
+        }
+        DispatchQueue.main.async {
+            // iOS uses a two-stage flow for background location. The first
+            // system sheet grants foreground access; a later request upgrades
+            // that authorization to Always.
+            mgr.requestWhenInUseAuthorization()
+        }
+    }
+
+    @objc public func requestAlwaysUpgrade() {
+        guard let mgr = locationManager else {
+            completeAuthorizationRequest(
+                authorizationStatus,
+                error: NSError(
+                    domain: "BGLocationAuthorization",
+                    code: -2,
+                    userInfo: [NSLocalizedDescriptionKey: "CLLocationManager is not ready"]
+                )
+            )
+            return
+        }
+        DispatchQueue.main.async {
+            mgr.requestAlwaysAuthorization()
+        }
+    }
+
+    @objc public func requestTemporaryFullAccuracy(_ purposeKey: String, completion: ((Error?) -> Void)?) {
+        if #available(iOS 14.0, *) {
+            locationManager?.requestTemporaryFullAccuracyAuthorization(withPurposeKey: purposeKey) { error in
+                completion?(error)
+            }
+        } else {
+            completion?(nil)
+        }
+    }
+
+    @objc public func requestTemporaryFullAccuracy(_ purposeKey: String, success: (() -> Void)?, failure: ((Error) -> Void)?) {
+        requestTemporaryFullAccuracy(purposeKey) { error in
+            if let error = error { failure?(error) } else { success?() }
+        }
+    }
+
+    // MARK: - Alert presentation
+
+    @objc public func showSettingsAlert() {
+        dismissCurrentAlert()
+        let strings = BGConfig.sharedInstance().getLocationAuthorizationAlertStrings()
+        let alert = UIAlertController(
+            title: strings["title"] as? String ?? "Background Location Access",
+            message: strings["message"] as? String ?? "This app requires location access to operate correctly.",
+            preferredStyle: .alert
+        )
+        alert.addAction(UIAlertAction(title: strings["cancel"] as? String ?? "Cancel", style: .cancel) { [weak self] _ in
+            self?.handleAlertCancelled()
+        })
+        alert.addAction(UIAlertAction(title: strings["settings"] as? String ?? "Settings", style: .default) { [weak self] _ in
+            self?.openSettings()
+        })
+        currentAlert = alert
+        presentSettingsAlert()
+    }
+
+    @objc public func presentSettingsAlert() {
+        guard let alert = currentAlert else { return }
+        DispatchQueue.main.async {
+            guard let topVC = BGAppState.sharedInstance().topPresenter() else { return }
+            topVC.present(alert, animated: true)
+        }
+    }
+
+    @objc public func dismissCurrentAlert() {
+        DispatchQueue.main.async {
+            self.currentAlert?.dismiss(animated: false)
+            self.currentAlert = nil
+        }
+    }
+
+    @objc public func openSettings() {
+        guard let url = URL(string: UIApplication.openSettingsURLString) else { return }
+        UIApplication.shared.open(url)
+    }
+
+    @objc public func hide() {
+        dismissCurrentAlert()
+    }
+
+    // MARK: - Completion
+
+    @objc public func completeAuthorizationRequest(_ status: CLAuthorizationStatus, error: Error?) {
+        cancelTimeoutTimer()
+        transitionToState("idle")
+        let completions = pendingCompletions
+        pendingCompletions.removeAll()
+        pendingCompletion = nil
+        for c in completions { c(status, error) }
+        delegate?.locationAuthorization?(self, didCompleteWith: status, error: error)
+    }
+
+    @objc public func cancelAuthorizationRequest() {
+        completeAuthorizationRequest(authorizationStatus, error: NSError(domain: "BGLocationAuthorization", code: -1, userInfo: [NSLocalizedDescriptionKey: "Cancelled"]))
+    }
+
+    // MARK: - State machine
+
+    @objc public func transitionToState(_ newState: String) {
+        state = newState
+    }
+
+    @objc public func stateForAuthorizationStatus(_ status: CLAuthorizationStatus) -> String {
+        switch status {
+        case .authorizedAlways: return "authorized_always"
+        case .authorizedWhenInUse: return "authorized_when_in_use"
+        case .denied: return "denied"
+        case .restricted: return "restricted"
+        case .notDetermined: return "not_determined"
+        @unknown default: return "unknown"
+        }
+    }
+
+    @objc public func stringForPolicy(_ policy: String) -> String {
+        return policy
+    }
+
+    @objc public func stringForState(_ state: String) -> String {
+        return state
+    }
+
+    // MARK: - Timeout
+
+    @objc public func startTimeoutTimer() {
+        cancelTimeoutTimer()
+        DispatchQueue.main.async {
+            self.timeoutTimer = Timer.scheduledTimer(withTimeInterval: self.authorizationTimeoutInterval, repeats: false) { [weak self] _ in
+                self?.handleTimeout()
+            }
+        }
+    }
+
+    @objc public func cancelTimeoutTimer() {
+        timeoutTimer?.invalidate()
+        timeoutTimer = nil
+    }
+
+    @objc public func handleTimeout() {
+        // Complete with the CURRENT status and NO error. A slow user (or the
+        // deferred iOS Always prompt) must not produce a spurious rejection in
+        // JS — requestPermission inspects the returned status, not an error.
+        completeAuthorizationRequest(authorizationStatus, error: nil)
+    }
+
+    // MARK: - Handlers
+
+    @objc public func handleAlertCancelled() {
+        completeAuthorizationRequest(authorizationStatus, error: nil)
+    }
+
+    @objc public func handleAlwaysGranted() {
+        completeAuthorizationRequest(.authorizedAlways, error: nil)
+    }
+
+    @objc public func handleWhenInUseGranted() {
+        completeAuthorizationRequest(.authorizedWhenInUse, error: nil)
+    }
+
+    @objc public func handleAuthorizationDenied() {
+        dismissCurrentAlert()
+        completeAuthorizationRequest(.denied, error: nil)
+    }
+
+    @objc public func onAuthorizationStatusChanged(_ status: CLAuthorizationStatus) {
+        authorizationStatus = status
+        updateAuthorizationState()
+        checkAuthorizationStatusForPolicyChange()
+        delegate?.locationAuthorization?(self, didChangeAuthorizationStatus: status)
+    }
+
+    @objc public func updateAuthorizationState() {
+        // Keep permission status separate from the request lifecycle in `state`.
+        // Mixing the two caused the initial `.notDetermined` callback to replace
+        // `idle`, so beginAuthorizationFlow() silently returned without showing
+        // the system permission sheet.
+        authorizationState = stateForAuthorizationStatus(authorizationStatus)
+    }
+
+    @objc public func checkAuthorizationStatusForPolicyChange() {
+        guard isRequestInProgress() || state == "requesting" else { return }
+        switch authorizationStatus {
+        case .authorizedAlways:
+            handleAlwaysGranted()
+        case .authorizedWhenInUse:
+            // iOS grants When-In-Use first even when Always was requested; the
+            // actual "Always" upgrade prompt is deferred to a later background
+            // transition, so NO further callback arrives this session. Resolve
+            // the request now with the real (provisional) status instead of
+            // hanging until the 20s timeout — which used to surface to JS as a
+            // rejection even though the user just granted access. The caller can
+            // re-request to trigger the Always upgrade.
+            handleWhenInUseGranted()
+        case .denied, .restricted:
+            handleAuthorizationDenied()
+        default:
+            break
+        }
+    }
+
+    @objc public func onDidBecomeActive() {
+        if state == "requesting" && authorizationStatus != .notDetermined {
+            checkAuthorizationStatusForPolicyChange()
+        }
+    }
+
+    @objc public func cleanup() {
+        cancelTimeoutTimer()
+        dismissCurrentAlert()
+    }
+
+    // MARK: - Notifications
+
+    @objc func applicationDidBecomeActive() {
+        onDidBecomeActive()
+    }
+
+    // MARK: - CLLocationManagerDelegate
+
+    @objc public func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
+        onAuthorizationStatusChanged(status)
+    }
+
+    @available(iOS 14.0, *)
+    @objc public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        let status = manager.authorizationStatus
+        onAuthorizationStatusChanged(status)
+        if #available(iOS 14.0, *) {
+            let acc = manager.accuracyAuthorization
+            accuracyAuthorization = acc == .fullAccuracy ? 1 : 0
+        }
+    }
+}

package/ios/engine/BGLocationDAO.swift

@@ -0,0 +1,252 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGLocationDAO: NSObject {
+
+    private static var _sharedInstance: BGLocationDAO?
+    private static let lock = NSLock()
+
+    private var dbQueue: BGDatabaseQueue?
+    private let accessQueue = DispatchQueue(label: "BGLocationDAO.access")
+
+    @objc public class func sharedInstance() -> BGLocationDAO {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGLocationDAO()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+        setupDatabase()
+        registerConfigChangeHandlers()
+    }
+
+    private func setupDatabase() {
+        let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
+        guard let docPath = paths.first else { return }
+        let dbPath = docPath.appendingPathComponent("BGLocationManager.db")
+        dbQueue = BGDatabaseQueue(path: dbPath.path)
+        dbQueue?.inDatabase { db in
+            _ = db.executeUpdate("""
+                CREATE TABLE IF NOT EXISTS locations (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    uuid TEXT UNIQUE NOT NULL,
+                    timestamp REAL NOT NULL,
+                    latitude REAL NOT NULL,
+                    longitude REAL NOT NULL,
+                    accuracy REAL,
+                    altitude REAL,
+                    speed REAL,
+                    heading REAL,
+                    odometer REAL,
+                    is_moving INTEGER,
+                    event TEXT,
+                    activity_type TEXT,
+                    activity_confidence INTEGER,
+                    battery_level REAL,
+                    battery_is_charging INTEGER,
+                    extras TEXT,
+                    json TEXT NOT NULL,
+                    locked INTEGER DEFAULT 0
+                )
+            """)
+            _ = db.executeUpdate("CREATE INDEX IF NOT EXISTS locations_timestamp ON locations (timestamp)")
+            _ = db.executeUpdate("CREATE INDEX IF NOT EXISTS locations_uuid ON locations (uuid)")
+        }
+    }
+
+    @objc public func registerConfigChangeHandlers() {
+    }
+
+    @objc public func create(_ location: BGLocation, error: UnsafeMutablePointer<NSError?>?) -> Bool {
+        guard let json = location.toJson(nil) else { return false }
+        let dict = location.toDictionary()
+        let coords = dict["coords"] as? [String: Any] ?? [:]
+        var result = false
+
+        dbQueue?.inDatabase { db in
+            let extras = location.extras.flatMap { try? JSONSerialization.data(withJSONObject: $0) }.flatMap { String(data: $0, encoding: .utf8) }
+            result = db.executeUpdate(
+                """
+                INSERT OR IGNORE INTO locations
+                    (uuid, timestamp, latitude, longitude, accuracy, altitude, speed, heading,
+                     odometer, is_moving, event, activity_type, battery_level, battery_is_charging, extras, json)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                withArgumentsInArray: [
+                    location.uuid,
+                    location.timestamp().timeIntervalSince1970,
+                    coords["latitude"] ?? 0,
+                    coords["longitude"] ?? 0,
+                    coords["accuracy"] ?? 0,
+                    coords["altitude"] ?? 0,
+                    coords["speed"] ?? 0,
+                    coords["heading"] ?? 0,
+                    location.odometer,
+                    location.isMoving ? 1 : 0,
+                    location.event,
+                    (dict["activity"] as? [String: Any])?["type"] ?? "",
+                    (dict["battery"] as? [String: Any])?["level"] ?? 0,
+                    (dict["battery"] as? [String: Any])?["is_charging"] ?? false,
+                    extras as Any,
+                    json
+                ]
+            )
+        }
+        return result
+    }
+
+    @objc public func all() -> [[String: Any]] {
+        return allWithLocking(false)
+    }
+
+    @objc public func allWithLocking(_ locking: Bool) -> [[String: Any]] {
+        var results: [[String: Any]] = []
+        dbQueue?.inDatabase { db in
+            let sql = locking ? "SELECT * FROM locations ORDER BY timestamp ASC" : "SELECT * FROM locations WHERE locked = 0 ORDER BY timestamp ASC"
+            guard let rs = db.executeQuery(sql) else { return }
+            defer { rs.close() }
+            while rs.next() {
+                if let json = rs.string(forColumn: "json"),
+                   let data = json.data(using: .utf8),
+                   let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                    results.append(dict)
+                }
+            }
+        }
+        return results
+    }
+
+    @objc public func first() -> [String: Any]? {
+        var result: [String: Any]?
+        dbQueue?.inDatabase { db in
+            guard let rs = db.executeQuery("SELECT * FROM locations WHERE locked = 0 ORDER BY timestamp ASC LIMIT 1") else { return }
+            defer { rs.close() }
+            if rs.next(), let json = rs.string(forColumn: "json"),
+               let data = json.data(using: .utf8),
+               let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                result = dict
+            }
+        }
+        return result
+    }
+
+    @objc public func getCount() -> Int {
+        var count = 0
+        dbQueue?.inDatabase { db in
+            guard let rs = db.executeQuery("SELECT COUNT(*) FROM locations") else { return }
+            defer { rs.close() }
+            if rs.next() { count = Int(rs.int(forColumn: 0)) }
+        }
+        return count
+    }
+
+    @objc public func destroy(_ uuid: String) -> Bool {
+        var result = false
+        dbQueue?.inDatabase { db in
+            result = db.executeUpdate("DELETE FROM locations WHERE uuid = ?", withArgumentsInArray: [uuid])
+        }
+        return result
+    }
+
+    @objc public func destroyByUuid(_ uuid: String) -> Bool {
+        return destroy(uuid)
+    }
+
+    @objc public func destroyAll(_ uuids: [String]) -> Bool {
+        var result = false
+        dbQueue?.inDatabase { db in
+            let placeholders = uuids.map { _ in "?" }.joined(separator: ", ")
+            result = db.executeUpdate("DELETE FROM locations WHERE uuid IN (\(placeholders))", withArgumentsInArray: uuids)
+        }
+        return result
+    }
+
+    @objc public func clear() {
+        dbQueue?.inDatabase { db in
+            _ = db.executeUpdate("DELETE FROM locations")
+        }
+    }
+
+    @objc public func unlock(_ uuid: String) -> Bool {
+        var result = false
+        dbQueue?.inDatabase { db in
+            result = db.executeUpdate("UPDATE locations SET locked = 0 WHERE uuid = ?", withArgumentsInArray: [uuid])
+        }
+        return result
+    }
+
+    @objc public func unlockAll(_ uuids: [String]) -> Bool {
+        var result = false
+        dbQueue?.inDatabase { db in
+            let placeholders = uuids.map { _ in "?" }.joined(separator: ", ")
+            result = db.executeUpdate("UPDATE locations SET locked = 0 WHERE uuid IN (\(placeholders))", withArgumentsInArray: uuids)
+        }
+        return result
+    }
+
+    @objc public func unlock() -> Bool {
+        var result = false
+        dbQueue?.inDatabase { db in
+            result = db.executeUpdate("UPDATE locations SET locked = 0")
+        }
+        return result
+    }
+
+    @objc public func purge(_ query: SQLQuery) -> Bool {
+        var result = false
+        dbQueue?.inDatabase { db in
+            result = db.executeUpdate("DELETE FROM locations", withArgumentsInArray: [])
+        }
+        return result
+    }
+
+    @objc public func shrink(_ count: Int, db: BGDatabase) {
+        let current = getCount()
+        if current > count {
+            let excess = current - count
+            _ = db.executeUpdate("DELETE FROM locations WHERE id IN (SELECT id FROM locations ORDER BY timestamp ASC LIMIT ?)", withArgumentsInArray: [excess])
+        }
+    }
+
+    @objc public func inflate(_ dict: [String: Any]) -> BGLocation {
+        let location = BGLocation()
+        if let uuid = dict["uuid"] as? String { location.uuid = uuid }
+        if let event = dict["event"] as? String { location.event = event }
+        if let isMoving = dict["is_moving"] as? Bool { location.isMoving = isMoving }
+        if let odometer = dict["odometer"] as? Double { location.odometer = odometer }
+        if let extras = dict["extras"] as? [String: Any] { location.extras = extras }
+        if let coords = dict["coords"] as? [String: Any] {
+            let lat = coords["latitude"] as? Double ?? 0
+            let lng = coords["longitude"] as? Double ?? 0
+            let accuracy = coords["accuracy"] as? Double ?? 0
+            let altitude = coords["altitude"] as? Double ?? 0
+            let speed = coords["speed"] as? Double ?? -1
+            let heading = coords["heading"] as? Double ?? -1
+            var timestamp = Date()
+            if let ts = dict["timestamp"] as? String {
+                let fmt = ISO8601DateFormatter()
+                timestamp = fmt.date(from: ts) ?? Date()
+            }
+            let coord = CLLocationCoordinate2D(latitude: lat, longitude: lng)
+            let loc = CLLocation(coordinate: coord, altitude: altitude, horizontalAccuracy: accuracy, verticalAccuracy: -1, course: heading, speed: speed, timestamp: timestamp)
+            location.location = loc
+        }
+        return location
+    }
+
+    @objc public func decodeJSON(_ json: String) -> [String: Any]? {
+        guard let data = json.data(using: .utf8) else { return nil }
+        return try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+    }
+
+    @objc public func migrate(_ db: BGDatabase) {
+    }
+
+    @objc public func hydrate(_ query: SQLQuery) -> [[String: Any]] {
+        return all()
+    }
+}