react-native-bg-geolocation 0.2.0

package/ios/engine/BGSchedule.swift

@@ -0,0 +1,228 @@
+import Foundation
+
+@objc public final class BGSchedule: NSObject {
+
+    @objc public var days: NSMutableArray
+    @objc public private(set) var isLiteralDate: Bool = false
+    private var hasTriggered: Bool = false
+    private var datePattern: String
+    private var calendar: NSCalendar
+    @objc public var triggered: Bool = false
+    @objc public var onTime: NSDateComponents?
+    @objc public var onDate: Date?
+    @objc public var offTime: NSDateComponents?
+    @objc public var offDate: Date?
+    @objc public var trackingMode: Int = 1
+    @objc public var handlerBlock: (() -> Void)?
+
+    @objc public init(record: String) {
+        self.days = NSMutableArray()
+        self.triggered = false
+        self.hasTriggered = false
+        self.trackingMode = 1
+        self.datePattern = "^\\d{4}-\\d{2}-\\d{2}.*"
+
+        let cal = NSCalendar(calendarIdentifier: .gregorian)!
+        cal.locale = Locale(identifier: "en_US")
+        cal.timeZone = NSTimeZone.local
+        self.calendar = cal
+
+        let onComponents = NSDateComponents()
+        let offComponents = NSDateComponents()
+        self.onTime = onComponents
+        self.offTime = offComponents
+
+        super.init()
+
+        let parts = NSMutableArray(array: record.components(separatedBy: " "))
+        guard parts.count > 0, let part0 = parts.object(at: 0) as? String else { return }
+
+        if part0.contains("-") {
+            let isDate = part0.range(of: datePattern, options: .regularExpression) != nil
+            if isDate {
+                isLiteralDate = true
+                let dateComponents = part0.components(separatedBy: "-")
+                onComponents.year = Int(dateComponents[0]) ?? 0
+                onComponents.month = Int(dateComponents[1]) ?? 0
+                onComponents.day = Int(dateComponents[2]) ?? 0
+
+                if parts.count > 1, let part1 = parts.object(at: 1) as? String {
+                    if part1.range(of: datePattern, options: .regularExpression) != nil {
+                        offComponents.year = onComponents.year
+                        offComponents.month = onComponents.month
+                        offComponents.day = onComponents.day
+                    } else {
+                        let off = part1.components(separatedBy: "-")
+                        offComponents.year = Int(off[0]) ?? 0
+                        offComponents.month = Int(off[1]) ?? 0
+                        offComponents.day = Int(off[2]) ?? 0
+                        if dateComponents.count > 3 && off.count > 3 {
+                            parts[1] = String(format: "%@-%@", dateComponents[3], off[3])
+                        }
+                    }
+                }
+            } else {
+                // Numeric day range "from-to".
+                let range = part0.components(separatedBy: "-")
+                let from = Int(range[0]) ?? 0
+                let to = Int(range[1]) ?? 0
+                if from <= to {
+                    for day in from...to {
+                        days.add(NSNumber(value: day))
+                    }
+                }
+            }
+        } else {
+            // Comma-separated day list.
+            for dayStr in part0.components(separatedBy: ",") {
+                days.add(NSNumber(value: Int(dayStr) ?? 0))
+            }
+        }
+
+        // Parse time window from parts[1] ("HH:MM-HH:MM").
+        if parts.count > 1, let part1 = parts.object(at: 1) as? String {
+            let timeRange = part1.components(separatedBy: "-")
+            if timeRange.count >= 2 {
+                let onParts = timeRange[0].components(separatedBy: ":")
+                onComponents.hour = Int(onParts[0]) ?? 0
+                onComponents.minute = onParts.count > 1 ? (Int(onParts[1]) ?? 0) : 0
+                let offParts = timeRange[1].components(separatedBy: ":")
+                offComponents.hour = Int(offParts[0]) ?? 0
+                offComponents.minute = offParts.count > 1 ? (Int(offParts[1]) ?? 0) : 0
+            }
+        }
+
+        if isLiteralDate {
+            onDate = calendar.date(from: onComponents as DateComponents)
+            offDate = calendar.date(from: offComponents as DateComponents)
+            if let onDate = onDate, let offDate = offDate,
+               (offDate as NSDate).earlierDate(onDate) == offDate {
+                let oneDay = NSDateComponents()
+                oneDay.day = 1
+                self.offDate = calendar.date(byAdding: oneDay as DateComponents, to: offDate, options: [])
+            }
+        }
+
+        if parts.count >= 3, let part2 = parts.object(at: 2) as? String {
+            if part2.contains("geofence") {
+                trackingMode = 0
+            }
+        }
+    }
+
+    @objc public func evaluate() -> Date {
+        let now = Date()
+        if triggered {
+            if (now as NSDate).laterDate(offDate ?? now) == now {
+                trigger(false)
+            }
+        } else {
+            if let onDate = onDate, (now as NSDate).laterDate(onDate) == now {
+                let withinWindow = (now as NSDate).earlierDate(offDate ?? now) == now
+                trigger(withinWindow)
+            }
+        }
+        return now
+    }
+
+    @objc public func trigger(_ state: Bool) {
+        if hasTriggered && triggered == state {
+            return
+        }
+        let logger = BGLog.sharedInstance()
+        if state {
+            if logger.shouldLog(5) {
+                let message = String(format: "%@", description)
+                logger.log(5, tag: 3, function: "-[BGSchedule trigger:]", message: message)
+            }
+        } else {
+            if logger.shouldLog(3) {
+                let message = String(format: "%@", description)
+                logger.log(3, tag: 5, function: "-[BGSchedule trigger:]", message: message)
+            }
+        }
+        hasTriggered = true
+        triggered = state
+
+        let state = BGConfig.sharedInstance().toDictionary()
+        let event = BGScheduleEvent(schedule: self, state: state)
+        BGEventBus.sharedInstance().trigger(BGEventNameSchedule, payload: event)
+        BGEventManager.sharedInstance().trigger(BGEventNameSchedule, payload: event)
+    }
+
+    @objc public func make(_ components: NSDateComponents) {
+        guard !isLiteralDate else { return }
+        onTime?.year = components.year
+        onTime?.month = components.month
+        onTime?.day = components.day
+        onDate = calendar.date(from: (onTime ?? NSDateComponents()) as DateComponents)
+
+        offTime?.year = components.year
+        offTime?.month = components.month
+        offTime?.day = components.day
+        offDate = calendar.date(from: (offTime ?? NSDateComponents()) as DateComponents)
+
+        if let onDate = onDate, let offDate = offDate,
+           (offDate as NSDate).earlierDate(onDate) == offDate {
+            let oneDay = NSDateComponents()
+            oneDay.day = 1
+            self.offDate = calendar.date(byAdding: oneDay as DateComponents, to: offDate, options: [])
+        }
+    }
+
+    @objc public func isNext(_ date: Date) -> Bool {
+        let comps = calendar.components([.year, .month, .day, .hour, .minute, .weekday], from: date)
+        if !isLiteralDate {
+            make(comps as NSDateComponents)
+            if !hasDay(comps.weekday ?? 0) {
+                return false
+            }
+        }
+        guard let offDate = offDate else { return false }
+        return (date as NSDate).earlierDate(offDate) == date
+    }
+
+    @objc public func reset() {
+        hasTriggered = false
+    }
+
+    @objc public func expired() -> Bool {
+        let now = Date()
+        guard let offDate = offDate else { return false }
+        return (now as NSDate).laterDate(offDate) == now
+    }
+
+    @objc public func startsBefore(_ date: Date) -> Bool {
+        guard let onDate = onDate else { return false }
+        return (onDate as NSDate).earlierDate(date) == onDate
+    }
+
+    @objc public func startsAfter(_ date: Date) -> Bool {
+        guard let onDate = onDate else { return false }
+        return (onDate as NSDate).earlierDate(date) == date
+    }
+
+    @objc public func endsBefore(_ date: Date) -> Bool {
+        guard let offDate = offDate else { return false }
+        return (offDate as NSDate).earlierDate(date) == offDate
+    }
+
+    @objc public func endsAfter(_ date: Date) -> Bool {
+        guard let offDate = offDate else { return false }
+        return (offDate as NSDate).earlierDate(date) == date
+    }
+
+    @objc public func hasDay(_ weekday: Int) -> Bool {
+        return days.contains(NSNumber(value: weekday))
+    }
+
+    public override var description: String {
+        let onHour = onTime?.hour ?? 0
+        let onMinute = onTime?.minute ?? 0
+        let offHour = offTime?.hour ?? 0
+        let offMinute = offTime?.minute ?? 0
+        let daysString = days.componentsJoined(by: ",")
+        return String(format: "BGSchedule[triggered:%d, %02ld:%02ld - %02ld:%02ld, Days:%@, trackingMode:%d]",
+                      triggered, onHour, onMinute, offHour, offMinute, daysString, trackingMode)
+    }
+}

