@wayq/beekon-rn 0.0.1 → 0.0.5

package/ios/BeekonRn.swift

@@ -1,209 +1,489 @@
 import Foundation
 import BeekonKit
 
-/// Swift impl of the Beekon RN TurboModule. Bridges the actor-based native
-/// SDK (`BeekonKit.Beekon.shared`) to the ObjC TurboModule conformance in
+/// Swift impl of the Beekon RN TurboModule. Bridges the actor-based native SDK
+/// (`BeekonKit.Beekon.shared`) to the ObjC TurboModule conformance in
 /// `BeekonRn.mm`. All public-facing methods take ObjC-compatible callbacks
-/// (resolver/rejecter) and dictionaries so they can be invoked from `.mm`.
+/// (resolver/rejecter) and dictionaries/arrays so they can be invoked from `.mm`.
 ///
-/// Event delivery: `BeekonRn.mm` constructs this with two closures that call
-/// the codegen-generated `emitOnState:` / `emitOnPosition:` ObjC methods on
-/// the spec; the closures are invoked from the per-stream `Task`s started
-/// during `initialize`.
-@objc public final class BeekonRnImpl: NSObject {
+/// Event delivery: `BeekonRn.mm` constructs this with four closures that call
+/// the codegen `emitOnState:` / `emitOnLocation:` / `emitOnGeofenceEvent:` /
+/// `emitOnSyncStatus:` ObjC methods; the closures are invoked from per-stream
+/// `Task`s started during init.
+//
+// `@unchecked Sendable` is correct here: the four emit closures are immutable
+// `let`s, and the stream `Task`s are mutated only from init/invalidate which run
+// sequentially. NSObject can't be auto-Sendable and `@objc` rules out `actor`,
+// so this is the path. Non-Sendable wire inputs (NSDictionary/NSArray) are
+// converted to Sendable Beekon types *before* crossing into any `Task`.
+@objc public final class BeekonRnImpl: NSObject, @unchecked Sendable {
 
   private let onStateCb: (NSDictionary) -> Void
-  private let onPositionCb: (NSDictionary) -> Void
+  private let onLocationCb: (NSDictionary) -> Void
+  private let onGeofenceEventCb: (NSDictionary) -> Void
+  private let onSyncStatusCb: (NSDictionary) -> Void
 
   private var stateTask: Task<Void, Never>?
-  private var positionsTask: Task<Void, Never>?
+  private var locationsTask: Task<Void, Never>?
+  private var geofenceEventsTask: Task<Void, Never>?
+  private var syncStatusTask: Task<Void, Never>?
 
   @objc public init(
     onState: @escaping (NSDictionary) -> Void,
-    onPosition: @escaping (NSDictionary) -> Void
+    onLocation: @escaping (NSDictionary) -> Void,
+    onGeofenceEvent: @escaping (NSDictionary) -> Void,
+    onSyncStatus: @escaping (NSDictionary) -> Void
   ) {
     self.onStateCb = onState
-    self.onPositionCb = onPosition
+    self.onLocationCb = onLocation
+    self.onGeofenceEventCb = onGeofenceEvent
+    self.onSyncStatusCb = onSyncStatus
     super.init()
+    self.stateTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await state in await Beekon.shared.state {
+        self.onStateCb(self.stateToWire(state))
+      }
+    }
+    self.locationsTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await loc in await Beekon.shared.locations {
+        self.onLocationCb(self.locationToWire(loc))
+      }
+    }
+    self.geofenceEventsTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await event in await Beekon.shared.geofenceEvents {
+        self.onGeofenceEventCb(self.geofenceEventToWire(event))
+      }
+    }
+    self.syncStatusTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await status in await Beekon.shared.syncStatus {
+        self.onSyncStatusCb(self.syncStatusToWire(status))
+      }
+    }
+  }
+
+  @objc public func invalidate() {
+    stateTask?.cancel()
+    locationsTask?.cancel()
+    geofenceEventsTask?.cancel()
+    syncStatusTask?.cancel()
+    stateTask = nil
+    locationsTask = nil
+    geofenceEventsTask = nil
+    syncStatusTask = nil
+  }
+
+  /// Register Beekon's background-refresh task and install cold-launch hooks.
+  /// Must be called once, synchronously, during app launch (before
+  /// `didFinishLaunchingWithOptions` returns) — invoke from the host AppDelegate.
+  @objc public static func registerBackgroundTasks() {
+    Beekon.registerBackgroundTasks()
+    // Touch the shared actor so its cold-launch resume hooks install.
+    _ = Beekon.shared
   }
 
   // MARK: - Lifecycle
 
