react-native-bg-geolocation 0.2.0

package/ios/engine/BGDatabasePool.swift

@@ -0,0 +1,220 @@
+import Foundation
+
+@objc public protocol BGDatabasePoolDelegate: NSObjectProtocol {
+    @objc optional func databasePool(_ pool: BGDatabasePool, shouldAddDatabaseToPool database: BGDatabase) -> Bool
+    @objc optional func databasePool(_ pool: BGDatabasePool, didAddDatabase database: BGDatabase)
+}
+
+@objc public class BGDatabasePool: NSObject {
+
+    @objc public var path: String = ""
+    @objc public var vfsName: String?
+    @objc public var openFlags: Int32 = 0
+    @objc public var maximumNumberOfDatabasesToCreate: Int = 5
+    @objc public weak var delegate: BGDatabasePoolDelegate?
+
+    private var databaseInPool: [BGDatabase] = []
+    private var databaseOutPool: [BGDatabase] = []
+    private let lockQueue = DispatchQueue(label: "BGDatabasePool.lock")
+    private let semaphore: DispatchSemaphore
+
+    @objc public class func databasePool(withPath path: String) -> BGDatabasePool {
+        return BGDatabasePool(path: path)
+    }
+
+    @objc public class func databasePool(withPath path: String, flags: Int32) -> BGDatabasePool {
+        return BGDatabasePool(path: path, flags: flags)
+    }
+
+    @objc public class func databasePool(withURL url: URL) -> BGDatabasePool {
+        return BGDatabasePool(url: url)
+    }
+
+    @objc public class func databasePool(withURL url: URL, flags: Int32) -> BGDatabasePool {
+        return BGDatabasePool(url: url, flags: flags)
+    }
+
+    @objc public class func databaseClass() -> AnyClass {
+        return BGDatabase.self
+    }
+
+    @objc public init(path: String) {
+        self.path = path
+        self.semaphore = DispatchSemaphore(value: 5)
+        super.init()
+    }
+
+    @objc public init(path: String, flags: Int32) {
+        self.path = path
+        self.openFlags = flags
+        self.semaphore = DispatchSemaphore(value: 5)
+        super.init()
+    }
+
+    @objc public init(path: String, flags: Int32, vfs: String?) {
+        self.path = path
+        self.openFlags = flags
+        self.vfsName = vfs
+        self.semaphore = DispatchSemaphore(value: 5)
+        super.init()
+    }
+
+    @objc public init(url: URL) {
+        self.path = url.path
+        self.semaphore = DispatchSemaphore(value: 5)
+        super.init()
+    }
+
+    @objc public init(url: URL, flags: Int32) {
+        self.path = url.path
+        self.openFlags = flags
+        self.semaphore = DispatchSemaphore(value: 5)
+        super.init()
+    }
+
+    @objc public init(url: URL, flags: Int32, vfs: String?) {
+        self.path = url.path
+        self.openFlags = flags
+        self.vfsName = vfs
+        self.semaphore = DispatchSemaphore(value: 5)
+        super.init()
+    }
+
+    @objc public override init() {
+        self.semaphore = DispatchSemaphore(value: 5)
+        super.init()
+    }
+
+    @objc public func countOfCheckedInDatabases() -> Int {
+        return executeLocked { self.databaseInPool.count }
+    }
+
+    @objc public func countOfCheckedOutDatabases() -> Int {
+        return executeLocked { self.databaseOutPool.count }
+    }
+
+    @objc public func countOfOpenDatabases() -> Int {
+        return executeLocked { self.databaseInPool.count + self.databaseOutPool.count }
+    }
+
+    @objc public func releaseAllDatabases() {
+        executeLocked {
+            self.databaseInPool.removeAll()
+            self.databaseOutPool.removeAll()
+        }
+    }
+
+    func executeLocked<T>(_ block: () -> T) -> T {
+        var result: T!
+        lockQueue.sync { result = block() }
+        return result
+    }
+
+    @objc public func executeLocked(_ block: () -> Void) {
+        lockQueue.sync(execute: block)
+    }
+
+    func db() -> BGDatabase {
+        semaphore.wait()
+        var db: BGDatabase?
+        executeLocked {
+            db = self.databaseInPool.popLast()
+        }
+        if db == nil {
+            db = BGDatabase(path: path)
+            if openFlags != 0 {
+                _ = db?.open(withFlags: openFlags)
+            } else {
+                _ = db?.open()
+            }
+        }
+        executeLocked {
+            if let database = db {
+                self.databaseOutPool.append(database)
+            }
+        }
+        return db!
+    }
+
+    @objc public func inDatabase(_ block: (BGDatabase) -> Void) {
+        let database = db()
+        block(database)
+        pushDatabaseBackInPool(database)
+    }
+
+    @objc public func beginTransaction(_ useDeferred: Bool, withBlock block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        inDatabase { db in
+            var shouldRollback = ObjCBool(false)
+            if useDeferred {
+                _ = db.beginDeferredTransaction()
+            } else {
+                _ = db.beginTransaction()
+            }
+            block(db, &shouldRollback)
+            if shouldRollback.boolValue {
+                _ = db.rollback()
+            } else {
+                _ = db.commit()
+            }
+        }
+    }
+
+    @objc public func inTransaction(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        beginTransaction(false, withBlock: block)
+    }
+
+    @objc public func inDeferredTransaction(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        beginTransaction(true, withBlock: block)
+    }
+
+    @objc public func inImmediateTransaction(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        inDatabase { db in
+            var shouldRollback = ObjCBool(false)
+            _ = db.beginImmediateTransaction()
+            block(db, &shouldRollback)
+            if shouldRollback.boolValue {
+                _ = db.rollback()
+            } else {
+                _ = db.commit()
+            }
+        }
+    }
+
+    @objc public func inExclusiveTransaction(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        inDatabase { db in
+            var shouldRollback = ObjCBool(false)
+            _ = db.beginExclusiveTransaction()
+            block(db, &shouldRollback)
+            if shouldRollback.boolValue {
+                _ = db.rollback()
+            } else {
+                _ = db.commit()
+            }
+        }
+    }
+
+    @objc public func inSavePoint(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) -> Error? {
+        inDatabase { db in
+            var shouldRollback = ObjCBool(false)
+            let name = "sp_\(arc4random())"
+            _ = db.startSavePoint(withName: name, error: nil)
+            block(db, &shouldRollback)
+            if shouldRollback.boolValue {
+                _ = db.rollbackToSavePoint(withName: name, error: nil)
+            } else {
+                _ = db.releaseSavePoint(withName: name, error: nil)
+            }
+        }
+        return nil
+    }
+
+    @objc public func pushDatabaseBackInPool(_ database: BGDatabase) {
+        executeLocked {
+            if let idx = self.databaseOutPool.firstIndex(where: { $0 === database }) {
+                self.databaseOutPool.remove(at: idx)
+            }
+            self.databaseInPool.append(database)
+        }
+        semaphore.signal()
+    }
+}

