therms-device-tracker 1.0.0-rc.1

package/ios/GeofenceManager.swift

@@ -0,0 +1,221 @@
+import CoreLocation
+
+/// Protocol for testability of region monitoring (avoids direct hard dep on CLLocationManager).
+/// Allows injecting mocks in unit tests for GeofenceManager (see ThermsGeofenceTests.swift skeleton).
+protocol GeofenceRegionMonitoring: AnyObject {
+  func startMonitoring(for region: CLRegion)
+  func stopMonitoring(for region: CLRegion)
+}
+
+// Extend for seamless use with real CLLocationManager (follows existing patterns).
+extension CLLocationManager: GeofenceRegionMonitoring {}
+
+/// Focused manager for geofencing concerns (CLCircularRegion + monitoring).
+/// Follows the splitting direction started with LocationProvider.swift and ProviderMonitor.swift.
+///
+/// Responsibilities:
+/// - Add / remove / list geofences
+/// - Start/stop monitoring
+/// - Build geofence event payloads
+/// - Notify via simple callbacks (keeps the manager decoupled from sendEvent)
+///
+/// The main ThermsDeviceTrackerModule remains the CLLocationManagerDelegate and
+/// forwards region events here via the handle* methods.
+///
+/// Config notes: geofence section (enabled, proximityRadius) may be respected by caller (module)
+/// on ready/start; manager itself is config-agnostic for minimal surface. Persistence of regions
+/// via LocationStore (save/loadGeofences) for durability across restarts.
+final class GeofenceManager {
+  // Callbacks supplied by owner (the module)
+  var onGeofence: (([String: Any]) -> Void)?
+  var onGeofencesChange: (([String: Any]) -> Void)?
+
+  /// Direct provider for last location attachment (more direct than post-event mutation in owner).
+  /// Owner injects e.g. { [weak self] in self?.getLastLocationDict() }
+  var lastLocationProvider: (() -> [String: Any]?)?
+
+  private var monitoredRegions: [String: CLCircularRegion] = [:]
+  private var geofenceExtras: [String: [String: Any]] = [:]
+
+  // Uses protocol for testability (direct monitoring seam). Real CLLocationManager via extension.
+  private weak var regionMonitor: GeofenceRegionMonitoring?
+
+  // Store for geofence persistence (durability). Strong ref (module owns the store instance);
+  // weak would risk nil despite owner lifetime.
+  private var store: LocationStore?
+
+  init(monitor: GeofenceRegionMonitoring, store: LocationStore? = nil) {
+    self.regionMonitor = monitor
+    self.store = store
+    // Stub: could auto-restore here, but caller controls (e.g. on startGeofences)
+  }
+
+  // MARK: - Public API used by module
+
+  func addGeofence(from dict: [String: Any]) {
+    guard
+      let identifier = dict["identifier"] as? String,
+      let mon = regionMonitor,
+      let region = makeRegion(from: dict)
+    else { return } // silent no-op on bad input (consistent with prior behavior)
+
+    monitoredRegions[identifier] = region
+    if let extras = dict["extras"] as? [String: Any] {
+      geofenceExtras[identifier] = extras
+    }
+
+    if canMonitorRegions() {
+      mon.startMonitoring(for: region)
+    }
+
+    persistGeofences()
+    notifyGeofencesChange()
+  }
+
+  private func canMonitorRegions() -> Bool {
+    return CLLocationManager.isMonitoringAvailable(for: CLCircularRegion.self)
+  }
+
+  private func makeRegion(from dict: [String: Any]) -> CLCircularRegion? {
+    guard
+      let lat = dict["latitude"] as? Double,
+      let lon = dict["longitude"] as? Double,
+      let radius = dict["radius"] as? Double,
+      let identifier = dict["identifier"] as? String
+    else { return nil }
+    let region = CLCircularRegion(
+      center: CLLocationCoordinate2D(latitude: lat, longitude: lon),
+      radius: radius,
+      identifier: identifier
+    )
+    region.notifyOnEntry = (dict["notifyOnEntry"] as? Bool) ?? true
+    region.notifyOnExit = (dict["notifyOnExit"] as? Bool) ?? true
+    return region
+  }
+
+  func addGeofences(_ geofences: [[String: Any]]) {
+    for g in geofences {
+      addGeofence(from: g)
+    }
+  }
+
+  func removeGeofence(identifier: String) {
+    if let region = monitoredRegions.removeValue(forKey: identifier), let mon = regionMonitor {
+      mon.stopMonitoring(for: region)
+    }
+    geofenceExtras.removeValue(forKey: identifier)
+    persistGeofences()
+    notifyGeofencesChange()
+  }
+
+  func removeGeofences(identifiers: [String]?) {
+    if let ids = identifiers {
+      for id in ids {
+        removeGeofence(identifier: id)
+      }
+    } else {
+      stopAll()
+    }
+  }
+
+  func getGeofences() -> [[String: Any]] {
+    return monitoredRegions.map { (id, region) in
+      var d: [String: Any] = [
+        "identifier": id,
+        "latitude": region.center.latitude,
+        "longitude": region.center.longitude,
+        "radius": region.radius,
+        "notifyOnEntry": region.notifyOnEntry,
+        "notifyOnExit": region.notifyOnExit,
+      ]
+      if let ex = geofenceExtras[id] { d["extras"] = ex }
+      return d
+    }
+  }
+
+  func startMonitoring() {
+    guard let mon = regionMonitor else { return }
+    if !canMonitorRegions() { return }
+    for (_, region) in monitoredRegions {
+      mon.startMonitoring(for: region)
+    }
+  }
+
+  // MARK: - Delegate forwarding (called from main module)
+
+  func handleDidEnterRegion(_ region: CLRegion) {
+    guard let circular = region as? CLCircularRegion else { return }
+    let event = buildEvent(identifier: circular.identifier, action: "ENTER")
+    onGeofence?(event)
+  }
+
+  func handleDidExitRegion(_ region: CLRegion) {
+    guard let circular = region as? CLCircularRegion else { return }
+    let event = buildEvent(identifier: circular.identifier, action: "EXIT")
+    onGeofence?(event)
+  }
+
+  func handleDidDetermineState(_ state: CLRegionState, for region: CLRegion) {
+    // For now we only use enter/exit. Consumers can request state manually if needed.
+    // Future: could emit an initial "INSIDE" synthetic event.
+    _ = state
+    _ = region
+  }
+
+  // MARK: - Internal
+
+  private func buildEvent(identifier: String, action: String) -> [String: Any] {
+    var event: [String: Any] = [
+      "identifier": identifier,
+      "action": action,
+    ]
+    // Direct attachment via injected provider (fixes indirect pattern).
+    if let loc = lastLocationProvider?() {
+      event["location"] = loc
+    }
+    if let ex = geofenceExtras[identifier] {
+      event["extras"] = ex
+    }
+    return event
+  }
+
+  private func notifyGeofencesChange() {
+    let payload: [String: Any] = [
+      "on": getGeofences(),
+      "off": []
+    ]
+    onGeofencesChange?(payload)
+  }
+
+  private func stopAll() {
+    guard let mon = regionMonitor else { return }
+    for (_, region) in monitoredRegions {
+      mon.stopMonitoring(for: region)
+    }
+    monitoredRegions.removeAll()
+    geofenceExtras.removeAll()
+    persistGeofences()
+    notifyGeofencesChange()
+  }
+
+  // MARK: - Persistence (geofence durability via store)
+
+  private func persistGeofences() {
+    guard let s = store else { return }
+    s.saveGeofences(getGeofences())
+  }
+
+  /// Restore previously persisted geofences (call before startMonitoring for durability).
+  /// Populates memory only (avoids side-effect start); startMonitoring will activate.
+  func restorePersistedGeofences() {
+    guard let s = store else { return }
+    let saved = s.loadGeofences()
+    for g in saved {
+      guard let identifier = g["identifier"] as? String,
+            let region = makeRegion(from: g) else { continue }
+      monitoredRegions[identifier] = region
+      if let ex = g["extras"] as? [String: Any] { geofenceExtras[identifier] = ex }
+    }
+    // do not notify or start here; caller does
+  }
+}

