react-native-bg-geolocation 0.2.0

package/ios/engine/BGEventManager.swift

@@ -0,0 +1,169 @@
+import Foundation
+
+@objc public class BGLocationListener: NSObject {
+    @objc public var success: ((Any?) -> Void)?
+    @objc public var failure: ((Any?) -> Void)?
+
+    @objc public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? BGLocationListener else { return false }
+        return self === other
+    }
+
+    @objc public override var hash: Int { return ObjectIdentifier(self).hashValue }
+}
+
+@objc public class BGEventManager: NSObject {
+
+    private static var _sharedInstance: BGEventManager?
+    private static let lock = NSLock()
+
+    @objc public var listeners: NSMutableDictionary = NSMutableDictionary()
+    @objc public var locationListeners: NSMutableArray = NSMutableArray()
+    @objc public var bufferedEvents: NSMutableDictionary = NSMutableDictionary()
+    @objc public var bufferingEnabled: Bool = true
+    @objc public var locked: Bool = false
+    @objc public var maxBufferedPerEvent: Int = 1
+
+    @objc public class func sharedInstance() -> BGEventManager {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGEventManager()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+        listeners = NSMutableDictionary()
+        locationListeners = NSMutableArray()
+        bufferedEvents = NSMutableDictionary()
+        bufferingEnabled = true
+        maxBufferedPerEvent = 1
+    }
+
+    @objc public func isLocked() -> Bool { return locked }
+    @objc public func isBuffering() -> Bool { return bufferingEnabled }
+
+    @objc public func lock() { locked = true }
+
+    @objc public func ready() {
+        bufferingEnabled = false
+        flushBufferedEvents()
+    }
+
+    @objc public func addListener(_ event: String, callback: @escaping (Any?) -> Void) -> String {
+        let token = UUID().uuidString
+        objc_sync_enter(self)
+        var eventListeners = listeners[event] as? [[String: Any]] ?? []
+        eventListeners.append(["token": token, "callback": callback])
+        listeners[event] = eventListeners
+        objc_sync_exit(self)
+        return token
+    }
+
+    @objc public func addLocationListener(success: @escaping (Any?) -> Void,
+                                           failure: @escaping (Any?) -> Void) -> BGLocationListener {
+        let listener = BGLocationListener()
+        listener.success = success
+        listener.failure = failure
+        objc_sync_enter(self)
+        locationListeners.add(listener)
+        objc_sync_exit(self)
+        return listener
+    }
+
+    @objc public func removeListener(_ event: String, callback: AnyObject) {
+        objc_sync_enter(self)
+        if var eventListeners = listeners[event] as? [[String: Any]] {
+            eventListeners.removeAll { ($0["callback"] as AnyObject) === callback }
+            listeners[event] = eventListeners
+        }
+        objc_sync_exit(self)
+    }
+
+    @objc public func removeListener(_ event: String, token: String) {
+        objc_sync_enter(self)
+        if var eventListeners = listeners[event] as? [[String: Any]] {
+            eventListeners.removeAll { ($0["token"] as? String) == token }
+            listeners[event] = eventListeners
+        }
+        objc_sync_exit(self)
+    }
+
+    @objc public func removeListeners(_ event: String) {
+        objc_sync_enter(self)
+        listeners.removeObject(forKey: event)
+        objc_sync_exit(self)
+    }
+
+    @objc public func removeListeners() {
+        objc_sync_enter(self)
+        listeners.removeAllObjects()
+        locationListeners.removeAllObjects()
+        objc_sync_exit(self)
+    }
+
+    @objc public func trigger(_ event: String, payload: Any?) {
+        if bufferingEnabled {
+            bufferEvent(event, payload: payload)
+            return
+        }
+        objc_sync_enter(self)
+        let eventListeners = listeners[event] as? [[String: Any]] ?? []
+        objc_sync_exit(self)
+        for entry in eventListeners {
+            if let callback = entry["callback"] as? (Any?) -> Void {
+                callback(payload)
+            }
+        }
+    }
+
+    @objc public func triggerLocationSuccess(_ location: Any?) {
+        objc_sync_enter(self)
+        let lst = locationListeners.copy() as! NSArray
+        objc_sync_exit(self)
+        for listener in lst {
+            (listener as? BGLocationListener)?.success?(location)
+        }
+    }
+
+    @objc public func triggerLocationError(_ error: Any?) {
+        objc_sync_enter(self)
+        let lst = locationListeners.copy() as! NSArray
+        objc_sync_exit(self)
+        for listener in lst {
+            (listener as? BGLocationListener)?.failure?(error)
+        }
+    }
+
+    @objc public func bufferEvent(_ event: String, payload: Any?) {
+        objc_sync_enter(self)
+        var buf = bufferedEvents[event] as? [Any] ?? []
+        buf.append(payload as Any)
+        if buf.count > maxBufferedPerEvent {
+            buf.removeFirst()
+        }
+        bufferedEvents[event] = buf
+        objc_sync_exit(self)
+    }
+
+    @objc public func drainBuffer(forEvent event: String) {
+        objc_sync_enter(self)
+        let buf = bufferedEvents[event] as? [Any] ?? []
+        bufferedEvents.removeObject(forKey: event)
+        objc_sync_exit(self)
+        for payload in buf {
+            trigger(event, payload: payload)
+        }
+    }
+
+    @objc public func flushBufferedEvents() {
+        objc_sync_enter(self)
+        let events = (bufferedEvents.allKeys as? [String]) ?? []
+        objc_sync_exit(self)
+        for event in events {
+            drainBuffer(forEvent: event)
+        }
+    }
+}

