react-native-bg-geolocation 0.2.0

package/ios/engine/BGBackgroundTaskManager.swift

@@ -0,0 +1,143 @@
+import Foundation
+import UIKit
+import CoreLocation
+
+@objc public class BGBackgroundTaskManager: NSObject, CLLocationManagerDelegate {
+
+    private static var _sharedInstance: BGBackgroundTaskManager?
+    private static let lock = NSLock()
+
+    public var backgroundTasks: [UIBackgroundTaskIdentifier] = []
+    public var preventSuspendTasks: [UIBackgroundTaskIdentifier] = []
+    @objc public var locationManager: CLLocationManager?
+    @objc public var preventSuspendTimer: Timer?
+    @objc public var acquisitionBufferTimer: Timer?
+
+    @objc public class func sharedInstance() -> BGBackgroundTaskManager {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGBackgroundTaskManager()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+        stopPreventSuspendTimer()
+    }
+
+    @objc public func acquireBackgroundTime() {
+        let task = UIApplication.shared.beginBackgroundTask(expirationHandler: { [weak self] in
+            self?.stopKeepAlive()
+        })
+        if task != .invalid {
+            backgroundTasks.append(task)
+        }
+    }
+
+    @objc public func createBackgroundTask() -> UIBackgroundTaskIdentifier {
+        return UIApplication.shared.beginBackgroundTask(expirationHandler: nil)
+    }
+
+    @objc public func stopBackgroundTask(_ task: UIBackgroundTaskIdentifier) {
+        UIApplication.shared.endBackgroundTask(task)
+        backgroundTasks.removeAll { $0 == task }
+    }
+
+    @objc public func startKeepAlive() {
+        acquireBackgroundTime()
+    }
+
+    @objc public func stopKeepAlive() {
+        for task in backgroundTasks {
+            UIApplication.shared.endBackgroundTask(task)
+        }
+        backgroundTasks.removeAll()
+    }
+
+    @objc public func startPreventSuspend(_ task: UIBackgroundTaskIdentifier) {
+        // Begin a REAL UIBackgroundTask so a backgrounded app gets an extended
+        // (~30s) execution window. Previously this just appended the passed
+        // identifier (always .invalid) and did nothing. The passed argument is
+        // ignored. Note: true stationary/kill-state longevity comes from SLC +
+        // region wake, not from background tasks — this only bridges short gaps
+        // (e.g. so a heartbeat tick can complete an HTTP flush).
+        DispatchQueue.main.async {
+            let id = UIApplication.shared.beginBackgroundTask(withName: "BGPreventSuspend") { [weak self] in
+                self?.stopAllPreventSuspend()
+            }
+            if id != .invalid {
+                self.preventSuspendTasks.append(id)
+            }
+        }
+    }
+
+    @objc public func renewPreventSuspend() {
+        // Relay pattern: take a fresh task BEFORE ending the previous ones so the
+        // execution window rolls forward without a gap. Driven from the heartbeat.
+        DispatchQueue.main.async {
+            let previous = self.preventSuspendTasks
+            let id = UIApplication.shared.beginBackgroundTask(withName: "BGPreventSuspend") { [weak self] in
+                self?.stopAllPreventSuspend()
+            }
+            if id != .invalid {
+                self.preventSuspendTasks.append(id)
+            }
+            for t in previous {
+                UIApplication.shared.endBackgroundTask(t)
+                self.preventSuspendTasks.removeAll { $0 == t }
+            }
+        }
+    }
+
+    @objc public func stopAllPreventSuspend() {
+        DispatchQueue.main.async {
+            for t in self.preventSuspendTasks {
+                UIApplication.shared.endBackgroundTask(t)
+            }
+            self.preventSuspendTasks.removeAll()
+        }
+    }
+
+    @objc public func stopPreventSuspend(_ task: UIBackgroundTaskIdentifier) {
+        // The argument is historically meaningless (.invalid); end every
+        // prevent-suspend task we actually hold.
+        stopAllPreventSuspend()
+    }
+
+    @objc public func startPreventSuspendTimer(_ interval: TimeInterval) {
+        stopPreventSuspendTimer()
+        preventSuspendTimer = Timer.scheduledTimer(timeInterval: interval,
+                                                   target: self,
+                                                   selector: #selector(onPreventSuspendTimer),
+                                                   userInfo: nil,
+                                                   repeats: true)
+    }
+
+    @objc public func stopPreventSuspendTimer() {
+        preventSuspendTimer?.invalidate()
+        preventSuspendTimer = nil
+    }
+
+    @objc public func onPreventSuspendTimer() {
+        pleaseStayAwake()
+    }
+
+    @objc public func pleaseStayAwake() {
+    }
+
+    @objc public func onResume(_ notification: Notification) {
+    }
+
+    @objc public func onSuspend(_ notification: Notification) {
+    }
+
+    @objc public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {}
+    @objc public func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {}
+    @objc public func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {}
+}