package/ios/LocationProvider.swift

@@ -0,0 +1,32 @@
+import CoreLocation
+
+/// Extracted location management.
+/// Main ThermsDeviceTrackerModule (thin coordinator) delegates config, start/stop of
+/// location updates to this provider. Delegate ownership for didUpdate* remains on the module
+/// (parallel to how GeofenceManager receives forwarded region events).
+/// The provider's manager is shared with GeofenceManager via the region monitoring protocol.
+class LocationProvider {
+  let manager = CLLocationManager()
+
+  func configure(desiredAccuracy: CLLocationAccuracy, distanceFilter: CLLocationDistance) {
+    manager.desiredAccuracy = desiredAccuracy
+    manager.distanceFilter = distanceFilter
+  }
+
+  /// Apply background and pause settings prior to starting updates (from tracking options).
+  func applyBackgroundAndPauseSettings(allowsBackground: Bool, pausesAutomatically: Bool) {
+    manager.allowsBackgroundLocationUpdates = allowsBackground
+    manager.pausesLocationUpdatesAutomatically = pausesAutomatically
+  }
+
+  /// Starts location updates. Caller is responsible for checking locationServicesEnabled()
+  /// (to preserve error emission in module).
+  func startUpdatingLocation() {
+    manager.startUpdatingLocation()
+  }
+
+  func stopUpdating() {
+    manager.stopUpdatingLocation()
+    manager.allowsBackgroundLocationUpdates = false
+  }
+}