package/ios/engine/BGScheduleEvent.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+@objc public final class BGScheduleEvent: NSObject {
+
+    @objc public private(set) var schedule: BGSchedule?
+    @objc public private(set) var state: Any?
+
+    @objc public init(schedule: BGSchedule?, state: Any?) {
+        self.schedule = schedule
+        self.state = state
+        super.init()
+    }
+}

package/ios/engine/BGScheduler.swift

@@ -0,0 +1,116 @@
+import Foundation
+
+@objc public class BGScheduler: NSObject {
+
+    private static var _sharedInstance: BGScheduler?
+    private static let lock = NSLock()
+
+    private var scheduleRules: [BGScheduleRule] = []
+    private var timer: Timer?
+    private var enabled: Bool = false
+
+    @objc public class func sharedInstance() -> BGScheduler {
+        lock.lock()
+        defer { lock.unlock() }
+        if _sharedInstance == nil {
+            _sharedInstance = BGScheduler()
+        }
+        return _sharedInstance!
+    }
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public func start(withSchedule schedule: [String]) -> Bool {
+        stop()
+        scheduleRules = schedule.compactMap { BGScheduleRule(rule: $0) }
+        guard !scheduleRules.isEmpty else { return false }
+        enabled = true
+        startTimer()
+        return true
+    }
+
+    @objc public func stop() {
+        timer?.invalidate()
+        timer = nil
+        enabled = false
+    }
+
+    @objc public func isEnabled() -> Bool {
+        return enabled
+    }
+
+    @objc public func isTracking() -> Bool {
+        guard enabled else { return false }
+        let now = Date()
+        return scheduleRules.contains { $0.isActiveAt(now) }
+    }
+
+    @objc public func nextScheduledDate() -> Date? {
+        let now = Date()
+        return scheduleRules.compactMap { $0.nextTriggerDate(after: now) }.min()
+    }
+
+    private func startTimer() {
+        timer = Timer.scheduledTimer(timeInterval: 60.0,
+                                     target: self,
+                                     selector: #selector(evaluate),
+                                     userInfo: nil,
+                                     repeats: true)
+    }
+
+    @objc private func evaluate() {
+        let tracking = isTracking()
+        NotificationCenter.default.post(
+            name: NSNotification.Name("BGSchedulerEvaluated"),
+            object: self,
+            userInfo: ["tracking": tracking]
+        )
+    }
+}
+
+private class BGScheduleRule {
+    let raw: String
+    let startHour: Int
+    let startMinute: Int
+    let endHour: Int
+    let endMinute: Int
+    let weekdays: [Int]
+
+    init?(rule: String) {
+        raw = rule
+        let parts = rule.components(separatedBy: " ")
+        guard parts.count >= 2 else { return nil }
+        let timePart = parts[0].components(separatedBy: "-")
+        guard timePart.count == 2 else { return nil }
+        let startParts = timePart[0].components(separatedBy: ":")
+        let endParts = timePart[1].components(separatedBy: ":")
+        guard startParts.count == 2, endParts.count == 2 else { return nil }
+        startHour = Int(startParts[0]) ?? 0
+        startMinute = Int(startParts[1]) ?? 0
+        endHour = Int(endParts[0]) ?? 0
+        endMinute = Int(endParts[1]) ?? 0
+        weekdays = parts.dropFirst().compactMap { Int($0) }
+    }
+
+    func isActiveAt(_ date: Date) -> Bool {
+        let cal = Calendar.current
+        let weekday = cal.component(.weekday, from: date)
+        if !weekdays.isEmpty && !weekdays.contains(weekday) { return false }
+        let hour = cal.component(.hour, from: date)
+        let minute = cal.component(.minute, from: date)
+        let current = hour * 60 + minute
+        let start = startHour * 60 + startMinute
+        let end = endHour * 60 + endMinute
+        if start <= end {
+            return current >= start && current < end
+        } else {
+            return current >= start || current < end
+        }
+    }
+
+    func nextTriggerDate(after date: Date) -> Date? {
+        return nil
+    }
+}