package/ios/engine/BGDatabaseQueue.swift

@@ -0,0 +1,215 @@
+import Foundation
+
+@objc public class BGDatabaseQueue: NSObject {
+
+    @objc public var path: String = ""
+    @objc public var vfsName: String?
+    @objc public var openFlags: Int32 = 0
+
+    private var db: BGDatabase?
+    private let queue: DispatchQueue
+    private static let kQueueKey = DispatchSpecificKey<BGDatabaseQueue>()
+
+    @objc public class func databaseQueue(withPath path: String) -> BGDatabaseQueue {
+        return BGDatabaseQueue(path: path)
+    }
+
+    @objc public class func databaseQueue(withPath path: String, flags: Int32) -> BGDatabaseQueue {
+        return BGDatabaseQueue(path: path, flags: flags)
+    }
+
+    @objc public class func databaseQueue(withURL url: URL) -> BGDatabaseQueue {
+        return BGDatabaseQueue(url: url)
+    }
+
+    @objc public class func databaseQueue(withURL url: URL, flags: Int32) -> BGDatabaseQueue {
+        return BGDatabaseQueue(url: url, flags: flags)
+    }
+
+    @objc public class func databaseClass() -> AnyClass {
+        return BGDatabase.self
+    }
+
+    @objc public init(path: String) {
+        self.path = path
+        self.queue = DispatchQueue(label: "BGDatabaseQueue.\(path)")
+        super.init()
+        openDatabase()
+    }
+
+    @objc public init(path: String, flags: Int32) {
+        self.path = path
+        self.openFlags = flags
+        self.queue = DispatchQueue(label: "BGDatabaseQueue.\(path)")
+        super.init()
+        openDatabase()
+    }
+
+    @objc public init(path: String, flags: Int32, vfs: String?) {
+        self.path = path
+        self.openFlags = flags
+        self.vfsName = vfs
+        self.queue = DispatchQueue(label: "BGDatabaseQueue.\(path)")
+        super.init()
+        openDatabase()
+    }
+
+    @objc public init(url: URL) {
+        self.path = url.path
+        self.queue = DispatchQueue(label: "BGDatabaseQueue.\(url.path)")
+        super.init()
+        openDatabase()
+    }
+
+    @objc public init(url: URL, flags: Int32) {
+        self.path = url.path
+        self.openFlags = flags
+        self.queue = DispatchQueue(label: "BGDatabaseQueue.\(url.path)")
+        super.init()
+        openDatabase()
+    }
+
+    @objc public init(url: URL, flags: Int32, vfs: String?) {
+        self.path = url.path
+        self.openFlags = flags
+        self.vfsName = vfs
+        self.queue = DispatchQueue(label: "BGDatabaseQueue.\(url.path)")
+        super.init()
+        openDatabase()
+    }
+
+    @objc public override init() {
+        self.queue = DispatchQueue(label: "BGDatabaseQueue.default")
+        super.init()
+    }
+
+    private func openDatabase() {
+        let database = BGDatabase(path: path)
+        if openFlags != 0 {
+            _ = database.open(withFlags: openFlags)
+        } else {
+            _ = database.open()
+        }
+        db = database
+        queue.setSpecific(key: BGDatabaseQueue.kQueueKey, value: self)
+    }
+
+    @objc public func database() -> BGDatabase? {
+        return db
+    }
+
+    @objc public func close() {
+        queue.sync {
+            self.db?.close()
+            self.db = nil
+        }
+    }
+
+    @objc public func interrupt() {
+        db?.interrupt()
+    }
+
+    @objc public func inDatabase(_ block: (BGDatabase) -> Void) {
+        queue.sync {
+            guard let database = self.db else { return }
+            block(database)
+            if database.hasOpenResultSets() {
+                database.closeOpenResultSets()
+            }
+        }
+    }
+
+    @objc public func beginTransaction(_ useDeferred: Bool, withBlock block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        queue.sync {
+            guard let database = self.db else { return }
+            var shouldRollback = ObjCBool(false)
+            if useDeferred {
+                _ = database.beginDeferredTransaction()
+            } else {
+                _ = database.beginTransaction()
+            }
+            block(database, &shouldRollback)
+            if shouldRollback.boolValue {
+                _ = database.rollback()
+            } else {
+                _ = database.commit()
+            }
+        }
+    }
+
+    @objc public func inTransaction(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        beginTransaction(false, withBlock: block)
+    }
+
+    @objc public func inDeferredTransaction(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        beginTransaction(true, withBlock: block)
+    }
+
+    @objc public func inImmediateTransaction(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        queue.sync {
+            guard let database = self.db else { return }
+            var shouldRollback = ObjCBool(false)
+            _ = database.beginImmediateTransaction()
+            block(database, &shouldRollback)
+            if shouldRollback.boolValue {
+                _ = database.rollback()
+            } else {
+                _ = database.commit()
+            }
+        }
+    }
+
+    @objc public func inExclusiveTransaction(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        queue.sync {
+            guard let database = self.db else { return }
+            var shouldRollback = ObjCBool(false)
+            _ = database.beginExclusiveTransaction()
+            block(database, &shouldRollback)
+            if shouldRollback.boolValue {
+                _ = database.rollback()
+            } else {
+                _ = database.commit()
+            }
+        }
+    }
+
+    @objc public func inSavePoint(_ block: (BGDatabase, UnsafeMutablePointer<ObjCBool>) -> Void) -> Error? {
+        queue.sync {
+            guard let database = self.db else { return }
+            var shouldRollback = ObjCBool(false)
+            let name = "sp_\(arc4random())"
+            _ = database.startSavePoint(withName: name, error: nil)
+            block(database, &shouldRollback)
+            if shouldRollback.boolValue {
+                _ = database.rollbackToSavePoint(withName: name, error: nil)
+            } else {
+                _ = database.releaseSavePoint(withName: name, error: nil)
+            }
+        }
+        return nil
+    }
+
+    @objc public func checkpoint(_ checkpointMode: Int32, error: UnsafeMutablePointer<NSError?>?) -> Bool {
+        var result = false
+        queue.sync {
+            result = self.db?.checkpoint(checkpointMode, error: error) ?? false
+        }
+        return result
+    }
+
+    @objc public func checkpoint(_ checkpointMode: Int32, name: String?, error: UnsafeMutablePointer<NSError?>?) -> Bool {
+        var result = false
+        queue.sync {
+            result = self.db?.checkpoint(checkpointMode, name: name, error: error) ?? false
+        }
+        return result
+    }
+
+    @objc public func checkpoint(_ checkpointMode: Int32, name: String?, logFrameCount: UnsafeMutablePointer<Int32>?, checkpointCount: UnsafeMutablePointer<Int32>?, error: UnsafeMutablePointer<NSError?>?) -> Bool {
+        var result = false
+        queue.sync {
+            result = self.db?.checkpoint(checkpointMode, name: name, logFrameCount: logFrameCount, checkpointCount: checkpointCount, error: error) ?? false
+        }
+        return result
+    }
+}

