therms-device-tracker 1.0.0-rc.1

package/ios/ThermsDeviceTrackerModule.swift

@@ -0,0 +1,632 @@
+import ExpoModulesCore
+import CoreLocation
+import CoreMotion
+
+public class ThermsDeviceTrackerModule: Module {
+  // Thin coordinator following the architecture: delegates to focused providers.
+  // Location config/start/stop delegated to LocationProvider.
+  // Provider/authorization state delegated to ProviderMonitor.
+  // (See LocationProvider.swift, ProviderMonitor.swift, GeofenceManager.swift, etc.)
+  // Delegate for CLLocationManager remains here (to forward location + region events);
+  // manager instance is owned by locationProvider and shared for geofences.
+  private lazy var locationProvider = LocationProvider()
+
+  private var isTracking = false
+  private var enableActivity = true
+  private var enablePedometer = true
+  private var sessionLocations: [LocationPointRecord] = []
+  private var sessionActivities: [ActivityRecord] = []
+  private var sessionPedometer: [PedometerRecord] = []
+  private var currentActivity: ActivityRecord?
+  private var lastLocation: LocationPointRecord?
+  private var sessionStartedAt: Date?
+  private var sessionId: String?
+
+  // Remember last sync config for explicit startSync() after ready/start.
+  private var syncConfigFromLastStart: [String: Any]?
+
+  // For proper delegate-driven async permission requests (replaces the withCheckedContinuation + asyncAfter(0.6) hack).
+  // Resumed in handleAuthorizationChange when locationManagerDidChangeAuthorization fires after user responds to prompt.
+  private var pendingPermissionContinuation: CheckedContinuation<[String: Any], Never>?
+
+  // Focused managers (extraction to keep this file as thin coordinator)
+  private lazy var locationStore = LocationStore() // default .standard demonstrates seam (tests can override)
+  private lazy var geofenceManager: GeofenceManager = {
+    let mgr = GeofenceManager(monitor: locationProvider.manager, store: locationStore)
+    // Direct last location provider (attachment now happens inside manager's buildEvent)
+    mgr.lastLocationProvider = { [weak self] in
+      guard let self = self, let loc = self.lastLocation else { return nil }
+      return self.locationRecordToDict(loc)
+    }
+    mgr.onGeofence = { [weak self] event in
+      self?.sendEvent("onGeofence", event)
+    }
+    mgr.onGeofencesChange = { [weak self] payload in
+      self?.sendEvent("onGeofencesChange", payload)
+    }
+    return mgr
+  }()
+  private lazy var scheduleManager: ScheduleManager = {
+    let sm = ScheduleManager()
+    sm.onSchedule = { [weak self] s in self?.sendEvent("onSchedule", s) }
+    return sm
+  }()
+
+  private lazy var motionActivityProvider = MotionActivityProvider()
+
+  // Opt-in bg sync seam (native HTTP only; follows GeofenceManager/ScheduleManager pattern exactly).
+  // Uses onSync callback (not direct sendEvent inside manager). Injected store for SyncDataSource test seam.
+  // Naming: SyncManager (iOS); cross-platform note: Android equivalent is SyncProvider (see its docs).
+  private lazy var syncManager: SyncManager = {
+    let mgr = SyncManager(store: locationStore)
+    mgr.onSync = { [weak self] evt in self?.sendEvent("onSync", evt) }
+    return mgr
+  }()
+
+  // Records (internal, will map to JS structs)
+  private struct LocationPointRecord {
+    let latitude: Double
+    let longitude: Double
+    let altitude: Double?
+    let accuracy: Double?
+    let speed: Double?
+    let heading: Double?
+    let timestamp: Double
+  }
+
+  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
+  }
+
+  public func definition() -> ModuleDefinition {
+    Name("ThermsDeviceTracker")
+
+    Events(
+      "onLocationUpdate",
+      "onMotionChange",
+      "onActivityUpdate",
+      "onPedometerUpdate",
+      "onTrackingStateChange",
+      "onProviderChange",
+      "onGeofence",
+      "onGeofencesChange",
+      "onSchedule",
+      "onSync",
+      "onError"
+    )
+
+    OnCreate {
+      // Delegate assignment uses cast to avoid direct conformance issues with Expo's Module/BaseModule + NSObjectProtocol.
+      // Delegate methods are @objc for runtime dispatch.
+      let lm = locationProvider.manager
+      lm.delegate = (self as AnyObject) as? CLLocationManagerDelegate
+      // Initial defaults now via provider (delegated).
+      locationProvider.configure(desiredAccuracy: kCLLocationAccuracyBest, distanceFilter: kCLDistanceFilterNone)
+    }
+
+    OnDestroy {
+      self.stopTracking()
+      self.syncManager.stop()
+      self.scheduleManager.stop()
+    }
+
+    // Permissions
+    AsyncFunction("getPermissionsAsync") { () -> [String: Any] in
+      return self.getPermissionStatuses()
+    }
+
+    AsyncFunction("requestPermissionsAsync") { (options: [String: Any]?) -> [String: Any] in
+      let requestBackground = (options?["background"] as? Bool) ?? false
+      return try await self.requestPermissions(requestBackground: requestBackground)
+    }
+
+    // Control
+    AsyncFunction("startTrackingAsync") { (options: [String: Any]?) in
+      self.startTracking(options: options)
+    }.runOnQueue(.main)
+
+    AsyncFunction("stopTrackingAsync") {
+      self.stopTracking()
+    }.runOnQueue(.main)
+
+    // Getters
+    AsyncFunction("getCurrentLocationAsync") { () -> [String: Any]? in
+      guard let loc = lastLocation else { return nil }
+      return self.locationRecordToDict(loc)
+    }
+
+    Function("getLastKnownLocation") { () -> [String: Any]? in
+      guard let loc = lastLocation else { return nil }
+      return self.locationRecordToDict(loc)
+    }
+
+    Function("getCurrentActivity") { () -> [String: Any]? in
+      guard let act = currentActivity else { return nil }
+      return self.activityRecordToDict(act)
+    }
+
+    Function("getTrackingStatus") { () -> [String: Any] in
+      return self.buildTrackingStatusDict()
+    }
+
+    Function("getProviderState") { () -> [String: Any] in
+      return self.buildProviderChangeDict()
+    }
+
+    // Geofencing (delegated to manager)
+    AsyncFunction("addGeofence") { (geofence: [String: Any]) in
+      self.geofenceManager.addGeofence(from: geofence)
+    }
+
+    AsyncFunction("addGeofences") { (geofences: [[String: Any]]) in
+      self.geofenceManager.addGeofences(geofences)
+    }
+
+    AsyncFunction("removeGeofence") { (identifier: String) in
+      self.geofenceManager.removeGeofence(identifier: identifier)
+    }
+
+    AsyncFunction("removeGeofences") { (identifiers: [String]?) in
+      self.geofenceManager.removeGeofences(identifiers: identifiers)
+    }
+
+    AsyncFunction("getGeofences") { () -> [[String: Any]] in
+      return self.geofenceManager.getGeofences()
+    }
+
+    AsyncFunction("startGeofences") { () in
+      // Improve durability: restore persisted regions first (if any), then monitor.
+      self.geofenceManager.restorePersistedGeofences()
+      self.geofenceManager.startMonitoring()
+    }
+
+    // Persistence (delegated to store)
+    AsyncFunction("getLocations") { () -> [[String: Any]] in
+      return self.locationStore.getAll() + self.sessionLocations.map { self.locationRecordToDict($0) }
+    }
+
+    AsyncFunction("getCount") { () -> Int in
+      return self.locationStore.count() + self.sessionLocations.count
+    }
+
+    AsyncFunction("destroyLocations") {
+      self.locationStore.clear()
+      self.sessionLocations.removeAll()
+    }
+
+    AsyncFunction("destroyLocation") { (uuid: String?) in
+      if let u = uuid {
+        self.locationStore.remove(byId: u)
+      } else {
+        self.locationStore.clear()
+      }
+    }
+
+    AsyncFunction("insertLocation") { (loc: [String: Any]) in
+      self.locationStore.insert(loc)
+      self.triggerImmediateSyncIfNeeded()
+    }
+
+    // Scheduler (delegated)
+    AsyncFunction("startSchedule") {
+      self.scheduleManager.start()
+    }
+
+    AsyncFunction("stopSchedule") {
+      self.scheduleManager.stop()
+    }
+
+    // Opt-in native bg sync (config primary from ready/start; explicit start/stopSync for control like schedule).
+    // Delegates fully to syncManager (which uses onSync callback + live store reads).
+    AsyncFunction("startSync") {
+      if let cfg = self.syncConfigFromLastStart {
+        self.syncManager.start(config: cfg)
+      } else {
+        self.syncManager.syncNow() // trigger immediate if already configured
+      }
+    }
+
+    AsyncFunction("stopSync") {
+      self.syncManager.stop()
+    }
+
+    AsyncFunction("getCurrentSessionHistory") { () -> [String: Any] in
+      return [
+        "locations": self.sessionLocations.map { self.locationRecordToDict($0) },
+        "activities": self.sessionActivities.map { self.activityRecordToDict($0) },
+        "pedometer": self.sessionPedometer.map { self.pedometerRecordToDict($0) },
+      ]
+    }
+
+    AsyncFunction("clearCurrentSessionHistory") {
+      self.sessionLocations.removeAll()
+      self.sessionActivities.removeAll()
+      self.sessionPedometer.removeAll()
+    }
+
+    // Shared Object (live state handle / facade to shared module state)
+    // Design note: ThermsTracker is intentionally a lightweight proxy handle.
+    // All instances reflect the single module-owned tracking session (no per-instance state).
+    // We wire a weak back-ref so properties "use" the ref parameter (better alignment with SharedObject pattern).
+    // See src/ThermsDeviceTrackerModuleSharedObject.ts for full rationale + public API surface.
+    Class(ThermsTracker.self) {
+      Constructor {
+        let tracker = ThermsTracker()
+        tracker.ownerModule = self
+        return tracker
+      }
+
+      Property("isTracking") { (ref: ThermsTracker) -> Bool in
+        return ref.ownerModule?.isTracking ?? self.isTracking
+      }
+
+      Property("trackingStatus") { (ref: ThermsTracker) -> [String: Any] in
+        return ref.ownerModule?.buildTrackingStatusDict() ?? self.buildTrackingStatusDict()
+      }
+
+      Property("lastLocation") { (ref: ThermsTracker) -> [String: Any]? in
+        let module = ref.ownerModule ?? self
+        guard let loc = module.lastLocation else { return nil }
+        return module.locationRecordToDict(loc)
+      }
+
+      Property("currentActivity") { (ref: ThermsTracker) -> [String: Any]? in
+        let module = ref.ownerModule ?? self
+        guard let act = module.currentActivity else { return nil }
+        return module.activityRecordToDict(act)
+      }
+
+      Property("sessionStats") { (ref: ThermsTracker) -> [String: Any]? in
+        let module = ref.ownerModule ?? self
+        guard let started = module.sessionStartedAt else { return nil }
+        return [
+          "startTime": started.timeIntervalSince1970 * 1000,
+          "pointCount": module.sessionLocations.count,
+          "totalSteps": module.sessionPedometer.last?.steps ?? 0,
+        ]
+      }
+    }
+  }
+
+  // MARK: - Permissions
+
+  private func getPermissionStatuses() -> [String: Any] {
+    var result: [String: Any] = [:]
+
+    // Use the provider's manager instance (class method CLLocationManager.authorizationStatus() is deprecated).
+    let locStatus = locationProvider.manager.authorizationStatus
+    result["location"] = permissionStatusString(from: locStatus)
+
+    // Background location is granted *only* for .authorizedAlways.
+    // WhenInUse means bg not granted (even though loc is). This was previously mirroring incorrectly.
+    // "undetermined" only for initial notDetermined (supports re-prompts for background).
+    let bgStatus: String
+    if locStatus == .authorizedAlways {
+      bgStatus = "granted"
+    } else if locStatus == .denied || locStatus == .restricted {
+      bgStatus = "denied"
+    } else if locStatus == .authorizedWhenInUse {
+      bgStatus = "denied"
+    } else {
+      bgStatus = "undetermined"
+    }
+    result["backgroundLocation"] = bgStatus
+    result["canAskAgain"] = locStatus == .notDetermined
+
+    if #available(iOS 11.0, *) {
+      let motionStatus = CMMotionActivityManager.authorizationStatus()
+      result["motion"] = motionStatus == .authorized ? "granted" : (motionStatus == .denied ? "denied" : "undetermined")
+    } else {
+      result["motion"] = "granted"
+    }
+
+    return result
+  }
+
+  private func permissionStatusString(from status: CLAuthorizationStatus) -> String {
+    switch status {
+    case .authorizedAlways, .authorizedWhenInUse: return "granted"
+    case .denied, .restricted: return "denied"
+    default: return "undetermined"
+    }
+  }
+
+  private func requestPermissions(requestBackground: Bool) async throws -> [String: Any] {
+    let lm = locationProvider.manager
+    let currentStatus = lm.authorizationStatus
+
+    // Only await the delegate callback (via continuation) if a prompt will be shown and didChangeAuthorization will fire.
+    // - notDetermined: system will show prompt; delegate fires on response.
+    // - whenInUse + background: system shows upgrade prompt for "Always"; delegate fires after.
+    // If already determined and no upgrade applicable, return immediately (no delegate callback will occur for this call).
+    // Motion has no explicit request API (CMMotionActivityManager); its status is read on return (updated after activity use).
+    let shouldAwaitDelegate = currentStatus == .notDetermined ||
+      (requestBackground && currentStatus == .authorizedWhenInUse)
+
+    if !shouldAwaitDelegate {
+      return getPermissionStatuses()
+    }
+
+    return await withCheckedContinuation { continuation in
+      pendingPermissionContinuation = continuation
+      if requestBackground {
+        lm.requestAlwaysAuthorization()
+      } else {
+        lm.requestWhenInUseAuthorization()
+      }
+      // IMPORTANT: removed asyncAfter(0.6) hack. Completion driven by delegate.
+      // See handleAuthorizationChange + locationManagerDidChangeAuthorization.
+    }
+  }
+
+  // MARK: - Tracking
+
+  private func startTracking(options: [String: Any]?) {
+    guard !isTracking else { return }
+
+    let enableBg = (options?["enableBackground"] as? Bool) ?? false
+    enableActivity = (options?["enableActivityTracking"] as? Bool) ?? true
+    enablePedometer = (options?["enableStepCounting"] as? Bool) ?? true
+
+    // Location config (delegated to LocationProvider)
+    var desiredAccuracy: CLLocationAccuracy = kCLLocationAccuracyBest
+    if let accuracy = options?["accuracy"] as? String {
+      switch accuracy {
+      case "high": desiredAccuracy = kCLLocationAccuracyBest
+      case "balanced": desiredAccuracy = kCLLocationAccuracyNearestTenMeters
+      case "low": desiredAccuracy = kCLLocationAccuracyHundredMeters
+      case "lowest": desiredAccuracy = kCLLocationAccuracyThreeKilometers
+      default: break
+      }
+    }
+    var distanceFilter: CLLocationDistance = kCLDistanceFilterNone
+    if let df = options?["distanceFilter"] as? Double, df > 0 {
+      distanceFilter = df
+    }
+    locationProvider.configure(desiredAccuracy: desiredAccuracy, distanceFilter: distanceFilter)
+
+    // Reset session
+    sessionLocations.removeAll()
+    sessionActivities.removeAll()
+    sessionPedometer.removeAll()
+    sessionStartedAt = Date()
+    sessionId = UUID().uuidString
+
+    // Start location (delegated)
+    let pauses = (options?["ios"] as? [String: Any])?["pausesLocationUpdatesAutomatically"] as? Bool ?? false
+    locationProvider.applyBackgroundAndPauseSettings(allowsBackground: enableBg, pausesAutomatically: pauses)
+
+    if CLLocationManager.locationServicesEnabled() {
+      locationProvider.startUpdatingLocation()
+    } else {
+      sendError(code: "location_unavailable", message: "Location services are disabled")
+    }
+
+    // Motion / activity / pedometer — delegated
+    motionActivityProvider.configure(enableActivity: enableActivity, enablePedometer: enablePedometer)
+    motionActivityProvider.onActivityUpdate = { [weak self] dict in
+      // Reconstruct minimal record for session/current if needed (preserves prior behavior)
+      if let type = dict["type"] as? String, let conf = dict["confidence"] as? Double {
+        let rec = ActivityRecord(type: type, confidence: conf, timestamp: Date().timeIntervalSince1970 * 1000)
+        self?.currentActivity = rec
+        self?.sessionActivities.append(rec)
+      }
+      self?.sendEvent("onActivityUpdate", dict)
+      self?.sendStateChange()
+    }
+    motionActivityProvider.onPedometerUpdate = { [weak self] dict in
+      if let steps = dict["steps"] as? Int {
+        let rec = PedometerRecord(
+          steps: steps,
+          distance: dict["distance"] as? Double,
+          floorsAscended: dict["floorsAscended"] as? Int,
+          floorsDescended: dict["floorsDescended"] as? Int,
+          timestamp: Date().timeIntervalSince1970 * 1000
+        )
+        self?.sessionPedometer.append(rec)
+      }
+      self?.sendEvent("onPedometerUpdate", dict)
+    }
+    motionActivityProvider.onError = { [weak self] code, msg in
+      self?.sendError(code: code, message: msg)
+    }
+    motionActivityProvider.start()
+
+    isTracking = true
+    sendStateChange()
+
+    // Wire more config from ThermsConfig (smallest; no behavior change).
+    // Only schedule.enabled acts; geofence/persistence enabled are comments (use explicit add/start APIs).
+    if let sched = options?["schedule"] as? [String: Any], (sched["enabled"] as? Bool) == true {
+      scheduleManager.start(config: sched)
+    }
+    if let _ = options?["geofence"] as? [String: Any] {
+      // e.g. (gf["enabled"] as? Bool) could trigger startGeofences but preserve explicit API use
+    }
+    if let _ = options?["persistence"] as? [String: Any] {
+      // LocationStore could consult maxDaysToPersist etc in future; current bounded by maxEntries
+    }
+    if let syncCfg = options?["sync"] as? [String: Any] {
+      syncConfigFromLastStart = syncCfg
+      if (syncCfg["enabled"] as? Bool) == true {
+        syncManager.start(config: syncCfg)
+      }
+    }
+
+    // Fire initial provider state (like reference libs do after ready)
+    let prov = self.buildProviderChangeDict()
+    self.sendEvent("onProviderChange", prov)
+  }
+
+  private func stopTracking() {
+    guard isTracking else { return }
+
+    // Stop location updates (delegated to provider)
+    locationProvider.stopUpdating()
+    motionActivityProvider.stop()
+
+    isTracking = false
+    sendStateChange()
+
+    syncManager.stop()
+    syncConfigFromLastStart = nil
+    sendEvent("onMotionChange", ["isMoving": false, "location": nil])
+    // Note: schedule lifecycle independent (no auto stopSchedule on stopTracking; call explicitly if needed)
+  }
+
+  // MARK: - CLLocationManagerDelegate
+
+  @objc public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+    guard let location = locations.last else { return }
+
+    let record = LocationPointRecord(
+      latitude: location.coordinate.latitude,
+      longitude: location.coordinate.longitude,
+      altitude: location.altitude,
+      accuracy: location.horizontalAccuracy >= 0 ? location.horizontalAccuracy : nil,
+      speed: location.speed >= 0 ? location.speed : nil,
+      heading: location.course >= 0 ? location.course : nil,
+      timestamp: location.timestamp.timeIntervalSince1970 * 1000
+    )
+
+    lastLocation = record
+    sessionLocations.append(record)
+
+    // Persist via store (adds id automatically)
+    locationStore.insert(locationRecordToDict(record))
+
+    triggerImmediateSyncIfNeeded()
+
+    sendEvent("onLocationUpdate", locationRecordToDict(record))
+    sendEvent("onMotionChange", ["isMoving": true, "location": locationRecordToDict(record)])
+    sendStateChange()
+  }
+
+  @objc public func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+    sendError(code: "location_error", message: error.localizedDescription)
+  }
+
+  @objc public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+    handleAuthorizationChange()
+  }
+
+  // Older delegate signature (pre-iOS 14 / for compatibility): still invoked by CLLocationManager in some cases.
+  // Ensures we capture auth changes for permission request continuations across iOS versions.
+  @objc public func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
+    handleAuthorizationChange()
+  }
+
+  private func handleAuthorizationChange() {
+    let event = self.buildProviderChangeDict()
+    self.sendEvent("onProviderChange", event)
+
+    // Resume any in-flight requestPermissionsAsync continuation. This makes permission flow
+    // reliable and delegate-driven instead of time-based polling.
+    if let cont = pendingPermissionContinuation {
+      pendingPermissionContinuation = nil
+      cont.resume(returning: self.getPermissionStatuses())
+    }
+  }
+
+  // MARK: - Helpers
+
+
+
+  private func locationRecordToDict(_ r: LocationPointRecord) -> [String: Any] {
+    var dict: [String: Any] = [
+      "latitude": r.latitude,
+      "longitude": r.longitude,
+      "timestamp": r.timestamp,
+    ]
+    if let v = r.altitude { dict["altitude"] = v }
+    if let v = r.accuracy { dict["accuracy"] = v }
+    if let v = r.speed { dict["speed"] = v }
+    if let v = r.heading { dict["heading"] = v }
+    return dict
+  }
+
+  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
+  }
+
+  private func buildTrackingStatusDict() -> [String: Any] {
+    return [
+      "state": isTracking ? "active" : "inactive",
+      "isBackground": locationProvider.manager.allowsBackgroundLocationUpdates,
+      "sessionId": sessionId as Any,
+      "startedAt": sessionStartedAt.map { $0.timeIntervalSince1970 * 1000 } as Any,
+    ]
+  }
+
+  private func buildProviderChangeDict() -> [String: Any] {
+    // Delegated fully to ProviderMonitor (uses active manager for instance auth + accuracy props).
+    return ProviderMonitor.currentState(using: locationProvider.manager)
+  }
+
+  private func sendStateChange() {
+    sendEvent("onTrackingStateChange", buildTrackingStatusDict())
+  }
+
+  private func sendError(code: String, message: String) {
+    sendEvent("onError", ["code": code, "message": message])
+  }
+
+  // Extracted helper to reduce duplication of the immediate (non-batch) sync trigger.
+  // Used from didUpdateLocations and insertLocation. Keeps the check in one place
+  // while the module remains a thin coordinator. (Small intentional dupe vs Android mirror.)
+  private func triggerImmediateSyncIfNeeded() {
+    if let sc = syncConfigFromLastStart,
+       (sc["enabled"] as? Bool) == true,
+       (sc["batch"] as? Bool) != true {
+      syncManager.syncNow()
+    }
+  }
+
+  // MARK: - Delegate forwarding to managers (keeps main module thin)
+
+  @objc public func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
+    geofenceManager.handleDidEnterRegion(region)
+  }
+
+  @objc public func locationManager(_ manager: CLLocationManager, didExitRegion region: CLRegion) {
+    geofenceManager.handleDidExitRegion(region)
+  }
+
+  @objc public func locationManager(_ manager: CLLocationManager, didDetermineState state: CLRegionState, for region: CLRegion) {
+    geofenceManager.handleDidDetermineState(state, for: region)
+  }
+}
+
+// MARK: - SharedObject impl
+// ThermsTracker is a lightweight handle/proxy (not owner of tracking state).
+// State lives in the ThermsDeviceTrackerModule (the one true session).
+// ownerModule allows properties to delegate without ignoring 'ref'.
+// Multiple handles are equivalent and intentionally share state.
+
+public class ThermsTracker: SharedObject {
+  // Weak ref to owning module for proxying live state. Set by Class constructor.
+  public weak var ownerModule: ThermsDeviceTrackerModule?
+
+  override public func sharedObjectDidRelease() {
+    // No per-handle resources; module manages its own session lifecycle.
+    super.sharedObjectDidRelease()
+  }
+}

package/ios/ThermsDeviceTrackerModuleSharedObject.swift

@@ -0,0 +1,17 @@
+import ExpoModulesCore
+
+/**
+ * Legacy compatibility placeholder only.
+ * The real live state handle is `ThermsTracker` (defined + registered inside ThermsDeviceTrackerModule.swift).
+ * Never instantiated via the module definition; retained only for historical name references.
+ * Do not use directly; use `useThermsTracker()` / ThermsTracker from JS.
+ */
+public class ThermsDeviceTrackerModuleSharedObject: SharedObject {
+  // Unused legacy field; preserved only to avoid any binary compat surprises in old builds.
+  @available(*, deprecated, message: "Legacy placeholder; not used by current ThermsTracker implementation.")
+  var count: Int = 0
+
+  override public func sharedObjectDidRelease() {
+    super.sharedObjectDidRelease()
+  }
+}