react-native-bg-geolocation 0.2.0

package/ios/engine/BGGeofenceLocationRequest.swift

@@ -0,0 +1,94 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGGeofenceLocationRequest: BGSingleLocationRequest {
+
+    @objc public var geofenceEvent: BGGeofenceEvent?
+
+    @objc public class func request(
+        event: BGGeofenceEvent,
+        maximumAge: Double,
+        timeout: Double,
+        desiredAccuracy: CLLocationAccuracy,
+        allowStale: Bool,
+        samples: Int,
+        label: String?,
+        persist: Bool,
+        success: @escaping (Any?) -> Void,
+        failure: @escaping (Int) -> Void
+    ) -> BGGeofenceLocationRequest {
+        let req = BGGeofenceLocationRequest()
+        req.geofenceEvent = event
+        req.maximumAge = maximumAge
+        req.timeout = timeout
+        req.desiredAccuracy = desiredAccuracy
+        req.allowStale = allowStale
+        req.samples = samples
+        req.label = label
+        req.persist = persist
+        req.success = success
+        req.failure = failure
+        req.type = "geofence"
+        return req
+    }
+
+    @objc public init(
+        event: BGGeofenceEvent,
+        maximumAge: Double,
+        timeout: Double,
+        desiredAccuracy: CLLocationAccuracy,
+        allowStale: Bool,
+        samples: Int,
+        label: String?,
+        persist: Bool,
+        success: @escaping (Any?) -> Void,
+        failure: @escaping (Int) -> Void
+    ) {
+        super.init()
+        self.geofenceEvent = event
+        self.maximumAge = maximumAge
+        self.timeout = timeout
+        self.desiredAccuracy = desiredAccuracy
+        self.allowStale = allowStale
+        self.samples = samples
+        self.label = label
+        self.persist = persist
+        self.success = success
+        self.failure = failure
+        self.type = "geofence"
+    }
+
+    @objc public override init() {
+        super.init()
+        self.type = "geofence"
+    }
+
+    @objc public func copy(with zone: NSZone? = nil) -> Any {
+        let copy = BGGeofenceLocationRequest()
+        copy.geofenceEvent = geofenceEvent
+        copy.maximumAge = maximumAge
+        copy.timeout = timeout
+        copy.desiredAccuracy = desiredAccuracy
+        copy.allowStale = allowStale
+        copy.samples = samples
+        copy.label = label
+        copy.persist = persist
+        copy.success = success
+        copy.failure = failure
+        return copy
+    }
+
+    @objc public func didComplete(withLocation location: CLLocation) {
+        success?(location)
+    }
+
+    public func setType(_ type: String) {
+        self.type = type
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        var dict: [String: Any] = ["type": type]
+        if let event = geofenceEvent { dict["geofenceEvent"] = event.toDictionary() }
+        return dict
+    }
+}

package/ios/engine/BGGeofenceManager.swift