-  @objc public func initializeWithResolver(
-    _ resolve: @escaping (Any?) -> Void,
-    rejecter reject: @escaping (String?, String?, Error?) -> Void
+  @objc public func configure(
+    _ config: NSDictionary,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    // Convert the non-Sendable NSDictionary to a Sendable BeekonConfig before
+    // crossing into the Task closure.
+    let cfg = wireToConfig(config)
+    Task {
+      await Beekon.shared.configure(cfg)
+      resolve(nil)
+    }
+  }
+
+  @objc public func startWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    // start() never throws — outcome surfaces on the `state` stream.
+    Task {
+      await Beekon.shared.start()
+      resolve(nil)
+    }
+  }
+
+  @objc public func stopWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task {
+      await Beekon.shared.stop()
+      resolve(nil)
+    }
+  }
+
+  @objc public func resumeIfNeededWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task {
+      await Beekon.shared.resumeIfNeeded()
+      resolve(nil)
+    }
+  }
+
+  // MARK: - History
+
+  @objc public func getLocationsFromMs(
+    _ fromMs: Double,
+    toMs: Double,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
   ) {
     Task { [weak self] in
       guard let self = self else { return }
       do {
-        try await Beekon.shared.initialize()
-        // Idempotent: cancel any prior collectors before starting new ones.
-        self.stateTask?.cancel()
-        self.positionsTask?.cancel()
-        self.stateTask = Task { [weak self] in
-          guard let self = self else { return }
-          for await state in await Beekon.shared.state {
-            self.onStateCb(self.stateToWire(state))
-          }
-        }
-        self.positionsTask = Task { [weak self] in
-          guard let self = self else { return }
-          for await pos in await Beekon.shared.positions {
-            self.onPositionCb(self.positionToWire(pos))
-          }
-        }
-        resolve(nil)
+        let from = Date(timeIntervalSince1970: fromMs / 1000.0)
+        let to = Date(timeIntervalSince1970: toMs / 1000.0)
+        let locations = try await Beekon.shared.getLocations(from: from, to: to)
+        resolve(locations.map { self.locationToWire($0) })
       } catch {
         reject(self.errorCode(error), error.localizedDescription, error)
       }
     }
   }
 