package/ios/engine/BGDateUtils.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+@objc public final class BGDateUtils: NSObject {
+
+    private static let iso8601Formatter: ISO8601DateFormatter = {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = ISO8601DateFormatter.Options(rawValue: 0xf73)
+        formatter.timeZone = TimeZone(abbreviation: "UTC")
+        return formatter
+    }()
+
+    private static let iso8601ParseFormatter: ISO8601DateFormatter = {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = ISO8601DateFormatter.Options(rawValue: 0xf73)
+        formatter.timeZone = TimeZone(abbreviation: "UTC")
+        return formatter
+    }()
+
+    @objc public class func iso8601String(from date: Date) -> String {
+        return iso8601Formatter.string(from: date)
+    }
+
+    @objc public class func date(fromISO8601String string: String) -> Date? {
+        return iso8601ParseFormatter.date(from: string)
+    }
+}

package/ios/engine/BGDeviceInfo.swift

@@ -0,0 +1,54 @@
+import Foundation
+#if canImport(UIKit)
+import UIKit
+#endif
+
+@objc public final class BGDeviceInfo: NSObject {
+
+    @objc public var model: String?
+    @objc public var manufacturer: String?
+    @objc public var platform: String?
+    @objc public var version: String?
+
+    @objc public static let sharedInstance = BGDeviceInfo()
+
+    @objc public override init() {
+        super.init()
+        let device = UIDevice.current
+        self.model = getDeviceId()
+        self.platform = device.systemName
+        self.manufacturer = "Apple"
+        self.version = device.systemVersion
+    }
+
+    @objc public func toDictionary() -> [String: Any] {
+        return [
+            "model": model ?? "",
+            "platform": platform ?? "",
+            "manufacturer": "Apple",
+            "version": version ?? "",
+            "framework": "native"
+        ]
+    }
+
+    @objc public func toDictionary(_ framework: String) -> [String: Any] {
+        var dict = toDictionary()
+        dict["framework"] = framework
+        return dict
+    }
+
+    @objc public func getDeviceId() -> String {
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        let machine = withUnsafePointer(to: &systemInfo.machine) {
+            $0.withMemoryRebound(to: CChar.self, capacity: 1) {
+                String(cString: $0)
+            }
+        }
+        if machine == "i386" || machine == "x86_64" {
+            let simulatorModel = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"] ?? ""
+            return String(format: "%s(%@)", simulatorModel, machine)
+        }
+        return machine
+    }
+}