package/ios/engine/BGSingleLocationRequest.swift

@@ -0,0 +1,49 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGSingleLocationRequest: NSObject {
+
+    @objc public var type: String = "single"
+    @objc public var maximumAge: Double = 0
+    @objc public var timeout: Double = 30
+    @objc public var desiredAccuracy: CLLocationAccuracy = kCLLocationAccuracyBest
+    @objc public var allowStale: Bool = false
+    @objc public var samples: Int = 1
+    @objc public var label: String?
+    @objc public var persist: Bool = false
+    @objc public var extras: [AnyHashable: Any]?
+    @objc public var success: ((Any?) -> Void)?
+    @objc public var failure: ((Int) -> Void)?
+    @objc public var requestId: String = UUID().uuidString
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public init(
+        type: String,
+        maximumAge: Double,
+        timeout: Double,
+        desiredAccuracy: CLLocationAccuracy,
+        allowStale: Bool,
+        samples: Int,
+        label: String?,
+        persist: Bool,
+        extras: [AnyHashable: Any]?,
+        success: @escaping (Any?) -> Void,
+        failure: @escaping (Int) -> Void
+    ) {
+        self.type = type
+        self.maximumAge = maximumAge
+        self.timeout = timeout
+        self.desiredAccuracy = desiredAccuracy
+        self.allowStale = allowStale
+        self.samples = samples
+        self.label = label
+        self.persist = persist
+        self.extras = extras
+        self.success = success
+        self.failure = failure
+        super.init()
+    }
+}