package/ios/engine/BGCLRouter.swift

@@ -0,0 +1,101 @@
+import Foundation
+import CoreLocation
+
+/// Single delegate for the one shared `CLLocationManager`.
+///
+/// A `CLLocationManager` has exactly ONE `delegate`. Previously
+/// `BGTrackingService`, `BGGeofenceManager`, `BGLocationRequestService` and
+/// `BGLocationAuthorization` each assigned `manager.delegate = self`, so whoever
+/// ran last silently stole every callback from the others (e.g. starting
+/// geofences right after tracking killed all `onLocation`/persist events, and
+/// the auth callbacks never reached `BGLocationAuthorization`, so
+/// `requestPermission` only resolved on its 20s timeout).
+///
+/// Routing every callback through this one object lets all four services
+/// participate again. Each downstream handler already self-filters (region
+/// handlers guard by identifier prefix), so fan-out is safe.
+@objc public class BGCLRouter: NSObject, CLLocationManagerDelegate {
+
+    private static var _sharedInstance: BGCLRouter?
+    private static let instanceLock = NSLock()
+
+    @objc public class func sharedInstance() -> BGCLRouter {
+        instanceLock.lock()
+        defer { instanceLock.unlock() }
+        if _sharedInstance == nil { _sharedInstance = BGCLRouter() }
+        return _sharedInstance!
+    }
+
+    private var tracking: BGTrackingService { BGTrackingService.sharedInstance() }
+    private var geofences: BGGeofenceManager { BGGeofenceManager.sharedInstance() }
+    private var requests: BGLocationRequestService { BGLocationRequestService.sharedInstance() }
+    private var authorization: BGLocationAuthorization { BGLocationAuthorization.sharedInstance() }
+
+    // MARK: - Location updates
+
+    @objc public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        // Always feed the request service: it owns getCurrentPosition sampling
+        // and watchPosition streams (no-ops when neither is active).
+        requests.locationManager(manager, didUpdateLocations: locations)
+
+        // Tracking owns persist + the `location` event; it also forwards each
+        // fix to BGGeofenceManager.setLocation internally. Only when tracking is
+        // disabled do we feed geofences directly (geofences-only mode).
+        if tracking.isEnabled {
+            tracking.locationManager(manager, didUpdateLocations: locations)
+        } else if geofences.enabled {
+            geofences.locationManager(manager, didUpdateLocations: locations)
+        }
+    }
+
+    @objc public func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        requests.locationManager(manager, didFailWithError: error)
+        if tracking.isEnabled {
+            tracking.locationManager(manager, didFailWithError: error)
+        }
+    }
+
+    // MARK: - Authorization
+
+    @available(iOS 14.0, *)
+    @objc public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        // Primary path on iOS 14+. Resolves any in-flight requestPermission().
+        authorization.locationManagerDidChangeAuthorization(manager)
+    }
+
+    // Legacy path (< iOS 14). On iOS 14+ this is not called.
+    @objc public func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
+        authorization.locationManager(manager, didChangeAuthorization: status)
+    }
+
+    // MARK: - Region monitoring (handlers self-filter by identifier)
+
+    @objc public func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
+        geofences.locationManager(manager, didEnterRegion: region)
+    }
+
+    @objc public func locationManager(_ manager: CLLocationManager, didExitRegion region: CLRegion) {
+        // "BGStationary" -> tracking (start-detection); "BGGeofence:" -> geofences.
+        tracking.locationManager(manager, didExitRegion: region)
+        geofences.locationManager(manager, didExitRegion: region)
+    }
+
+    @objc public func locationManager(_ manager: CLLocationManager, didStartMonitoringFor region: CLRegion) {
+        geofences.locationManager(manager, didStartMonitoringFor: region)
+    }
+
+    @objc public func locationManager(_ manager: CLLocationManager, monitoringDidFailFor region: CLRegion?, withError error: Error) {
+        tracking.locationManager(manager, monitoringDidFailFor: region, withError: error)
+        geofences.locationManager(manager, monitoringDidFailFor: region, withError: error)
+    }
+
+    // MARK: - Pause / resume
+
+    @objc public func locationManagerDidPauseLocationUpdates(_ manager: CLLocationManager) {
+        tracking.locationManagerDidPauseLocationUpdates(manager)
+    }
+
+    @objc public func locationManagerDidResumeLocationUpdates(_ manager: CLLocationManager) {
+        tracking.locationManagerDidResumeLocationUpdates(manager)
+    }
+}