@@ -0,0 +1,315 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGGeofenceManager: NSObject, CLLocationManagerDelegate {
+
+    private static var _sharedInstance: BGGeofenceManager?
+    private static let instanceLock = NSLock()
+
+    @objc public class func sharedInstance() -> BGGeofenceManager {
+        instanceLock.lock()
+        defer { instanceLock.unlock() }
+        if _sharedInstance == nil { _sharedInstance = BGGeofenceManager() }
+        return _sharedInstance!
+    }
+
+    // MARK: - State
+
+    @objc public var locationManager: CLLocationManager?
+    @objc public var enabled: Bool = false
+    @objc public var isMoving: Bool = false
+    @objc public var count: Int = 0
+    @objc public var proximityRadius: CLLocationDistance = 1000
+    @objc public var evaluationInterval: TimeInterval = 5.0
+    @objc public var bufferInterval: TimeInterval = 0.5
+    @objc public var evaluated: Bool = false
+    @objc public var lastLocation: CLLocation?
+    @objc public var lastEvent: BGGeofenceEvent?
+    @objc public var lastAction: String?
+    @objc public var lastEvaluatedAt: Date?
+    @objc public var didScheduleColdStartReconcile: Bool = false
+    @objc public var isMonitoringSignificantLocationChanges: Bool = false
+    @objc public var entryStates: [String: String] = [:]
+    @objc public var monitoredGeofences: [String: BGGeofence] = [:]
+    @objc public var preventSuspendTask: Any?
+    @objc public var willEvaluateProximity: Bool = false
+
+    var bufferTimer: Timer?
+    var clLocationListener: AnyObject?
+    var eventQueue: DispatchQueue?
+
+    private let stateQueue = DispatchQueue(label: "BGGeofenceManager.state", attributes: .concurrent)
+    private var clMutationQueue = DispatchQueue(label: "BGGeofenceManager.cl")
+
+    @objc public override init() {
+        super.init()
+        eventQueue = DispatchQueue(label: "BGGeofenceManager.events")
+        registerConfigChangeHandlers()
+    }
+
+    @objc public func registerConfigChangeHandlers() {
+    }
+
+    // MARK: - Start/Stop
+
+    @objc public func start() {
+        guard !enabled else { return }
+        enabled = true
+        // NOTE: the CLLocationManager delegate is owned solely by BGCLRouter
+        // (see BGLocationManager.setupCoreLocation), which forwards region and
+        // location callbacks here. Do NOT assign mgr.delegate.
+        reconcileMonitoredCacheFromCoreLocation()
+    }
+
+    @objc public func stop() {
+        guard enabled else { return }
+        enabled = false
+        stopMonitoringGeofences()
+    }
+
+    // MARK: - CL mutation
+
+    @objc public func _mutateCL(_ block: @escaping (CLLocationManager) -> Void) {
+        clMutationQueue.async {
+            guard let mgr = self.locationManager else { return }
+            DispatchQueue.main.async { block(mgr) }
+        }
+    }
+
+    // MARK: - Geofence management
+
+    @objc public func create(_ geofence: BGGeofence, success: (() -> Void)?, failure: ((Error) -> Void)?) {
+        BGGeofenceDAO.sharedInstance().create(geofence)
+        startMonitoringGeofence(geofence)
+        count = BGGeofenceDAO.sharedInstance().count()
+        success?()
+    }
+
+    @objc public func destroy(_ identifier: String, success: (() -> Void)?, failure: ((Error) -> Void)?) {
+        if let geofence = BGGeofenceDAO.sharedInstance().find(identifier) {
+            BGGeofenceDAO.sharedInstance().destroy(identifier)
+            stopMonitoringGeofence(geofence)
+        }
+        count = BGGeofenceDAO.sharedInstance().count()
+        success?()
+    }
+
+    @objc public func isInfiniteMonitoring() -> Bool {
+        return true
+    }
+
+    @objc public func startMonitoringGeofence(_ geofence: BGGeofence) {
+        _mutateCL { mgr in
+            geofence.startMonitoring(withLocationManager: mgr, prefix: "BGGeofence:")
+            self.stateQueue.async(flags: .barrier) {
+                self.monitoredGeofences[geofence.identifier] = geofence
+            }
+        }
+    }
+
+    @objc public func stopMonitoringGeofence(_ geofence: BGGeofence) {
+        _mutateCL { mgr in
+            for region in mgr.monitoredRegions {
+                if region.identifier.hasSuffix(geofence.identifier) {
+                    mgr.stopMonitoring(for: region)
+                }
+            }
+            self.stateQueue.async(flags: .barrier) {
+                self.monitoredGeofences.removeValue(forKey: geofence.identifier)
+            }
+        }
+    }
+
+    @objc public func stopMonitoringGeofenceByIdentifier(_ identifier: String) {
+        if let geofence = monitoredGeofences[identifier] {
+            stopMonitoringGeofence(geofence)
+        }
+    }
+
+    @objc public func stopMonitoringGeofences() {
+        _mutateCL { mgr in
+            for region in mgr.monitoredRegions {
+                if region.identifier.hasPrefix("BGGeofence:") {
+                    mgr.stopMonitoring(for: region)
+                }
+            }
+        }
+        stateQueue.async(flags: .barrier) {
+            self.monitoredGeofences.removeAll()
+        }
+    }
+
+    @objc public func isMonitoringRegion(_ identifier: String) -> Bool {
+        return monitoredGeofences[identifier] != nil
+    }
+
+    @objc public func getMonitoredGeofenceByIdentifier(_ identifier: String) -> BGGeofence? {
+        var result: BGGeofence?
+        stateQueue.sync { result = monitoredGeofences[identifier] }
+        return result
+    }
+
+    @objc public func identifierFor(_ region: CLRegion) -> String {
+        let id = region.identifier
+        if id.hasPrefix("BGGeofence:") {
+            return String(id.dropFirst("BGGeofence:".count))
+        }
+        return id
+    }
+
+    @objc public func reconcileMonitoredCacheFromCoreLocation() {
+        guard let mgr = locationManager else { return }
+        var coreLocationIds = Set<String>()
+        for region in mgr.monitoredRegions {
+            if region.identifier.hasPrefix("BGGeofence:") {
+                coreLocationIds.insert(identifierFor(region))
+            }
+        }
+        let dao = BGGeofenceDAO.sharedInstance()
+        let all = dao.all()
+        for geofence in all {
+            if !coreLocationIds.contains(geofence.identifier) {
+                startMonitoringGeofence(geofence)
+            }
+        }
+    }
+
+    // MARK: - Evaluation
+
+    @objc public func setLocation(_ location: CLLocation, isMoving moving: Bool) {
+        lastLocation = location
+        isMoving = moving
+        if moving {
+            evaluateProximity(location)
+        }
+    }
+
+    @objc public func evaluateProximity(_ location: CLLocation) {
+        evaluateProximity(location, delay: false)
+    }
+
+    @objc public func evaluateProximity(_ location: CLLocation, delay: Bool) {
+        guard enabled else { return }
+        if delay {
+            startBufferTimer()
+        } else {
+            onEvaluate()
+        }
+    }
+
+    @objc public func startBufferTimer() {
+        bufferTimer?.invalidate()
+        DispatchQueue.main.async {
+            self.bufferTimer = Timer.scheduledTimer(withTimeInterval: self.bufferInterval, repeats: false) { [weak self] _ in
+                self?.onEvaluate()
+            }
+        }
+    }
+
+    @objc public func onEvaluate() {
+        guard let location = lastLocation else { return }
+        lastEvaluatedAt = Date()
+        evaluated = true
+
+        let dao = BGGeofenceDAO.sharedInstance()
+        let nearby = dao.allWithinRadius(proximityRadius, latitude: location.coordinate.latitude, longitude: location.coordinate.longitude, limit: 20)
+
+        _mutateCL { mgr in
+            var needsStartSLC = false
+            for geofence in nearby {
+                if !self.isMonitoringRegion(geofence.identifier) {
+                    geofence.startMonitoring(withLocationManager: mgr, prefix: "BGGeofence:")
+                    self.stateQueue.async(flags: .barrier) {
+                        self.monitoredGeofences[geofence.identifier] = geofence
+                    }
+                    needsStartSLC = true
+                }
+            }
+            if needsStartSLC && !self.isMonitoringSignificantLocationChanges {
+                self.startMonitoringSignificantLocationChanges()
+            }
+        }
+    }
+
+    // MARK: - Significant location changes
+
+    @objc public func startMonitoringSignificantLocationChanges() {
+        guard !isMonitoringSignificantLocationChanges else { return }
+        _mutateCL { mgr in
+            mgr.startMonitoringSignificantLocationChanges()
+            self.isMonitoringSignificantLocationChanges = true
+        }
+    }
+
+    @objc public func stopMonitoringSignificantLocationChanges() {
+        guard isMonitoringSignificantLocationChanges else { return }
+        _mutateCL { mgr in
+            mgr.stopMonitoringSignificantLocationChanges()
+            self.isMonitoringSignificantLocationChanges = false
+        }
+    }
+
+    @objc public func onStopMonitoringSLC() {
+        stopMonitoringSignificantLocationChanges()
+    }
+
+    // MARK: - Event handling
+
+    @objc public func handleGeofenceEvent(_ geofence: BGGeofence, action: String) {
+        createEvent(geofence, geofence: geofence, action: action)
+    }
+
+    @objc public func createEvent(_ sender: BGGeofence, geofence: BGGeofence, action: String) {
+        let identifier = geofence.identifier
+        let event = BGGeofenceEvent(identifier: identifier, action: action, timestamp: Date(), geofence: geofence, location: lastLocation, extras: geofence.extras)
+        lastEvent = event
+        lastAction = action
+        geofence.fireEvent(action, location: lastLocation)
+        BGGeofenceDAO.sharedInstance().updateState(forIdentifier: identifier, entryState: action == "ENTER" ? "ENTER" : "EXIT", hits: geofence.hits + 1)
+        BGEventBus.sharedInstance().emit(BGEventNames.geofence, payload: event.toDictionary())
+    }
+
+    // MARK: - CLLocationManagerDelegate
+
+    @objc public func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
+        guard region.identifier.hasPrefix("BGGeofence:") else { return }
+        let id = identifierFor(region)
+        if let geofence = BGGeofenceDAO.sharedInstance().find(id) {
+            if geofence.notifyOnEntry {
+                handleGeofenceEvent(geofence, action: "ENTER")
+            }
+            if geofence.notifyOnDwell && geofence.loiteringDelay > 0 {
+                geofence.startLoitering()
+            }
+        }
+    }
+
+    @objc public func locationManager(_ manager: CLLocationManager, didExitRegion region: CLRegion) {
+        guard region.identifier.hasPrefix("BGGeofence:") else { return }
+        let id = identifierFor(region)
+        if let geofence = BGGeofenceDAO.sharedInstance().find(id) {
+            geofence.cancelLoitering()
+            if geofence.notifyOnExit {
+                handleGeofenceEvent(geofence, action: "EXIT")
+            }
+        }
+    }
+
+    @objc public func locationManager(_ manager: CLLocationManager, didStartMonitoringFor region: CLRegion) {
+    }
+
+    @objc public func locationManager(_ manager: CLLocationManager, monitoringDidFailFor region: CLRegion?, withError error: Error) {
+        BGNativeLogger.error("BGGeofenceManager", message: error.localizedDescription)
+    }
+
+    @objc public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        guard let location = locations.last else { return }
+        setLocation(location, isMoving: isMoving)
+    }
+
+    // MARK: - Info
+
+    @objc public func launchedInBackground() -> Bool {
+        return BGAppState.sharedInstance().didLaunchInBackground
+    }
+}