package/ios/engine/BGEventNames.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+// Global NSString event-name constants (extern NSString * const BGEventName…).
+
+public let BGEventNameLocation = "location"
+public let BGEventNameLocationError = "locationerror"
+public let BGEventNameHttp = "http"
+public let BGEventNameGeofence = "geofence"
+public let BGEventNameHeartbeat = "heartbeat"
+public let BGEventNameMotionChange = "motionchange"
+public let BGEventNameActivityChange = "activitychange"
+public let BGEventNameProviderChange = "providerchange"
+public let BGEventNameGeofencesChange = "geofenceschange"
+public let BGEventNameSchedule = "schedule"
+public let BGEventNamePowerSaveChange = "powersavechange"
+public let BGEventNameConnectivityChange = "connectivitychange"
+public let BGEventNameEnabledChange = "enabledchange"
+public let BGEventNameAuthorization = "authorization"
+public let BGEventNameCLLocation = "CLLocation"
+public let BGEventNameWatchPosition = "watchposition"
+public let BGEventNameRPCError = "RPCError"
+public let BGEventNameStopMonitoringSignificantLocationChanges = "stopMonitoringSignificantLocationChanges"
+
+public let BGEventBusNameAppResume = "BGAppState.resume"
+public let BGEventBusNameAppSuspend = "BGAppState.suspend"
+public let BGEventBusNamePersist = "BGLocation.persist"
+
+// Convenience namespace for dot-syntax access to event name constants.
+public struct BGEventNames {
+    public static let location = BGEventNameLocation
+    public static let locationError = BGEventNameLocationError
+    public static let http = BGEventNameHttp
+    public static let geofence = BGEventNameGeofence
+    public static let heartbeat = BGEventNameHeartbeat
+    public static let motionChange = BGEventNameMotionChange
+    public static let activityChange = BGEventNameActivityChange
+    public static let providerChange = BGEventNameProviderChange
+    public static let geofencesChange = BGEventNameGeofencesChange
+    public static let schedule = BGEventNameSchedule
+    public static let powerSaveChange = BGEventNamePowerSaveChange
+    public static let connectivityChange = BGEventNameConnectivityChange
+    public static let enabledChange = BGEventNameEnabledChange
+    public static let authorization = BGEventNameAuthorization
+    public static let watchPosition = BGEventNameWatchPosition
+    // Composite names used by BGLog and other components
+    public static let locationComplete = "locationComplete"
+    public static let locationSample = "locationSample"
+    public static let geofenceComplete = "geofenceComplete"
+    public static let motionChangeComplete = "motionChangeComplete"
+    public static let motionChangeError = "motionChangeError"
+}

package/ios/engine/BGGeofence.swift