package/ios/engine/BGCallback.swift

@@ -0,0 +1,19 @@
+import Foundation
+
+@objc public final class BGCallback: NSObject {
+
+    @objc public var success: Any?
+    @objc public var failure: Any?
+    @objc public private(set) var options: Any?
+
+    @objc public init(success: Any?, failure: Any?) {
+        self.success = success
+        self.failure = failure
+        super.init()
+    }
+
+    @objc public convenience init(success: Any?, failure: Any?, options: Any?) {
+        self.init(success: success, failure: failure)
+        self.options = options
+    }
+}

package/ios/engine/BGConfig.swift

@@ -0,0 +1,440 @@
+import Foundation
+
+@objc public class BGConfig: NSObject, NSCoding {
+
+    private static var _sharedInstance: BGConfig?
+    private static let instanceLock = NSLock()
+    private static let storageKey = "BGLocationManager_config"
+
+    // MARK: - Singleton
+
+    @objc public class func sharedInstance() -> BGConfig {
+        instanceLock.lock()
+        defer { instanceLock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGConfig.decode() ?? BGConfig()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public class func decode(config dict: [String: Any]) -> BGConfig {
+        let config = BGConfig()
+        config.updateWithDictionary(dict)
+        return config
+    }
+
+    @objc public class func uptime() -> TimeInterval {
+        return ProcessInfo.processInfo.systemUptime
+    }
+
+    @objc public class func userDefaults() -> UserDefaults {
+        return UserDefaults.standard
+    }
+
+    // MARK: - Sub-modules
+
+    @objc public lazy var geolocation: BGGeolocationConfig = BGGeolocationConfig()
+    @objc public lazy var http: BGHttpConfig = BGHttpConfig()
+    @objc public lazy var logger: BGLoggerConfig = BGLoggerConfig()
+    @objc public lazy var app: BGAppConfig = BGAppConfig()
+    @objc public lazy var authorization: BGAuthorizationConfig = BGAuthorizationConfig()
+    @objc public lazy var persistence: BGPersistenceConfig = BGPersistenceConfig()
+    @objc public lazy var activity: BGActivityConfig = {
+        let c = BGActivityConfig()
+        return c
+    }()
+
+    // MARK: - Top-level state
+
+    @objc public var enabled: Bool = false
+    @objc public var isMoving: Bool = false
+    @objc public var trackingMode: Int = 1
+    @objc public var didLaunchInBackground: Bool = false
+    @objc public var didRequestUpgradeLocationAuthorization: Bool = false
+    @objc public var lastLocationAuthorizationStatus: Int = 0
+    @objc public var iOSHasWarnedLocationServicesOff: Bool = false
+    @objc public var schedulerEnabled: Bool = false
+    @objc public var includeDeprecatedPropertiesInDictionary: Bool = false
+
+    private var listeners: [String: [[String: Any]]] = [:]
+    private var plugins: [String: AnyObject] = [:]
+    private let listenersLock = NSLock()
+    private let persistQueue = DispatchQueue(label: "BGConfig.persist")
+    private var pendingPersist: Bool = false
+
+    // MARK: - Init
+
+    @objc public override init() {
+        super.init()
+        commonInitSetup()
+    }
+
+    @objc public required init?(coder: NSCoder) {
+        super.init()
+        commonInitSetup()
+        if let data = coder.decodeObject(forKey: "geolocation") as? Data,
+           let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+            geolocation.updateWithDictionary(dict)
+        }
+        if let data = coder.decodeObject(forKey: "http") as? Data,
+           let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+            http.updateWithDictionary(dict)
+        }
+        if let data = coder.decodeObject(forKey: "logger") as? Data,
+           let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+            logger.updateWithDictionary(dict)
+        }
+        if let data = coder.decodeObject(forKey: "app") as? Data,
+           let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+            app.updateWithDictionary(dict)
+        }
+        enabled = coder.decodeBool(forKey: "enabled")
+        isMoving = coder.decodeBool(forKey: "isMoving")
+        trackingMode = coder.decodeInteger(forKey: "trackingMode")
+        schedulerEnabled = coder.decodeBool(forKey: "schedulerEnabled")
+    }
+
+    @objc public func encode(with coder: NSCoder) {
+        if let data = try? JSONSerialization.data(withJSONObject: geolocation.toDictionary()) { coder.encode(data, forKey: "geolocation") }
+        if let data = try? JSONSerialization.data(withJSONObject: http.toDictionary()) { coder.encode(data, forKey: "http") }
+        if let data = try? JSONSerialization.data(withJSONObject: logger.toDictionary()) { coder.encode(data, forKey: "logger") }
+        if let data = try? JSONSerialization.data(withJSONObject: app.toDictionary()) { coder.encode(data, forKey: "app") }
+        coder.encode(enabled, forKey: "enabled")
+        coder.encode(isMoving, forKey: "isMoving")
+        coder.encode(trackingMode, forKey: "trackingMode")
+        coder.encode(schedulerEnabled, forKey: "schedulerEnabled")
+    }
+
+    @objc public func commonInitSetup() {
+        applyDefaults()
+    }
+
+    @objc public func initPrivateForBoot() {
+        didLaunchInBackground = true
+    }
+
+    // MARK: - Defaults
+
+    @objc public func applyDefaults() {
+        applyModuleDefaults()
+    }
+
+    @objc public func applyModuleDefaults() {
+        geolocation.applyDefaults()
+        http.applyDefaults()
+        logger.applyDefaults()
+        app.applyDefaults()
+        authorization.applyDefaults()
+        persistence.applyDefaults()
+    }
+
+    // MARK: - Module access
+
+    @objc public func allModules() -> [BGConfigModuleBase] {
+        return [geolocation, http, logger, app, authorization, persistence]
+    }
+
+    @objc public func moduleMap() -> [String: BGConfigModuleBase] {
+        return [
+            "geolocation": geolocation,
+            "http": http,
+            "logger": logger,
+            "app": app,
+            "authorization": authorization,
+            "persistence": persistence
+        ]
+    }
+
+    @objc public func module(forKey key: String) -> BGConfigModuleBase? {
+        return moduleMap()[key]
+    }
+
+    @objc public func key(forModule module: BGConfigModuleBase) -> String? {
+        return moduleMap().first(where: { $0.value === module })?.key
+    }
+
+    // MARK: - Update
+
+    @objc public func updateWithDictionary(_ dict: [String: Any]) {
+        updateWithDictionaryUnsafe(dict)
+        persist()
+    }
+
+    @objc public func updateWithDictionaryUnsafe(_ dict: [String: Any]) {
+        for (key, value) in dict {
+            if let module = module(forKey: key), let subDict = value as? [String: Any] {
+                module.updateWithDictionary(subDict)
+            } else {
+                applyTopLevelValue(value, forKey: key)
+            }
+        }
+        flattenModulesFrom(dict)
+    }
+
+    @objc public func flattenedModules(from dict: [String: Any]) -> [String: Any] {
+        var flattened: [String: Any] = [:]
+        for module in allModules() {
+            let specs = module.propertySpecs()
+            for spec in specs {
+                if let value = dict[spec.name] {
+                    flattened[spec.name] = value
+                }
+            }
+        }
+        return flattened
+    }
+
+    @objc public func flattenModulesFrom(_ dict: [String: Any]) {
+        for module in allModules() {
+            let specs = module.propertySpecs()
+            var moduleDict: [String: Any] = [:]
+            for spec in specs {
+                if let value = dict[spec.name] {
+                    moduleDict[spec.name] = value
+                }
+            }
+            if !moduleDict.isEmpty {
+                module.updateWithDictionary(moduleDict)
+            }
+        }
+    }
+
+    private func applyTopLevelValue(_ value: Any, forKey key: String) {
+        switch key {
+        case "enabled": if let v = value as? Bool { enabled = v }
+        case "isMoving", "is_moving": if let v = value as? Bool { isMoving = v }
+        case "trackingMode": if let v = value as? Int { trackingMode = v }
+        case "schedulerEnabled": if let v = value as? Bool { schedulerEnabled = v }
+        default: break
+        }
+    }
+
+    // MARK: - Batch update
+
+    @objc public func batchUpdate(_ block: (BGConfig) -> Void) {
+        block(self)
+        persist()
+    }
+
+    // MARK: - Serialization
+
+    @objc public func toDictionary() -> [String: Any] {
+        return toDictionary(false)
+    }
+
+    @objc public func toDictionary(_ includeDeprecated: Bool) -> [String: Any] {
+        return toDictionaryUnsafe(includeDeprecated)
+    }
+
+    @objc public func toDictionaryUnsafe(_ includeDeprecated: Bool) -> [String: Any] {
+        var dict: [String: Any] = [:]
+        dict["enabled"] = enabled
+        dict["isMoving"] = isMoving
+        dict["trackingMode"] = trackingMode
+        dict["schedulerEnabled"] = schedulerEnabled
+
+        let moduleDict = moduleMap()
+        for (key, module) in moduleDict {
+            dict[key] = module.toDictionary()
+        }
+
+        for module in allModules() {
+            let moduleData = module.toDictionary()
+            dict.merge(moduleData) { $1 }
+        }
+
+        return dict
+    }
+
+    @objc public func toJson() -> String? {
+        let dict = toDictionary()
+        guard let data = try? JSONSerialization.data(withJSONObject: dict) else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    @objc public func currentStateDictionary() -> [String: Any] {
+        return toDictionary()
+    }
+
+    // MARK: - Persistence
+
+    @objc public func persist() {
+        persistQueue.async { self.persistUnsafe() }
+    }
+
+    @objc public func forcePersistNow() {
+        persistUnsafe()
+    }
+
+    @objc public func persistUnsafe() {
+        let data = try? NSKeyedArchiver.archivedData(withRootObject: self, requiringSecureCoding: false)
+        UserDefaults.standard.set(data, forKey: BGConfig.storageKey)
+        UserDefaults.standard.synchronize()
+    }
+
+    @objc public func _flushDefaults() {
+        UserDefaults.standard.synchronize()
+    }
+
+    @objc public class func decode() -> BGConfig? {
+        guard let data = UserDefaults.standard.data(forKey: storageKey) else { return nil }
+        return try? NSKeyedUnarchiver.unarchivedObject(ofClass: BGConfig.self, from: data)
+    }
+
+    // MARK: - Listeners
+
+    @objc public func addListener(_ property: String, callback: @escaping ([String: Any]) -> Void) -> Int {
+        listenersLock.lock()
+        defer { listenersLock.unlock() }
+        let token = Int.random(in: 1...Int.max)
+        var entry: [String: Any] = ["callback": callback, "token": token]
+        if listeners[property] == nil { listeners[property] = [] }
+        listeners[property]!.append(entry)
+        return token
+    }
+
+    @objc public func onChange(_ block: @escaping ([String: Any]) -> Void) {
+        _ = addListener("*", callback: block)
+    }
+
+    @objc public func removeListener(_ property: String, forProperty prop: String) {
+    }
+
+    @objc public func removeListener(_ property: String, token: Int) {
+        listenersLock.lock()
+        defer { listenersLock.unlock() }
+        listeners[property]?.removeAll { ($0["token"] as? Int) == token }
+    }
+
+    @objc public func removeAllListeners(forProperty property: String) {
+        listenersLock.lock()
+        defer { listenersLock.unlock() }
+        listeners.removeValue(forKey: property)
+    }
+
+    @objc public func removeAllListeners() {
+        listenersLock.lock()
+        defer { listenersLock.unlock() }
+        listeners.removeAll()
+    }
+
+    @objc public func emitChangeEvent(_ event: String, value: Any?) {
+        listenersLock.lock()
+        let list = (listeners[event] ?? []) + (listeners["*"] ?? [])
+        listenersLock.unlock()
+        let payload: [String: Any] = ["event": event, "value": value ?? NSNull()]
+        for entry in list {
+            if let cb = entry["callback"] as? ([String: Any]) -> Void {
+                cb(payload)
+            }
+        }
+    }
+
+    @objc public func emitModuleEvents(forPrefixes prefixes: [String]) {
+        for prefix in prefixes {
+            emitChangeEvent(prefix, value: nil)
+        }
+    }
+
+    @objc public func moduleEventPrefixes(forChangedKeypaths keypaths: [String]) -> [String] {
+        return keypaths
+    }
+
+    // MARK: - KVO
+
+    @objc public func setupKVO() {
+    }
+
+    @objc public func setupModuleObservation() {
+    }
+
+    @objc public override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey: Any]?, context: UnsafeMutableRawPointer?) {
+    }
+
+    // MARK: - Plugins
+
+    @objc public func registerPlugin(_ plugin: AnyObject) {
+        plugins[NSStringFromClass(type(of: plugin))] = plugin
+    }
+
+    @objc public func hasPlugin(forEvent event: String) -> Bool {
+        return false
+    }
+
+    // MARK: - Convenience computed properties
+
+    @objc public func hasSchedule() -> Bool {
+        return app.hasSchedule
+    }
+
+    @objc public func hasTriggerActivities() -> Bool {
+        return false
+    }
+
+    @objc public func hasValidUrl() -> Bool {
+        return http.hasValidUrl
+    }
+
+    @objc public func isLocationTrackingMode() -> Bool {
+        return trackingMode == 1
+    }
+
+    @objc public func isFirstBoot() -> Bool {
+        return !UserDefaults.standard.bool(forKey: "BGLocationManager_booted")
+    }
+
+    @objc public func didDeviceReboot() -> Bool {
+        let stored = UserDefaults.standard.double(forKey: "BGLocationManager_uptime")
+        let current = ProcessInfo.processInfo.systemUptime
+        return stored > current
+    }
+
+    @objc public func shouldPersist(_ location: BGLocation) -> Bool {
+        return persistence.persistMode > 0
+    }
+
+    @objc public func isValue(_ value1: Any?, equalTo value2: Any?) -> Bool {
+        guard let v1 = value1, let v2 = value2 else { return value1 == nil && value2 == nil }
+        if let n1 = v1 as? NSObject, let n2 = v2 as? NSObject { return n1.isEqual(n2) }
+        return false
+    }
+
+    // MARK: - State
+
+    @objc public func reset() {
+        resetUnsafe()
+        persist()
+    }
+
+    @objc public func resetUnsafe() {
+        enabled = false
+        isMoving = false
+        applyModuleDefaults()
+    }
+
+    @objc public func resetConfig(_ dict: [String: Any]) {
+        resetUnsafe()
+        updateWithDictionaryUnsafe(dict)
+        persist()
+    }
+
+    @objc public func lockForInvalidLicense() {
+        enabled = false
+    }
+
+    @objc public func validateLicense() {
+        BGLicenseManager.sharedManager().validateLicense()
+    }
+
+    @objc public func migrateFromLegacyObject(_ legacy: AnyObject) {
+    }
+
+    @objc public func getLocationAuthorizationAlertStrings() -> [String: Any] {
+        return [
+            "title": "Background Location Access",
+            "message": "This app requires location access to function properly.",
+            "cancel": "Cancel",
+            "settings": "Settings"
+        ]
+    }
+}