-  @objc public func configure(
-    _ config: NSDictionary,
-    resolver resolve: @escaping RCTPromiseResolveBlock,
-    rejecter reject: @escaping RCTPromiseRejectBlock
+  @objc public func deleteLocationsBeforeMs(
+    _ beforeMs: Double,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
   ) {
     Task { [weak self] in
       guard let self = self else { return }
       do {
-        let cfg = try self.wireToConfig(config)
-        await Beekon.shared.configure(cfg)
-        resolve(nil)
+        // Negative is the wire sentinel for "delete all" (no cutoff).
+        let before: Date? =
+          beforeMs < 0 ? nil : Date(timeIntervalSince1970: beforeMs / 1000.0)
+        let count = try await Beekon.shared.deleteLocations(before: before)
+        resolve(count)
       } catch {
         reject(self.errorCode(error), error.localizedDescription, error)
       }
     }
   }
 
-  @objc public func startWithResolver(
-    _ resolve: @escaping (Any?) -> Void,
-    rejecter reject: @escaping (String?, String?, Error?) -> Void
+  @objc public func pendingUploadCountWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
   ) {
     Task { [weak self] in
       guard let self = self else { return }
       do {
-        try await Beekon.shared.start()
-        resolve(nil)
+        let count = try await Beekon.shared.pendingUploadCount()
+        resolve(count)
       } catch {
         reject(self.errorCode(error), error.localizedDescription, error)
       }
     }
   }
 
-  @objc public func stopWithResolver(
-    _ resolve: @escaping (Any?) -> Void,
-    rejecter reject: @escaping (String?, String?, Error?) -> Void
+  // MARK: - Sync
+
+  @objc public func syncWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
   ) {
-    Task { [weak self] in
-      guard let self = self else { return }
-      await Beekon.shared.stop()
+    Task {
+      await Beekon.shared.sync()
       resolve(nil)
     }
   }
 
-  @objc public func shutdownWithResolver(
-    _ resolve: @escaping (Any?) -> Void,
-    rejecter reject: @escaping (String?, String?, Error?) -> Void
+  @objc public func setExtras(
+    _ entries: NSArray,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
   ) {
-    Task { [weak self] in
-      guard let self = self else { return }
-      self.stateTask?.cancel()
-      self.positionsTask?.cancel()
-      await Beekon.shared.shutdown()
+    let extras = entriesToDict(entries)
+    Task {
+      await Beekon.shared.setExtras(extras)
       resolve(nil)
     }
   }
 
-  @objc public func historyFromMs(
-    _ fromMs: Double,
-    toMs: Double,
-    resolver resolve: @escaping RCTPromiseResolveBlock,
-    rejecter reject: @escaping RCTPromiseRejectBlock
+  // MARK: - Geofences
+
+  @objc public func addGeofences(
+    _ geofences: NSArray,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
   ) {
+    let list = wireToGeofences(geofences)
     Task { [weak self] in
       guard let self = self else { return }
       do {
-        let from = Date(timeIntervalSince1970: fromMs / 1000.0)
-        let to = Date(timeIntervalSince1970: toMs / 1000.0)
-        let positions = try await Beekon.shared.history(from: from, to: to)
-        let arr = positions.map { self.positionToWire($0) }
-        resolve(arr)
+        try await Beekon.shared.addGeofences(list)
+        resolve(nil)
       } catch {
         reject(self.errorCode(error), error.localizedDescription, error)
       }
     }
   }
 
-  // MARK: - Mappers
+  @objc public func removeGeofences(
+    _ ids: NSArray,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    let list = ids.compactMap { $0 as? String }
+    Task {
+      await Beekon.shared.removeGeofences(ids: list)
+      resolve(nil)
+    }
+  }
 
-  private func wireToConfig(_ d: NSDictionary) throws -> BeekonConfig {
-    let presetStr = (d["preset"] as? String) ?? "balanced"
-    let preset: Preset
-    switch presetStr {
-    case "saver": preset = .saver
-    case "precision": preset = .precision
-    default: preset = .balanced
+  @objc public func listGeofencesWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+      let geofences = await Beekon.shared.listGeofences()
+      resolve(geofences.map { self.geofenceToWire($0) })
     }
+  }
+
+  // MARK: - Mappers: wire (NSDictionary/NSArray) → Beekon
 
-    let distanceFilterMeters = d["distanceFilterMeters"] as? Double
-    // JS sends millis; iOS BeekonConfig wants seconds. Normalize here.
-    let intervalSeconds: Double?
-    if let ms = d["intervalMillis"] as? Double {
-      intervalSeconds = ms / 1000.0
-    } else {
-      intervalSeconds = nil
+  private func wireToConfig(_ d: NSDictionary) -> BeekonConfig {
+    let minTime =
+      (d["minTimeBetweenLocationsSeconds"] as? NSNumber)?.doubleValue ?? 30
+    let minDist =
+      (d["minDistanceBetweenLocationsMeters"] as? NSNumber)?.doubleValue ?? 100
+    let stationaryRadius =
+      (d["stationaryRadiusMeters"] as? NSNumber)?.doubleValue ?? 5
+    let detectActivity = (d["detectActivity"] as? NSNumber)?.boolValue ?? false
+
+    var sync: SyncConfig?
+    if let s = d["sync"] as? NSDictionary,
+      let urlStr = s["url"] as? String,
+      let url = URL(string: urlStr) {
+      sync = SyncConfig(
+        url: url,
+        headers: entriesToDict((s["headers"] as? NSArray) ?? []),
+        intervalSeconds: (s["intervalSeconds"] as? NSNumber)?.doubleValue ?? 300,
+        batchSize: (s["batchSize"] as? NSNumber)?.intValue ?? 100
+      )
     }
-    let licenseKey = d["licenseKey"] as? String
 
+    // `notification` is Android-only — iOS ignores it.
     return BeekonConfig(
-      preset: preset,
-      distanceFilterMeters: distanceFilterMeters,
-      intervalSeconds: intervalSeconds,
-      licenseKey: licenseKey
+      minTimeBetweenLocationsSeconds: minTime,
+      minDistanceBetweenLocationsMeters: minDist,
+      accuracyMode: accuracyModeFromWire(d["accuracyMode"] as? String),
+      whenStationary: stationaryModeFromWire(d["whenStationary"] as? String),
+      stationaryRadiusMeters: stationaryRadius,
+      detectActivity: detectActivity,
+      sync: sync
     )
   }
 
-  private func positionToWire(_ p: Position) -> NSDictionary {
+  private func wireToGeofences(_ arr: NSArray) -> [BeekonGeofence] {
+    var out: [BeekonGeofence] = []
+    for case let m as NSDictionary in arr {
+      guard
+        let id = m["id"] as? String,
+        let lat = (m["lat"] as? NSNumber)?.doubleValue,
+        let lng = (m["lng"] as? NSNumber)?.doubleValue,
+        let radius = (m["radiusMeters"] as? NSNumber)?.doubleValue
+      else { continue }
+      out.append(
+        BeekonGeofence(
+          id: id,
+          latitude: lat,
+          longitude: lng,
+          radiusMeters: radius,
+          notifyOnEntry: (m["notifyOnEntry"] as? NSNumber)?.boolValue ?? true,
+          notifyOnExit: (m["notifyOnExit"] as? NSNumber)?.boolValue ?? true
+        )
+      )
+    }
+    return out
+  }
+
+  private func entriesToDict(_ arr: NSArray) -> [String: String] {
+    var out: [String: String] = [:]
+    for case let e as NSDictionary in arr {
+      if let k = e["key"] as? String, let v = e["value"] as? String {
+        out[k] = v
+      }
+    }
+    return out
+  }
+
+  // MARK: - Mappers: Beekon → wire (NSDictionary)
+
+  private func locationToWire(_ loc: Location) -> NSDictionary {
+    // NSDictionary literals can't carry `nil`, so optionals collapse to
+    // `NSNull` — the JS Codegen layer translates that back to `null`.
+    let d = NSMutableDictionary()
+    d["id"] = loc.id
+    d["lat"] = loc.latitude
+    d["lng"] = loc.longitude
+    d["timestampMs"] = loc.timestamp.timeIntervalSince1970 * 1000.0
+    d["accuracy"] = loc.accuracy.map { $0 as Any } ?? NSNull()
+    d["speed"] = loc.speed.map { $0 as Any } ?? NSNull()
+    d["bearing"] = loc.bearing.map { $0 as Any } ?? NSNull()
+    d["altitude"] = loc.altitude.map { $0 as Any } ?? NSNull()
+    d["quality"] = qualityToWire(loc.quality)
+    d["trigger"] = triggerToWire(loc.trigger)
+    d["motion"] = motionToWire(loc.motion)
+    d["activity"] = loc.activity.map { activityToWire($0) as Any } ?? NSNull()
+    d["isMock"] = loc.isMock
+    return d
+  }
+
+  private func geofenceToWire(_ g: BeekonGeofence) -> NSDictionary {
     return [
-      "lat": p.lat,
-      "lng": p.lng,
-      "accuracy": p.accuracy,
-      "speed": p.speed,
-      "bearing": p.bearing,
-      "altitude": p.altitude,
-      "timestampMs": p.timestamp.timeIntervalSince1970 * 1000.0,
+      "id": g.id,
+      "lat": g.latitude,
+      "lng": g.longitude,
+      "radiusMeters": g.radiusMeters,
+      "notifyOnEntry": g.notifyOnEntry,
+      "notifyOnExit": g.notifyOnExit,
+    ]
+  }
+
+  private func geofenceEventToWire(_ e: GeofenceEvent) -> NSDictionary {
+    return [
+      "id": e.id,
+      "geofenceId": e.geofenceId,
+      "type": transitionToWire(e.type),
+      "timestampMs": e.timestamp.timeIntervalSince1970 * 1000.0,
     ]
   }
 
   private func stateToWire(_ s: BeekonState) -> NSDictionary {
     switch s {
-    case .idle: return ["type": "idle"]
-    case .starting: return ["type": "starting"]
-    case .tracking: return ["type": "tracking"]
-    case .stopped: return ["type": "stopped"]
-    case .paused(let reason):
-      let r: String
-      switch reason {
-      case .permissionRevoked: r = "permissionRevoked"
-      case .locationDisabled: r = "locationDisabled"
-      case .unknown: r = "unknown"
-      }
-      return ["type": "paused", "pauseReason": r]
+    case .idle:
+      return ["type": "idle"]
+    case .tracking:
+      return ["type": "tracking"]
+    case .stopped(let reason):
+      return ["type": "stopped", "stopReason": stopReasonToWire(reason)]
+    // BeekonKit enums are non-frozen (library-evolution binary); handle unknowns.
+    @unknown default:
+      return ["type": "idle"]
+    }
+  }
+
+  private func syncStatusToWire(_ s: SyncStatus) -> NSDictionary {
+    switch s {
+    case .idle:
+      return ["type": "idle"]
+    case .pending:
+      return ["type": "pending"]
+    case .failed(let reason):
+      return ["type": "failed", "failure": syncFailureToWire(reason)]
+    @unknown default:
+      return ["type": "idle"]
+    }
+  }
+
+  // MARK: - Enum mappers
+
+  private func accuracyModeFromWire(_ s: String?) -> AccuracyMode {
+    switch s {
+    case "high": return .high
+    case "low": return .low
+    default: return .balanced
+    }
+  }
+
+  private func stationaryModeFromWire(_ s: String?) -> StationaryMode {
+    switch s {
+    case "keepTracking": return .keepTracking
+    case "pauseWithCheckIns": return .pauseWithCheckIns
+    default: return .pause
+    }
+  }
+
+  private func stopReasonToWire(_ r: StopReason) -> String {
+    switch r {
+    case .user: return "user"
+    case .permissionDenied: return "permissionDenied"
+    case .locationServicesDisabled: return "locationServicesDisabled"
+    case .locationUnavailable: return "locationUnavailable"
+    case .system: return "system"
+    @unknown default: return "system"
+    }
+  }
+
+  private func syncFailureToWire(_ f: SyncFailure) -> String {
+    switch f {
+    case .auth: return "auth"
+    case .rejected: return "rejected"
+    @unknown default: return "rejected"
+    }
+  }
+
+  private func qualityToWire(_ q: LocationQuality) -> String {
+    switch q {
+    case .ok: return "ok"
+    case .lowAccuracy: return "lowAccuracy"
+    case .implausibleSpeed: return "implausibleSpeed"
+    @unknown default: return "ok"
+    }
+  }
+
+  private func triggerToWire(_ t: LocationTrigger) -> String {
+    switch t {
+    case .interval: return "interval"
+    case .motion: return "motion"
+    case .checkIn: return "checkIn"
+    case .geofence: return "geofence"
+    case .manual: return "manual"
+    @unknown default: return "interval"
+    }
+  }
+
+  private func motionToWire(_ m: MotionState) -> String {
+    switch m {
+    case .moving: return "moving"
+    case .stationary: return "stationary"
+    case .unknown: return "unknown"
+    @unknown default: return "unknown"
+    }
+  }
+
+  private func activityToWire(_ a: ActivityType) -> String {
+    switch a {
+    case .stationary: return "stationary"
+    case .walking: return "walking"
+    case .running: return "running"
+    case .cycling: return "cycling"
+    case .automotive: return "automotive"
+    case .unknown: return "unknown"
+    @unknown default: return "unknown"
+    }
+  }
+
+  private func transitionToWire(_ t: Transition) -> String {
+    switch t {
+    case .enter: return "enter"
+    case .exit: return "exit"
+    @unknown default: return "enter"
     }
   }
 
-  /// Maps native `BeekonError` cases to stable string codes shared with
-  /// Android. JS-side error handling can switch on these without per-platform
-  /// branches.
+  /// Maps native `BeekonError` cases to stable string codes shared with Android,
+  /// so JS-side error handling can switch on them without per-platform branches.
   private func errorCode(_ e: Error) -> String {
     if let be = e as? BeekonError {
       switch be {
-      case .permissionDenied: return "PERMISSION_DENIED"
-      case .locationServicesDisabled: return "LOCATION_SERVICES_DISABLED"
-      case .notConfigured: return "NOT_CONFIGURED"
-      case .notInitialised: return "NOT_INITIALISED"
-      case .internalError: return "INTERNAL_ERROR"
+      case .storage: return "STORAGE_FAILURE"
+      case .invalidGeofence: return "INVALID_GEOFENCE"
+      @unknown default: return "INTERNAL_ERROR"
       }
     }
     return "INTERNAL_ERROR"