package/ios/LocationStore.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+/// Dedicated persistence for location history (and potentially geofences in future).
+/// Extracted to keep the main module thin and make the storage logic testable.
+///
+/// Uses UserDefaults for simplicity (no extra deps). In a production version
+/// a proper database (Core Data / SQLite via GRDB etc.) could replace this.
+///
+/// Follows testability pattern: accepts UserDefaults (default .standard) for injection in tests.
+/// See LocationProvider.swift style for focused extract.
+final class LocationStore {
+  private let defaults: UserDefaults
+  private let persistedLocationsKey = "ThermsPersistedLocations"
+  private let persistedGeofencesKey = "ThermsPersistedGeofences"
+  private let maxEntries = 500
+
+  init(defaults: UserDefaults = .standard) {
+    self.defaults = defaults
+  }
+
+  /// Returns persisted locations. Each record should have at least:
+  /// latitude, longitude, timestamp, and ideally an "id".
+  func load() -> [[String: Any]] {
+    guard let arr = defaults.array(forKey: persistedLocationsKey) as? [[String: Any]] else {
+      return []
+    }
+    return arr
+  }
+
+  private func save(_ list: [[String: Any]]) {
+    // Keep bounded
+    let pruned = list.suffix(maxEntries)
+    defaults.set(Array(pruned), forKey: persistedLocationsKey)
+  }
+
+  func clear() {
+    defaults.removeObject(forKey: persistedLocationsKey)
+  }
+
+  /// Insert a location. Ensures an "id" (UUID string) exists for reliable destroy.
+  func insert(_ location: [String: Any]) {
+    var record = location
+    if record["id"] == nil {
+      record["id"] = UUID().uuidString
+    }
+    var current = load()
+    current.append(record)
+    save(current)
+  }
+
+  /// Remove by stable id. Improved removal: requires id (no legacy pop/clear fallback inside).
+  /// Callers (module) branch to clear() when no id for destroyLocation.
+  /// Legacy records w/o id tolerated (ignored on filter).
+  func remove(byId id: String?) {
+    guard let targetId = id else { return }
+
+    var current = load()
+    current.removeAll { rec in
+      if let existing = rec["id"] as? String {
+        return existing == targetId
+      }
+      return false
+    }
+    save(current)
+  }
+
+  func count() -> Int {
+    return load().count
+  }
+
+  /// Convenience to get all persisted (used by getLocations merge).
+  func getAll() -> [[String: Any]] {
+    return load()
+  }
+
+  // MARK: - Geofence persistence (for durability / restore across restarts)
+  // Lightweight array-of-dicts (geofences unbounded for now; expected small count; see locations for maxEntries).
+  // Used by GeofenceManager. Follows same UserDefaults pattern.
+
+  func loadGeofences() -> [[String: Any]] {
+    guard let arr = defaults.array(forKey: persistedGeofencesKey) as? [[String: Any]] else {
+      return []
+    }
+    return arr
+  }
+
+  func saveGeofences(_ geofences: [[String: Any]]) {
+    defaults.set(geofences, forKey: persistedGeofencesKey)
+  }
+
+  func clearGeofences() {
+    defaults.removeObject(forKey: persistedGeofencesKey)
+  }
+}
+
+// Conform to SyncDataSource protocol (simple seam for SyncManager testability/injection; no behavior change).
+// Sync always reads via getAll() at execution (live for batch/immediate).
+extension LocationStore: SyncDataSource {}