package/ios/engine/BGDeviceManager.swift

@@ -0,0 +1,65 @@
+import Foundation
+#if canImport(UIKit)
+import UIKit
+#endif
+
+@objc public final class BGDeviceManager: NSObject {
+
+    @objc public static let sharedInstance = BGDeviceManager()
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public func startMonitoring() {
+        let logger = BGLog.sharedInstance()
+        if logger.shouldLog(3) {
+            logger.log(3, tag: 4, function: "-[BGDeviceManager startMonitoring]", message: "")
+        }
+        UIDevice.current.isBatteryMonitoringEnabled = false
+        UIDevice.current.isBatteryMonitoringEnabled = true
+
+        NotificationCenter.default.removeObserver(self,
+            name: NSNotification.Name.NSProcessInfoPowerStateDidChange, object: nil)
+        NotificationCenter.default.addObserver(self,
+            selector: #selector(didChangePowerMode(_:)),
+            name: NSNotification.Name.NSProcessInfoPowerStateDidChange, object: nil)
+    }
+
+    @objc public func stopMonitoring() {
+        let logger = BGLog.sharedInstance()
+        if logger.shouldLog(3) {
+            logger.log(3, tag: 5, function: "-[BGDeviceManager stopMonitoring]", message: "")
+        }
+        UIDevice.current.isBatteryMonitoringEnabled = false
+        NotificationCenter.default.removeObserver(self,
+            name: NSNotification.Name.NSProcessInfoPowerStateDidChange, object: nil)
+    }
+
+    @objc public func batteryLevel() -> Float {
+        return UIDevice.current.batteryLevel
+    }
+
+    @objc public func batteryState() -> Int {
+        return UIDevice.current.batteryState.rawValue
+    }
+
+    @objc public func isLowPowerMode() -> Bool {
+        return ProcessInfo.processInfo.isLowPowerModeEnabled
+    }
+
+    @objc public func didChangePowerMode(_ notification: Notification) {
+        let lowPower = isLowPowerMode()
+        let logger = BGLog.sharedInstance()
+        if logger.shouldLog(3) {
+            let message = String(format: "%@", lowPower ? "ENABLED" : "DISABLED")
+            logger.log(3, tag: 0, function: "-[BGDeviceManager didChangePowerMode:]", message: message)
+        }
+        let payload = BGPowerSaveChangeEvent()
+        BGEventBus.sharedInstance().trigger(BGEventNamePowerSaveChange, payload: payload)
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+}

package/ios/engine/BGEnabledChangeEvent.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+@objc public final class BGEnabledChangeEvent: NSObject {
+
+    @objc public private(set) var enabled: Bool
+
+    @objc public init(enabled: Bool) {
+        self.enabled = enabled
+        super.init()
+    }
+}

package/ios/engine/BGEnv.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+@objc public final class BGEnv: NSObject {
+
+    @objc public var isTesting: Bool = false
+
+    @objc public static let sharedInstance = BGEnv()
+
+    @objc public override init() {
+        super.init()
+        let environment = ProcessInfo.processInfo.environment
+        let xpcServiceName = environment["XPC_SERVICE_NAME"]
+        if let xpcServiceName = xpcServiceName, xpcServiceName.hasSuffix("xctest") {
+            self.isTesting = true
+        }
+    }
+}

package/ios/engine/BGEventBus.swift

@@ -0,0 +1,83 @@
+import Foundation
+
+public typealias BGEventBusListener = (_ payload: Any?) -> Void
+
+@objc public class BGEventBus: NSObject {
+
+    private static var _sharedInstance: BGEventBus?
+    private static let lock = NSLock()
+
+    @objc public var listenersByEvent: NSMutableDictionary = NSMutableDictionary()
+    @objc public var locked: Bool = false
+    @objc public var q: DispatchQueue = DispatchQueue(label: "com.transistorsoft.eventbus", attributes: .concurrent)
+
+    @objc public class func sharedInstance() -> BGEventBus {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGEventBus()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public func initPrivate() {
+        q = DispatchQueue(label: "com.transistorsoft.eventbus", attributes: .concurrent)
+        listenersByEvent = NSMutableDictionary()
+    }
+
+    @objc public func isLocked() -> Bool { return locked }
+
+    @objc public func lock() { locked = true }
+
+    @objc public func _isOnQueue() -> Bool {
+        return false
+    }
+
+    @objc public func on(_ event: String, listener: @escaping BGEventBusListener) -> String {
+        let token = UUID().uuidString
+        q.async(flags: .barrier) {
+            var listeners = self.listenersByEvent[event] as? [[String: Any]] ?? []
+            listeners.append(["token": token, "listener": listener])
+            self.listenersByEvent[event] = listeners
+        }
+        return token
+    }
+
+    @objc public func off(_ event: String, token: String) {
+        q.async(flags: .barrier) {
+            var listeners = self.listenersByEvent[event] as? [[String: Any]] ?? []
+            listeners.removeAll { ($0["token"] as? String) == token }
+            self.listenersByEvent[event] = listeners
+        }
+    }
+
+    @objc public func offAll(_ event: String) {
+        q.async(flags: .barrier) {
+            self.listenersByEvent.removeObject(forKey: event)
+        }
+    }
+
+    @objc public func offAll() {
+        q.async(flags: .barrier) {
+            self.listenersByEvent.removeAllObjects()
+        }
+    }
+
+    @objc public func emit(_ event: String, payload: Any?) {
+        q.sync {
+            guard let listeners = self.listenersByEvent[event] as? [[String: Any]] else { return }
+            for entry in listeners {
+                if let fn = entry["listener"] as? BGEventBusListener {
+                    fn(payload)
+                }
+            }
+        }
+    }
+
+    @objc public func trigger(_ event: String, payload: Any?) {
+        emit(event, payload: payload)
+    }
+
+    public func setListenersByEvent(_ dict: NSMutableDictionary) { listenersByEvent = dict }
+    public func setLocked(_ val: Bool) { locked = val }
+}