package/ios/engine/BGStreamLocationRequest.swift

@@ -0,0 +1,42 @@
+import Foundation
+import CoreLocation
+
+@objc public class BGStreamLocationRequest: NSObject {
+
+    @objc public var streamId: Int = 0
+    @objc public var interval: Double = 1000.0
+    @objc public var desiredAccuracy: CLLocationAccuracy = kCLLocationAccuracyBest
+    @objc public var timeout: Double = 60.0
+    @objc public var persist: Bool = true
+    @objc public var extras: [AnyHashable: Any]?
+    @objc public var label: String?
+    @objc public var success: ((Any?) -> Void)?
+    @objc public var failure: ((Int) -> Void)?
+
+    @objc public override init() {
+        super.init()
+    }
+
+    @objc public init(
+        streamId: Int,
+        interval: Double,
+        desiredAccuracy: CLLocationAccuracy,
+        timeout: Double,
+        persist: Bool,
+        extras: [AnyHashable: Any]?,
+        label: String?,
+        success: @escaping (Any?) -> Void,
+        failure: @escaping (Int) -> Void
+    ) {
+        self.streamId = streamId
+        self.interval = interval
+        self.desiredAccuracy = desiredAccuracy
+        self.timeout = timeout
+        self.persist = persist
+        self.extras = extras
+        self.label = label
+        self.success = success
+        self.failure = failure
+        super.init()
+    }
+}

package/ios/engine/BGTemplate.swift

@@ -0,0 +1,54 @@
+import Foundation
+
+@objc public class BGTemplate: NSObject {
+
+    @objc public var name: String
+    @objc public var content: [String: Any]
+
+    @objc public init(name: String, content: [String: Any]) {
+        self.name = name
+        self.content = content
+        super.init()
+    }
+
+    @objc public override init() {
+        name = ""
+        content = [:]
+        super.init()
+    }
+
+    @objc public func render(with data: [String: Any]) -> [String: Any] {
+        var result: [String: Any] = [:]
+        for (key, value) in content {
+            if let strVal = value as? String {
+                result[key] = interpolate(strVal, with: data)
+            } else {
+                result[key] = value
+            }
+        }
+        return result
+    }
+
+    private func interpolate(_ template: String, with data: [String: Any]) -> String {
+        var result = template
+        let pattern = "<%=\\s*(.+?)\\s*%>"
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return template }
+        let range = NSRange(template.startIndex..., in: template)
+        let matches = regex.matches(in: template, range: range)
+        for match in matches.reversed() {
+            if let keyRange = Range(match.range(at: 1), in: template) {
+                let key = String(template[keyRange])
+                if let val = data[key] {
+                    if let matchRange = Range(match.range, in: result) {
+                        result.replaceSubrange(matchRange, with: "\(val)")
+                    }
+                }
+            }
+        }
+        return result
+    }
+
+    @objc public override var description: String {
+        return "<BGTemplate name=\(name)>"
+    }
+}

package/ios/engine/BGTimerService.swift

@@ -0,0 +1,46 @@
+import Foundation
+
+@objc public class BGTimerService: NSObject {
+
+    private var timers: [String: Timer] = [:]
+    private let lock = NSLock()
+
+    @objc public func scheduleTimer(
+        _ id: String,
+        interval: TimeInterval,
+        repeats: Bool,
+        block: @escaping () -> Void
+    ) {
+        lock.lock()
+        timers[id]?.invalidate()
+        let timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: repeats) { _ in
+            block()
+        }
+        timers[id] = timer
+        lock.unlock()
+    }
+
+    @objc public func cancelTimer(_ id: String) {
+        lock.lock()
+        timers[id]?.invalidate()
+        timers.removeValue(forKey: id)
+        lock.unlock()
+    }
+
+    @objc public func cancelAllTimers() {
+        lock.lock()
+        timers.values.forEach { $0.invalidate() }
+        timers.removeAll()
+        lock.unlock()
+    }
+
+    @objc public func hasTimer(_ id: String) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return timers[id]?.isValid ?? false
+    }
+
+    @objc public func isRunning(_ id: String) -> Bool {
+        return hasTimer(id)
+    }
+}