package/ios/MotionActivityProvider.swift

@@ -0,0 +1,109 @@
+import CoreMotion
+
+/// Focused provider for motion activity + pedometer (mirrors GeofenceManager / ScheduleManager seams).
+///
+/// Extracted to keep the main module thin (following LocationProvider + ProviderMonitor direction).
+/// Responsibilities:
+/// - Start/stop CMMotionActivityManager + CMPedometer updates.
+/// - Map native records to dicts.
+/// - Emit via callbacks (`onActivityUpdate`, `onPedometerUpdate`) — module wires `sendEvent`.
+///
+/// Injection / test seam precedent: callbacks + error closure (no direct sendEvent).
+/// Session state (append) remains in the coordinator.
+final class MotionActivityProvider {
+  var onActivityUpdate: (([String: Any]) -> Void)?
+  var onPedometerUpdate: (([String: Any]) -> Void)?
+  var onError: ((String, String) -> Void)?
+
+  private var activityManager = CMMotionActivityManager()
+  private var pedometer = CMPedometer()
+
+  private var enableActivity = true
+  private var enablePedometer = true
+
+  func configure(enableActivity: Bool, enablePedometer: Bool) {
+    self.enableActivity = enableActivity
+    self.enablePedometer = enablePedometer
+  }
+
+  func start() {
+    if enableActivity && CMMotionActivityManager.isActivityAvailable() {
+      activityManager.startActivityUpdates(to: .main) { [weak self] activity in
+        guard let self = self, let activity = activity else { return }
+        let record = self.mapActivity(activity)
+        self.onActivityUpdate?(self.activityRecordToDict(record))
+      }
+    }
+
+    if enablePedometer && CMPedometer.isStepCountingAvailable() {
+      pedometer.startUpdates(from: Date()) { [weak self] data, error in
+        guard let self = self, let data = data else { return }
+        if let error = error {
+          self.onError?("pedometer_error", error.localizedDescription)
+          return
+        }
+        let record = self.makePedometerRecord(data)
+        self.onPedometerUpdate?(self.pedometerRecordToDict(record))
+      }
+    }
+  }
+
+  func stop() {
+    if CMMotionActivityManager.isActivityAvailable() {
+      activityManager.stopActivityUpdates()
+    }
+    if CMPedometer.isStepCountingAvailable() {
+      pedometer.stopUpdates()
+    }
+  }
+
+  // Internal mapping (moved from module)
+  private struct ActivityRecord {
+    let type: String
+    let confidence: Double
+    let timestamp: Double
+  }
+
+  private struct PedometerRecord {
+    let steps: Int
+    let distance: Double?
+    let floorsAscended: Int?
+    let floorsDescended: Int?
+    let timestamp: Double
+  }
+
+  private func mapActivity(_ activity: CMMotionActivity) -> ActivityRecord {
+    let type: String
+    if activity.stationary { type = "still" }
+    else if activity.walking { type = "walking" }
+    else if activity.running { type = "running" }
+    else if activity.cycling { type = "cycling" }
+    else if activity.automotive { type = "automotive" }
+    else { type = "unknown" }
+
+    let conf = Double(activity.confidence.rawValue) / 2.0
+    return ActivityRecord(type: type, confidence: conf, timestamp: Date().timeIntervalSince1970 * 1000)
+  }
+
+  private func makePedometerRecord(_ data: CMPedometerData) -> PedometerRecord {
+    return PedometerRecord(
+      steps: data.numberOfSteps.intValue,
+      distance: data.distance?.doubleValue,
+      floorsAscended: data.floorsAscended?.intValue,
+      floorsDescended: data.floorsDescended?.intValue,
+      timestamp: Date().timeIntervalSince1970 * 1000
+    )
+  }
+
+  private func activityRecordToDict(_ r: ActivityRecord) -> [String: Any] {
+    return ["type": r.type, "confidence": r.confidence, "timestamp": r.timestamp]
+  }
+
+  private func pedometerRecordToDict(_ r: PedometerRecord) -> [String: Any] {
+    var d: [String: Any] = ["steps": r.steps, "timestamp": r.timestamp]
+    if let v = r.distance { d["distance"] = v }
+    if let v = r.floorsAscended { d["floorsAscended"] = v }
+    if let v = r.floorsDescended { d["floorsDescended"] = v }
+    return d
+  }
+}