@@ -0,0 +1,233 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGGeofence: NSObject {
+
+    @objc public var identifier: String = ""
+    @objc public var latitude: CLLocationDegrees = 0
+    @objc public var longitude: CLLocationDegrees = 0
+    @objc public var radius: CLLocationDistance = 200
+    @objc public var notifyOnEntry: Bool = true
+    @objc public var notifyOnExit: Bool = true
+    @objc public var notifyOnDwell: Bool = false
+    @objc public var loiteringDelay: Double = 0
+    @objc public var extras: [String: Any]?
+    @objc public var vertices: [[Double]] = []
+
+    @objc public var entryState: String = "UNKNOWN"
+    @objc public var stateUpdatedAt: Date?
+    @objc public var hits: Int = 0
+    @objc public var isLoitering: Bool = false
+    @objc public var isMonitoring: Bool = false
+    @objc public var loiteringRegion: CLCircularRegion?
+    @objc public var loiteringTransition: String?
+    @objc public var request: Any?
+    @objc public var cancelRequest: (() -> Void)?
+    @objc public var currentPolygonHits: Int = 0
+    @objc public var desiredPolygonHits: Int = 0
+
+    @objc public class func circle(
+        withIdentifier identifier: String,
+        radius: CLLocationDistance,
+        latitude: CLLocationDegrees,
+        longitude: CLLocationDegrees,
+        notifyOnEntry: Bool,
+        notifyOnExit: Bool,
+        notifyOnDwell: Bool,
+        loiteringDelay: Double,
+        extras: [String: Any]?
+    ) -> BGGeofence {
+        let g = BGGeofence()
+        g.identifier = identifier
+        g.radius = radius
+        g.latitude = latitude
+        g.longitude = longitude
+        g.notifyOnEntry = notifyOnEntry
+        g.notifyOnExit = notifyOnExit
+        g.notifyOnDwell = notifyOnDwell
+        g.loiteringDelay = loiteringDelay
+        g.extras = extras
+        return g
+    }
+
+    @objc public class func polygon(
+        withIdentifier identifier: String,
+        vertices: [[Double]],
+        notifyOnEntry: Bool,
+        notifyOnExit: Bool,
+        notifyOnDwell: Bool,
+        loiteringDelay: Double,
+        extras: [String: Any]?
+    ) -> BGGeofence {
+        let g = BGGeofence()
+        g.identifier = identifier
+        g.vertices = vertices
+        g.notifyOnEntry = notifyOnEntry
+        g.notifyOnExit = notifyOnExit
+        g.notifyOnDwell = notifyOnDwell
+        g.loiteringDelay = loiteringDelay
+        g.extras = extras
+        return g
+    }
+
+    @objc public init(
+        identifier: String,
+        radius: CLLocationDistance,
+        latitude: CLLocationDegrees,
+        longitude: CLLocationDegrees,
+        notifyOnEntry: Bool,
+        notifyOnExit: Bool,
+        notifyOnDwell: Bool,
+        loiteringDelay: Double
+    ) {
+        self.identifier = identifier
+        self.radius = radius
+        self.latitude = latitude
+        self.longitude = longitude
+        self.notifyOnEntry = notifyOnEntry
+        self.notifyOnExit = notifyOnExit
+        self.notifyOnDwell = notifyOnDwell
+        self.loiteringDelay = loiteringDelay
+        super.init()
+    }
+
+    @objc public init(
+        identifier: String,
+        radius: CLLocationDistance,
+        latitude: CLLocationDegrees,
+        longitude: CLLocationDegrees,
+        notifyOnEntry: Bool,
+        notifyOnExit: Bool,
+        notifyOnDwell: Bool,
+        loiteringDelay: Double,
+        extras: [String: Any]?,
+        vertices: [[Double]]
+    ) {
+        self.identifier = identifier
+        self.radius = radius
+        self.latitude = latitude
+        self.longitude = longitude
+        self.notifyOnEntry = notifyOnEntry
+        self.notifyOnExit = notifyOnExit
+        self.notifyOnDwell = notifyOnDwell
+        self.loiteringDelay = loiteringDelay
+        self.extras = extras
+        self.vertices = vertices
+        super.init()
+    }
+
+    @objc public init(
+        identifier: String,
+        radius: CLLocationDistance,
+        latitude: CLLocationDegrees,
+        longitude: CLLocationDegrees,
+        notifyOnEntry: Bool,
+        notifyOnExit: Bool,
+        notifyOnDwell: Bool,
+        loiteringDelay: Double,
+        extras: [String: Any]?,
+        vertices: [[Double]],
+        entryState: String,
+        stateUpdatedAt: Date?,
+        hits: Int
+    ) {
+        self.identifier = identifier
+        self.radius = radius
+        self.latitude = latitude
+        self.longitude = longitude
+        self.notifyOnEntry = notifyOnEntry
+        self.notifyOnExit = notifyOnExit
+        self.notifyOnDwell = notifyOnDwell
+        self.loiteringDelay = loiteringDelay
+        self.extras = extras
+        self.vertices = vertices
+        self.entryState = entryState
+        self.stateUpdatedAt = stateUpdatedAt
+        self.hits = hits
+        super.init()
+    }
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public var isPolygon: Bool {
+        return !vertices.isEmpty
+    }
+
+    @objc public var exitMEC: CLCircularRegion? {
+        guard !isPolygon else { return nil }
+        let center = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
+        return CLCircularRegion(center: center, radius: radius, identifier: identifier)
+    }
+
+    @objc public func startMonitoring(withLocationManager manager: CLLocationManager, prefix: String) {
+        guard !isPolygon else {
+            startMonitoringPolygon()
+            return
+        }
+        let center = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
+        let region = CLCircularRegion(center: center, radius: radius, identifier: "\(prefix)\(identifier)")
+        region.notifyOnEntry = notifyOnEntry
+        region.notifyOnExit = notifyOnExit
+        manager.startMonitoring(for: region)
+        isMonitoring = true
+    }
+
+    @objc public func startMonitoringPolygon() {
+        isMonitoring = true
+    }
+
+    @objc public func stopMonitoringPolygon() {
+        isMonitoring = false
+    }
+
+    @objc public func startLoitering() {
+        isLoitering = true
+    }
+
+    @objc public func cancelLoitering() {
+        isLoitering = false
+    }
+
+    @objc public func cancelLocationRequest() {
+        cancelRequest?()
+        cancelRequest = nil
+    }
+
+    @objc public func cancel() {
+        cancelLocationRequest()
+        isMonitoring = false
+    }
+
+    @objc public func fireEvent(_ action: String, location: CLLocation?) {
+        NotificationCenter.default.post(
+            name: NSNotification.Name("BGGeofenceEvent"),
+            object: self,
+            userInfo: ["action": action, "location": location as Any]
+        )
+    }
+
+    @objc public func persistState() {
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        var dict: [String: Any] = [
+            "identifier": identifier,
+            "latitude": latitude,
+            "longitude": longitude,
+            "radius": radius,
+            "notifyOnEntry": notifyOnEntry,
+            "notifyOnExit": notifyOnExit,
+            "notifyOnDwell": notifyOnDwell,
+            "loiteringDelay": loiteringDelay
+        ]
+        if let extras = extras { dict["extras"] = extras }
+        if !vertices.isEmpty { dict["vertices"] = vertices }
+        return dict
+    }
+
+    @objc public override var description: String {
+        return "<BGGeofence id=\(identifier) lat=\(latitude) lon=\(longitude) radius=\(radius)>"
+    }
+}