package/ios/engine/BGGeofenceTransition.swift

@@ -0,0 +1,97 @@
+import Foundation
+import CoreLocation
+
+@objc public final class BGGeofenceTransition: NSObject {
+
+    @objc public var location: CLLocation?
+    @objc public var triggerLocation: CLLocation?
+    @objc public var triggerLocationRequest: BGCurrentPositionRequest?
+    @objc public var loiteringRegion: CLCircularRegion?
+    @objc public var isLoitering: Bool = false
+    @objc public var didLoiter: Bool = false
+    @objc public var didComplete: Bool = false
+    @objc public var onComplete: ((NSError?) -> Void)?
+    @objc public var geofence: BGGeofence?
+    @objc public var region: CLRegion?
+    @objc public var timestamp: Date?
+    @objc public var action: String?
+
+    @objc public init(geofence: BGGeofence?,
+                       region: CLRegion?,
+                       action: String?,
+                       onComplete: ((NSError?) -> Void)?) {
+        self.geofence = geofence
+        self.region = region
+        self.action = action
+        self.onComplete = onComplete
+        self.isLoitering = false
+        self.didLoiter = false
+        self.didComplete = false
+        self.timestamp = Date()
+        super.init()
+        requestTriggerLocation()
+    }
+
+    @objc public convenience init(geofence: BGGeofence?,
+                                  action: String?,
+                                  onComplete: ((NSError?) -> Void)?) {
+        self.init(geofence: geofence, region: nil, action: action, onComplete: onComplete)
+    }
+
+    @objc public convenience init(geofence: BGGeofence?,
+                                  action: String?,
+                                  triggerLocation: CLLocation?) {
+        self.init(geofence: geofence, action: action, onComplete: nil)
+        if let triggerLocation = triggerLocation {
+            self.triggerLocation = triggerLocation
+        }
+    }
+
+    @objc public func getLoiteringRegion(_ location: CLLocation) -> CLCircularRegion? {
+        if let existing = loiteringRegion {
+            return existing
+        }
+        guard let region = region as? CLCircularRegion else { return nil }
+        let center = CLLocation(latitude: region.center.latitude,
+                                longitude: region.center.longitude)
+        let distance = location.distance(from: center)
+        let accuracy = location.horizontalAccuracy
+        let radius = distance + max(accuracy * 1.5, 10.0)
+        let loitering = CLCircularRegion(center: region.center,
+                                         radius: radius,
+                                         identifier: "loitering-region")
+        self.loiteringRegion = loitering
+        return loitering
+    }
+
+    @objc public func requestTriggerLocation() {
+        let label = String(format: "BGGeofenceTransition:%@:%@",
+                           action ?? "", geofence?.identifier ?? "")
+        weak var weakSelf = self
+        let request = BGCurrentPositionRequest(
+            type: "geofence",
+            maximumAge: 30.0,
+            timeout: 10000,
+            desiredAccuracy: 1,
+            allowStale: true,
+            samples: 3,
+            label: label,
+            persist: true,
+            extras: nil,
+            success: { _ in },
+            failure: { (code: Int) in
+                guard let strongSelf = weakSelf else { return }
+                let error = NSError(domain: "BGGeofenceTransition", code: code)
+                strongSelf.onComplete?(error)
+            })
+        self.triggerLocationRequest = request
+        BGLocationRequestService.sharedInstance().requestLocation(request)
+    }
+
+    @objc public func cancelLoitering() {
+        guard let request = triggerLocationRequest else { return }
+        BGLocationRequestService.sharedInstance().cancelRequest(request.label ?? "")
+        BGLog.sharedInstance().notify("Geofence DWELL cancelled", debug: BGConfig.sharedInstance().logger.debug)
+        triggerLocationRequest = nil
+    }
+}