package/ios/ProviderMonitor.swift

@@ -0,0 +1,33 @@
+import CoreLocation
+
+/// Dedicated provider / authorization monitoring.
+/// The thin coordinator (ThermsDeviceTrackerModule) delegates provider state to this
+/// for getProviderState() and onProviderChange. Pass the active manager (preferred)
+/// for accuracyAuthorization (iOS14+); falls back to temp instance if omitted.
+struct ProviderMonitor {
+  static func currentState(using manager: CLLocationManager? = nil) -> [String: Any] {
+    // Use instance-based API for authorizationStatus (CLLocationManager.authorizationStatus() class method is deprecated since iOS 14).
+    // locationServicesEnabled() remains a class method as it is a system-wide setting.
+    let lm = manager ?? CLLocationManager()
+    let servicesEnabled = CLLocationManager.locationServicesEnabled()
+    let auth = lm.authorizationStatus
+    let status: String
+    switch auth {
+    case .notDetermined: status = "not_determined"
+    case .restricted: status = "restricted"
+    case .denied: status = "denied"
+    case .authorizedAlways: status = "always"
+    case .authorizedWhenInUse: status = "when_in_use"
+    @unknown default: status = "not_determined"
+    }
+
+    var dict: [String: Any] = [
+      "enabled": servicesEnabled,
+      "status": status,
+    ]
+    // iOS 14+ accuracyAuthorization always available (min iOS 16.4)
+    let acc = lm.accuracyAuthorization
+    dict["accuracyAuthorization"] = (acc == .fullAccuracy) ? "full" : "reduced"
+    return dict
+  }
+}

package/ios/ScheduleManager.swift

@@ -0,0 +1,33 @@
+import Foundation
+
+/// Very lightweight scheduler manager.
+/// In a more complete implementation this would parse schedule windows from config
+/// and coordinate with background modes / BGTaskScheduler.
+///
+/// Accepts config for testability/configurability. Better notes on background limitations.
+final class ScheduleManager {
+  var onSchedule: (([String: Any]) -> Void)?
+
+  private var timer: Timer?
+
+  /// Start with optional config (e.g. from ThermsConfig.schedule). Configurable heartbeat interval.
+  /// NOTE: This uses NSTimer (foreground only for demo). For true background schedules on iOS,
+  /// use BGTaskScheduler + BGAppRefresh / Background Modes (see background config + enable).
+  /// Config keys honored: "interval" (seconds, default 60).
+  func start(config: [String: Any]? = nil) {
+    stop()
+    onSchedule?(["state": "started"])
+
+    let interval = (config?["interval"] as? TimeInterval) ?? 60.0
+    // Demo heartbeat. Real schedules evaluate time-of-day rules and call start/stopTracking.
+    timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
+      self?.onSchedule?(["state": "heartbeat"])
+    }
+  }
+
+  func stop() {
+    timer?.invalidate()
+    timer = nil
+    onSchedule?(["state": "stopped"])
+  }
+}