package/ios/engine/BGGeofenceDAO.swift

@@ -0,0 +1,152 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGGeofenceDAO: NSObject {
+
+    private static var _sharedInstance: BGGeofenceDAO?
+    private static let lock = NSLock()
+    private var geofences: [String: BGGeofence] = [:]
+    private let daLock = NSLock()
+
+    @objc public class func sharedInstance() -> BGGeofenceDAO {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGGeofenceDAO()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public func all() -> [BGGeofence] {
+        daLock.lock()
+        defer { daLock.unlock() }
+        return Array(geofences.values)
+    }
+
+    @objc public func all(withLocking lock: Bool) -> [BGGeofence] {
+        return all()
+    }
+
+    @objc public func count() -> Int {
+        daLock.lock()
+        defer { daLock.unlock() }
+        return geofences.count
+    }
+
+    @objc public func maxRadius() -> CLLocationDistance {
+        daLock.lock()
+        defer { daLock.unlock() }
+        return geofences.values.map { $0.radius }.max() ?? 0
+    }
+
+    @objc public func find(_ identifier: String) -> BGGeofence? {
+        daLock.lock()
+        defer { daLock.unlock() }
+        return geofences[identifier]
+    }
+
+    @objc public func exists(_ identifier: String) -> Bool {
+        daLock.lock()
+        defer { daLock.unlock() }
+        return geofences[identifier] != nil
+    }
+
+    @objc public func exists(_ db: Any?, identifier: String) -> Bool {
+        return exists(identifier)
+    }
+
+    @objc public func create(_ geofence: BGGeofence) -> Bool {
+        daLock.lock()
+        geofences[geofence.identifier] = geofence
+        daLock.unlock()
+        return true
+    }
+
+    @objc public func createAll(_ fences: [BGGeofence]) {
+        daLock.lock()
+        for g in fences { geofences[g.identifier] = g }
+        daLock.unlock()
+    }
+
+    @objc public func destroy(_ identifier: String) -> Bool {
+        daLock.lock()
+        let existed = geofences.removeValue(forKey: identifier) != nil
+        daLock.unlock()
+        return existed
+    }
+
+    @objc public func destroyAll() {
+        daLock.lock()
+        geofences.removeAll()
+        daLock.unlock()
+    }
+
+    @objc public func doInsert(_ db: Any?, geofence: BGGeofence) -> Bool {
+        return create(geofence)
+    }
+
+    @objc public func hydrate(_ row: [String: Any]) -> BGGeofence? {
+        guard let id = row["identifier"] as? String else { return nil }
+        let g = BGGeofence()
+        g.identifier = id
+        g.latitude = row["latitude"] as? CLLocationDegrees ?? 0
+        g.longitude = row["longitude"] as? CLLocationDegrees ?? 0
+        g.radius = row["radius"] as? CLLocationDistance ?? 200
+        g.notifyOnEntry = row["notify_on_entry"] as? Bool ?? true
+        g.notifyOnExit = row["notify_on_exit"] as? Bool ?? true
+        g.notifyOnDwell = row["notify_on_dwell"] as? Bool ?? false
+        g.loiteringDelay = row["loitering_delay"] as? Double ?? 0
+        g.entryState = row["entry_state"] as? String ?? "UNKNOWN"
+        g.hits = row["hits"] as? Int ?? 0
+        if let extrasStr = row["extras"] as? String {
+            g.extras = decodeExtras(extrasStr)
+        }
+        if let vertStr = row["vertices"] as? String {
+            g.vertices = decodeVertices(vertStr)
+        }
+        return g
+    }
+
+    @objc public func decodeExtras(_ 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 decodeVertices(_ json: String) -> [[Double]] {
+        guard let data = json.data(using: .utf8),
+              let arr = try? JSONSerialization.jsonObject(with: data) as? [[Double]] else { return [] }
+        return arr
+    }
+
+    @objc public func allWithinRadius(
+        _ radius: CLLocationDistance,
+        latitude: CLLocationDegrees,
+        longitude: CLLocationDegrees,
+        limit: Int
+    ) -> [BGGeofence] {
+        let center = CLLocation(latitude: latitude, longitude: longitude)
+        daLock.lock()
+        var results = geofences.values.filter {
+            let loc = CLLocation(latitude: $0.latitude, longitude: $0.longitude)
+            return center.distance(from: loc) <= radius
+        }
+        daLock.unlock()
+        if limit > 0 { results = Array(results.prefix(limit)) }
+        return results
+    }
+
+    @objc public func updateState(
+        forIdentifier identifier: String,
+        entryState: String,
+        hits: Int
+    ) {
+        daLock.lock()
+        geofences[identifier]?.entryState = entryState
+        geofences[identifier]?.hits = hits
+        daLock.unlock()
+    }
+}

package/ios/engine/BGGeofenceEvent.swift

@@ -0,0 +1,42 @@
+import Foundation
+import CoreLocation
+
+@objc public final class BGGeofenceEvent: NSObject {
+
+    @objc public private(set) var identifier: String
+    @objc public private(set) var action: String
+    @objc public private(set) var timestamp: Date?
+    @objc public private(set) var geofence: BGGeofence?
+    @objc public private(set) var location: Any?
+    @objc public private(set) var extras: [AnyHashable: Any]?
+
+    @objc public init(identifier: String?,
+                       action: String?,
+                       timestamp: Date?,
+                       geofence: BGGeofence?,
+                       location: Any?,
+                       extras: [AnyHashable: Any]?) {
+        self.identifier = identifier ?? ""
+        self.action = action ?? ""
+        self.timestamp = timestamp
+        self.geofence = geofence
+        self.location = location ?? [AnyHashable: Any]()
+        self.extras = extras
+        super.init()
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        var dict: [String: Any] = [:]
+        dict["identifier"] = identifier
+        dict["action"] = action
+        if let timestamp = timestamp {
+            dict["timestamp"] = BGDateUtils.iso8601String(from: timestamp)
+        }
+        dict["geofence"] = geofence?.toDictionary()
+        dict["location"] = location
+        if let extras = extras {
+            dict["extras"] = extras
+        }
+        return dict
+    }
+}