@wayq/beekon-rn 0.0.3 → 0.0.5

package/ios/BeekonRn.swift

@@ -1,33 +1,43 @@
 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:` / `emitOnLocation:` ObjC methods on
-/// the spec; the closures are invoked from per-stream `Task`s started during
-/// init.
-// `@unchecked Sendable` is correct here: `onStateCb`/`onLocationCb` are
-// immutable closures, and `stateTask`/`locationsTask` are mutated only from
-// init/stopCollectors which run sequentially. NSObject can't be auto-Sendable
-// and `@objc` rules out `actor`, so this is the path.
+/// 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 onLocationCb: (NSDictionary) -> Void
+  private let onGeofenceEventCb: (NSDictionary) -> Void
+  private let onSyncStatusCb: (NSDictionary) -> Void
 
   private var stateTask: 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,
-    onLocation: @escaping (NSDictionary) -> Void
+    onLocation: @escaping (NSDictionary) -> Void,
+    onGeofenceEvent: @escaping (NSDictionary) -> Void,
+    onSyncStatus: @escaping (NSDictionary) -> Void
   ) {
     self.onStateCb = onState
     self.onLocationCb = onLocation
+    self.onGeofenceEventCb = onGeofenceEvent
+    self.onSyncStatusCb = onSyncStatus
     super.init()
     self.stateTask = Task { [weak self] in
       guard let self = self else { return }
@@ -41,13 +51,38 @@ import BeekonKit
         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
@@ -55,17 +90,11 @@ import BeekonKit
   @objc public func configure(
     _ config: NSDictionary,
     resolver resolve: @escaping @Sendable (Any?) -> Void,
-    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> 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: BeekonConfig
-    do {
-      cfg = try wireToConfig(config)
-    } catch {
-      reject(errorCode(error), error.localizedDescription, error)
-      return
-    }
+    let cfg = wireToConfig(config)
     Task {
       await Beekon.shared.configure(cfg)
       resolve(nil)
@@ -74,88 +103,266 @@ import BeekonKit
 
   @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.start()
-        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 stopWithResolver(
+  @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 {
+        // 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 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 {
+        let count = try await Beekon.shared.pendingUploadCount()
+        resolve(count)
+      } catch {
+        reject(self.errorCode(error), error.localizedDescription, error)
+      }
+    }
+  }
+
+  // MARK: - Sync
+
+  @objc public func syncWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
   ) {
     Task {
-      await Beekon.shared.stop()
+      await Beekon.shared.sync()
       resolve(nil)
     }
   }
 
-  @objc public func historyFromMs(
-    _ fromMs: Double,
-    toMs: Double,
+  @objc public func setExtras(
+    _ entries: NSArray,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    let extras = entriesToDict(entries)
+    Task {
+      await Beekon.shared.setExtras(extras)
+      resolve(nil)
+    }
+  }
+
+  // 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)
-        // Function-form overload of `locations` — the property is the live
-        // stream, the function is the historical fetch. Swift resolves on
-        // signature.
-        let locations = try await Beekon.shared.locations(from: from, to: to)
-        let arr = locations.map { self.locationToWire($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)
+    }
+  }
+
+  @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
 
-  private func wireToConfig(_ d: NSDictionary) throws -> BeekonConfig {
-    // Wire defaults are applied by the TS facade — both fields are required at
-    // the wire level, so missing keys are a programmer error.
-    guard
-      let intervalSeconds = (d["intervalSeconds"] as? NSNumber)?.doubleValue,
-      let distanceMeters = (d["distanceMeters"] as? NSNumber)?.doubleValue
-    else {
-      throw NSError(
-        domain: "BeekonRn",
-        code: -1,
-        userInfo: [NSLocalizedDescriptionKey: "intervalSeconds/distanceMeters missing"]
+  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
       )
     }
+
+    // `notification` is Android-only — iOS ignores it.
     return BeekonConfig(
-      intervalSeconds: intervalSeconds,
-      distanceMeters: distanceMeters
+      minTimeBetweenLocationsSeconds: minTime,
+      minDistanceBetweenLocationsMeters: minDist,
+      accuracyMode: accuracyModeFromWire(d["accuracyMode"] as? String),
+      whenStationary: stationaryModeFromWire(d["whenStationary"] as? String),
+      stationaryRadiusMeters: stationaryRadius,
+      detectActivity: detectActivity,
+      sync: sync
     )
-    // androidNotification ignored on iOS.
   }
 
+  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` values, so optionals collapse
-    // to `NSNull` — the JS Codegen layer translates that back to `null`.
+    // NSDictionary literals can't carry `nil`, so optionals collapse to
+    // `NSNull` — the JS Codegen layer translates that back to `null`.
     let d = NSMutableDictionary()
-    d["lat"] = loc.lat
-    d["lng"] = loc.lng
+    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 [
+      "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:
@@ -164,6 +371,40 @@ import BeekonKit
       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
     }
   }
 
@@ -172,18 +413,77 @@ import BeekonKit
     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 .storageFailure: return "STORAGE_FAILURE"
+      case .storage: return "STORAGE_FAILURE"
+      case .invalidGeofence: return "INVALID_GEOFENCE"
+      @unknown default: return "INTERNAL_ERROR"
       }
     }
     return "INTERNAL_ERROR"