package/ios/engine/BGGeofencesChangeEvent.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+@objc public final class BGGeofencesChangeEvent: NSObject {
+
+    @objc public private(set) var on: [Any]
+    @objc public private(set) var off: [Any]
+
+    @objc public init(on: [Any]?, off: [Any]?) {
+        self.on = on ?? []
+        self.off = off ?? []
+        super.init()
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        var onDictionaries: [Any] = []
+        for geofence in on {
+            if let g = geofence as? BGGeofence {
+                onDictionaries.append(g.toDictionary())
+            }
+        }
+        return [
+            "on": onDictionaries,
+            "off": off
+        ]
+    }
+}

package/ios/engine/BGGeolocationConfig.swift

@@ -0,0 +1,136 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGGeolocationConfig: BGConfigModuleBase {
+
+    @objc public var desiredAccuracy: CLLocationAccuracy = kCLLocationAccuracyBest
+    @objc public var distanceFilter: CLLocationDistance = 10.0
+    @objc public var stationaryRadius: CLLocationDistance = 25.0
+    @objc public var locationTimeout: Double = 60.0
+    @objc public var stopTimeout: Double = 5.0
+    @objc public var stopAfterElapsedMinutes: Double = 0
+    @objc public var activityType: CLActivityType = .automotiveNavigation
+    @objc public var pausesLocationUpdatesAutomatically: Bool = false
+    @objc public var showsBackgroundLocationIndicator: Bool = false
+    @objc public var useSignificantChangesOnly: Bool = false
+    // When true, the engine never powers GPS down to the stationary state — it
+    // keeps continuous location updates running for the whole tracking session.
+    // Combined with showsBackgroundLocationIndicator this is the "ride app"
+    // behavior: the app stays alive in the background (location indicator shown)
+    // and tracks continuously instead of relying on motion/region wakeups.
+    // Higher battery cost; far more reliable background tracking.
+    @objc public var disableStopDetection: Bool = false
+    @objc public var locationAuthorizationRequest: String = "Always"
+    @objc public var locationAuthorizationAlert: [String: String] = [:]
+    @objc public var disableLocationAuthorizationAlert: Bool = false
+    @objc public var geofenceProximityRadius: CLLocationDistance = 1000.0
+    @objc public var geofenceInitialTriggerEntry: Bool = true
+    @objc public var enableTimestampMeta: Bool = false
+    @objc public var disableElasticity: Bool = false
+    @objc public var elasticityMultiplier: Double = 1.0
+    @objc public var filter: BGLocationFilterConfig?
+
+    @objc public class func activityType(fromString s: String) -> CLActivityType {
+        switch s.lowercased() {
+        case "automotive_navigation", "automotivenavigation": return .automotiveNavigation
+        case "fitness": return .fitness
+        case "other_navigation", "othernavigation": return .otherNavigation
+        case "other": return .other
+        default: return .other
+        }
+    }
+
+    @objc public class func string(forActivityType type: CLActivityType) -> String {
+        switch type {
+        case .automotiveNavigation: return "automotive_navigation"
+        case .fitness: return "fitness"
+        case .otherNavigation: return "other_navigation"
+        case .other: return "other"
+        default: return "other"
+        }
+    }
+
+    @objc public class func decodeDesiredAccuracy(_ value: Any?) -> CLLocationAccuracy {
+        if let n = value as? NSNumber {
+            let d = n.doubleValue
+            switch d {
+            case -1: return kCLLocationAccuracyBestForNavigation
+            case -2: return kCLLocationAccuracyBest
+            case 10: return kCLLocationAccuracyNearestTenMeters
+            case 100: return kCLLocationAccuracyHundredMeters
+            case 1000: return kCLLocationAccuracyKilometer
+            case 3000: return kCLLocationAccuracyThreeKilometers
+            default: return d
+            }
+        }
+        return kCLLocationAccuracyBest
+    }
+
+    @objc public override func applyDefaults() {
+        desiredAccuracy = kCLLocationAccuracyBest
+        distanceFilter = 10.0
+        stationaryRadius = 25.0
+        locationTimeout = 60.0
+        stopTimeout = 5.0
+        stopAfterElapsedMinutes = 0
+        activityType = .automotiveNavigation
+        pausesLocationUpdatesAutomatically = false
+        showsBackgroundLocationIndicator = false
+        useSignificantChangesOnly = false
+        disableStopDetection = false
+        locationAuthorizationRequest = "Always"
+        disableLocationAuthorizationAlert = false
+        geofenceProximityRadius = 1000.0
+        geofenceInitialTriggerEntry = true
+        enableTimestampMeta = false
+        disableElasticity = false
+        elasticityMultiplier = 1.0
+    }
+
+    @objc public var requestsAlwaysAuthorization: Bool {
+        return locationAuthorizationRequest == "Always"
+    }
+
+    @objc public var usesHighAccuracyGPS: Bool {
+        return desiredAccuracy <= kCLLocationAccuracyNearestTenMeters
+    }
+
+    @objc public var hasValidGeofenceProximityRadius: Bool {
+        return geofenceProximityRadius > 0
+    }
+
+    @objc public func getLocationAuthorizationAlertStrings() -> [String: String] {
+        return locationAuthorizationAlert
+    }
+
+    @objc public override func propertySpecs() -> [BGPropertySpecImpl] {
+        return [
+            BGPropertySpec(name: "desiredAccuracy", type: "double"),
+            BGPropertySpec(name: "distanceFilter", type: "double"),
+            BGPropertySpec(name: "stationaryRadius", type: "double"),
+            BGPropertySpec(name: "locationTimeout", type: "double"),
+            BGPropertySpec(name: "stopTimeout", type: "double"),
+            BGPropertySpec(name: "stopAfterElapsedMinutes", type: "double"),
+            BGPropertySpec(name: "activityType", type: "string"),
+            BGPropertySpec(name: "pausesLocationUpdatesAutomatically", type: "bool"),
+            BGPropertySpec(name: "showsBackgroundLocationIndicator", type: "bool"),
+            BGPropertySpec(name: "useSignificantChangesOnly", type: "bool"),
+            BGPropertySpec(name: "disableStopDetection", type: "bool"),
+            BGPropertySpec(name: "locationAuthorizationRequest", type: "string"),
+            BGPropertySpec(name: "disableLocationAuthorizationAlert", type: "bool"),
+            BGPropertySpec(name: "geofenceProximityRadius", type: "double"),
+            BGPropertySpec(name: "geofenceInitialTriggerEntry", type: "bool"),
+            BGPropertySpec(name: "enableTimestampMeta", type: "bool"),
+            BGPropertySpec(name: "disableElasticity", type: "bool"),
+            BGPropertySpec(name: "elasticityMultiplier", type: "double")
+        ]
+    }
+
+    @objc public override func validateConfiguration() -> Bool {
+        return true
+    }
+
+    @objc public override var description: String {
+        return "<BGGeolocationConfig desiredAccuracy=\(desiredAccuracy) distanceFilter=\(distanceFilter) stationaryRadius=\(stationaryRadius)>"
+    }
+}