therms-device-tracker 1.0.0-rc.1

package/android/src/main/java/expo/modules/thermsdevicetracker/ThermsDeviceTrackerModule.kt

@@ -0,0 +1,726 @@
+package expo.modules.thermsdevicetracker
+
+import android.Manifest
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.location.Location
+import android.os.Build
+import android.os.Looper
+import androidx.core.content.ContextCompat
+import androidx.core.os.bundleOf
+import com.google.android.gms.location.*
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.util.*
+
+class ThermsDeviceTrackerModule : Module() {
+  // Providers extracted (unification with iOS patterns): LocationProvider, ActivityRecognitionProvider
+  // (iOS: MotionActivityProvider), GeofenceProvider (seam unified to callbacks after ctor),
+  // ScheduleProvider, SyncProvider, LocationStore.
+  // Module is thin coordinator delegating via callbacks (see ThermsDeviceTrackerModule.swift
+  // and per-class docs).
+  private lateinit var fusedLocationClient: FusedLocationProviderClient
+  private lateinit var activityRecognitionClient: ActivityRecognitionClient
+  private lateinit var geofencingClient: GeofencingClient
+
+  private var bgReceiver: android.content.BroadcastReceiver? = null
+  private var providerReceiver: android.content.BroadcastReceiver? = null
+  private var geofenceReceiver: android.content.BroadcastReceiver? = null
+  private var syncReceiver: android.content.BroadcastReceiver? = null
+  private var activityReceiver: android.content.BroadcastReceiver? = null
+  private var enableBackground = false
+
+  // Focused provider
+  private lateinit var geofenceProvider: GeofenceProvider
+  private lateinit var locationStore: LocationStore
+  private lateinit var syncProvider: SyncProvider
+  private lateinit var scheduleProvider: ScheduleProvider
+  private lateinit var locationProvider: LocationProvider
+  private lateinit var activityProvider: ActivityRecognitionProvider
+
+  private var isTracking = false
+  private var lastSyncConfig: Map<String, Any?>? = null
+  private var enableActivityTracking = true
+  private var enableStepCounting = true
+  private var sessionLocations = mutableListOf<LocationPointRecord>()
+  private var sessionActivities = mutableListOf<ActivityRecord>()
+  private var sessionPedometer = mutableListOf<PedometerRecord>()
+  private var lastLocation: LocationPointRecord? = null
+  private var currentActivity: ActivityRecord? = null
+  private var sessionStartedAt: Long? = null
+  private var sessionId: String? = null
+
+  data class LocationPointRecord(
+    val latitude: Double,
+    val longitude: Double,
+    val altitude: Double?,
+    val accuracy: Float?,
+    val speed: Float?,
+    val heading: Float?,
+    val timestamp: Double
+  )
+
+  data class ActivityRecord(
+    val type: String,
+    val confidence: Double,
+    val timestamp: Double
+  )
+
+  data class PedometerRecord(
+    val steps: Int,
+    val distance: Double?,
+    val floorsAscended: Int?,
+    val floorsDescended: Int?,
+    val timestamp: Double
+  )
+
+  private val context: Context
+    get() = requireNotNull(appContext.reactContext)
+
+  override fun definition() = ModuleDefinition {
+    Name("ThermsDeviceTracker")
+
+    Events(
+      "onLocationUpdate",
+      "onMotionChange",
+      "onActivityUpdate",
+      "onPedometerUpdate",
+      "onTrackingStateChange",
+      "onProviderChange",
+      "onGeofence",
+      "onGeofencesChange",
+      "onSchedule",
+      "onSync",
+      "onError"
+    )
+
+    OnCreate {
+      fusedLocationClient = LocationServices.getFusedLocationProviderClient(context)
+      activityRecognitionClient = ActivityRecognition.getClient(context)
+      geofencingClient = LocationServices.getGeofencingClient(context)
+
+      locationStore = LocationStore(context)
+      geofenceProvider = GeofenceProvider(
+        context = context,
+        geofencingClient = geofencingClient,
+        store = locationStore
+      )
+      // Set callbacks after construction (unified seam; no lambdas in ctor).
+      // lastLocationProvider supplies location attachment at transition time (keeps events identical).
+      geofenceProvider.onGeofence = { payload -> sendEvent("onGeofence", payload) }
+      geofenceProvider.onGeofencesChange = { payload -> sendEvent("onGeofencesChange", payload) }
+      geofenceProvider.onError = { code, msg -> sendError(code, msg) }
+      geofenceProvider.lastLocationProvider = { lastLocation?.let { toLocationDict(it) } }
+
+      // Sync seam (injected with store only; onSync callback like iOS SyncManager).
+      // All logic (config, WorkManager scheduling, live-preferring fetch in worker, broadcast result handling) lives in SyncProvider.
+      // Module is thin: just wires onSync -> sendEvent and registers receiver to delegate to handleSyncResult.
+      // (Naming: Provider on Android to match GeofenceProvider; iOS uses SyncManager.)
+      syncProvider = SyncProvider(
+        context = context,
+        store = locationStore
+      )
+      syncProvider.onSync = { payload -> sendEvent("onSync", payload) }
+
+      scheduleProvider = ScheduleProvider(context)
+      scheduleProvider.onSchedule = { payload -> sendEvent("onSchedule", payload) }
+
+      locationProvider = LocationProvider(context, fusedLocationClient)
+      locationProvider.onNewLocation = { loc -> handleNewLocation(loc) }
+      locationProvider.onError = { code, msg -> sendError(code, msg) }
+
+      activityProvider = ActivityRecognitionProvider(context, activityRecognitionClient)
+      activityProvider.onActivityUpdate = { dict -> handleActivityUpdate(dict) }
+      activityProvider.onError = { code, msg -> sendError(code, msg) }
+
+      registerBgReceiver()
+      registerProviderReceiver()
+      registerGeofenceReceiver() // unconditional (receivers cheap; thin coordinator)
+      registerSyncReceiver()     // for sync results via broadcast (delegates to provider.handle)
+      registerActivityReceiver() // for activity via broadcast from ActivityRecognition PI (delegates to provider.handle)
+      // Emit initial provider state
+      sendEvent("onProviderChange", buildProviderChangeDict())
+    }
+
+    OnDestroy {
+      unregisterBgReceiver()
+      unregisterProviderReceiver()
+      unregisterGeofenceReceiver()
+      unregisterSyncReceiver()
+      unregisterActivityReceiver()
+      syncProvider.stop()
+      scheduleProvider.stop()
+      // activityProvider.stop() will be called via stopTracking if active; safe to call here too
+      activityProvider.stop()
+    }
+
+    // Permissions
+    AsyncFunction("getPermissionsAsync") {
+      getPermissionStatuses()
+    }
+
+    AsyncFunction("requestPermissionsAsync") { options: Map<String, Any?>? ->
+      val background = options?.get("background") as? Boolean ?: false
+      requestPermissions(background)
+    }
+
+    // Tracking
+    AsyncFunction("startTrackingAsync") { options: Map<String, Any?>? ->
+      startTracking(options)
+    }
+
+    AsyncFunction("stopTrackingAsync") {
+      stopTracking()
+    }
+
+    // Getters
+    AsyncFunction("getCurrentLocationAsync") {
+      lastLocation?.let { toLocationDict(it) }
+    }
+
+    Function("getLastKnownLocation") {
+      lastLocation?.let { toLocationDict(it) }
+    }
+
+    Function("getCurrentActivity") {
+      currentActivity?.let { toActivityDict(it) }
+    }
+
+    Function("getTrackingStatus") {
+      buildStatusDict()
+    }
+
+    Function("getProviderState") {
+      buildProviderChangeDict()
+    }
+
+    // Geofencing (delegated)
+    AsyncFunction("addGeofence") { geofence: Map<String, Any?> ->
+      geofenceProvider.addGeofence(geofence)
+    }
+
+    AsyncFunction("addGeofences") { geofences: List<Map<String, Any?>> ->
+      geofenceProvider.addGeofences(geofences)
+    }
+
+    AsyncFunction("removeGeofence") { identifier: String ->
+      geofenceProvider.removeGeofence(identifier)
+    }
+
+    AsyncFunction("removeGeofences") { identifiers: List<String>? ->
+      geofenceProvider.removeGeofences(identifiers)
+    }
+
+    AsyncFunction("getGeofences") {
+      geofenceProvider.getGeofences()
+    }
+
+    AsyncFunction("startGeofences") {
+      geofenceProvider.startMonitoring() // restore+register inside (parity with iOS explicit in startGeofences)
+    }
+
+    // Persistence (delegated to extracted LocationStore using SharedPrefs w/ id support)
+    AsyncFunction("getLocations") {
+      locationStore.getAll() + sessionLocations.map { toLocationDict(it) }
+    }
+
+    AsyncFunction("getCount") {
+      locationStore.count() + sessionLocations.size
+    }
+
+    AsyncFunction("destroyLocations") {
+      locationStore.clear()
+      sessionLocations.clear()
+    }
+
+    AsyncFunction("destroyLocation") { uuid: String? ->
+      if (uuid != null) locationStore.remove(uuid) else locationStore.clear()
+    }
+
+    AsyncFunction("insertLocation") { loc: Map<String, Any?> ->
+      locationStore.insert(loc)
+      triggerImmediateSyncIfNeeded()
+    }
+
+    // Scheduler (delegated to focused provider for parity with iOS ScheduleManager)
+    AsyncFunction("startSchedule") {
+      scheduleProvider.start()
+    }
+
+    AsyncFunction("stopSchedule") {
+      scheduleProvider.stop()
+    }
+
+    // Opt-in native bg sync (delegates to SyncProvider; onSync wired in OnCreate).
+    // Mirror iOS: if we have a prior config from ready/start use it; otherwise fall back to syncNow()
+    // (useful after explicit stopSync or for immediate trigger when no last config).
+    AsyncFunction("startSync") {
+      if (lastSyncConfig != null) {
+        syncProvider.start(lastSyncConfig)
+      } else {
+        syncProvider.syncNow()
+      }
+    }
+
+    AsyncFunction("stopSync") {
+      syncProvider.stop()
+    }
+
+    AsyncFunction("getCurrentSessionHistory") {
+      mapOf(
+        "locations" to sessionLocations.map { toLocationDict(it) },
+        "activities" to sessionActivities.map { toActivityDict(it) },
+        "pedometer" to sessionPedometer.map { toPedometerDict(it) }
+      )
+    }
+
+    AsyncFunction("clearCurrentSessionHistory") {
+      sessionLocations.clear()
+      sessionActivities.clear()
+      sessionPedometer.clear()
+    }
+
+    Class(ThermsTracker::class) {
+      // SharedObject for live state: intentionally proxies the module singleton state
+      // (one tracking session). All created handles are equivalent. ownerModule enables
+      // using the 'ref' param in properties (cleanup from previous "dummy/ignore ref" impl).
+      // Matches iOS and documented public surface in useThermsTracker.
+      Constructor {
+        val tracker = ThermsTracker(appContext)
+        tracker.ownerModule = this@ThermsDeviceTrackerModule
+        tracker
+      }
+
+      Property("isTracking") { ref: ThermsTracker -> ref.ownerModule?.isTracking ?: isTracking }
+
+      Property("trackingStatus") { ref: ThermsTracker -> ref.ownerModule?.buildStatusDict() ?: buildStatusDict() }
+
+      Property("lastLocation") { ref: ThermsTracker ->
+        val m = ref.ownerModule ?: this@ThermsDeviceTrackerModule
+        m.lastLocation?.let { m.toLocationDict(it) }
+      }
+
+      Property("currentActivity") { ref: ThermsTracker ->
+        val m = ref.ownerModule ?: this@ThermsDeviceTrackerModule
+        m.currentActivity?.let { m.toActivityDict(it) }
+      }
+
+      Property("sessionStats") { ref: ThermsTracker ->
+        val m = ref.ownerModule ?: this@ThermsDeviceTrackerModule
+        m.sessionStartedAt?.let {
+          mapOf(
+            "startTime" to it,
+            "pointCount" to m.sessionLocations.size,
+            "totalSteps" to (m.sessionPedometer.lastOrNull()?.steps ?: 0)
+          )
+        }
+      }
+    }
+  }
+
+  // MARK: Permissions
+
+  private fun getPermissionStatuses(): Map<String, Any> {
+    val fine = checkPermission(Manifest.permission.ACCESS_FINE_LOCATION)
+    val coarse = checkPermission(Manifest.permission.ACCESS_COARSE_LOCATION)
+    val activity = checkPermission(Manifest.permission.ACTIVITY_RECOGNITION)
+    val bg = checkPermission(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+
+    val locGranted = fine == "granted" || coarse == "granted"
+
+    // Report "denied" (not "undetermined") for !granted to match iOS behavior after fixes
+    // (iOS distinguishes notDetermined vs denied/restricted). Background uses separate perm check.
+    // canAskAgain kept true (accurate "can re-prompt" requires rationale tracking or prior state).
+    return mapOf(
+      "location" to if (locGranted) "granted" else "denied",
+      "backgroundLocation" to bg,
+      "motion" to activity,
+      "canAskAgain" to true
+    )
+  }
+
+  private fun checkPermission(perm: String): String {
+    val res = ContextCompat.checkSelfPermission(context, perm)
+    return if (res == PackageManager.PERMISSION_GRANTED) "granted" else "denied"
+  }
+
+  private fun requestPermissions(background: Boolean): Map<String, Any> {
+    // NOTE: background option is accepted for API parity (status response will include backgroundLocation).
+    // Actual permission prompting in Expo modules typically requires ActivityResultContracts or host/JS layer
+    // (e.g. PermissionsAndroid or expo's permission helpers) because dialogs are async + activity-bound.
+    // We return accurate current statuses (no regression). Delegate observation pattern used on iOS side.
+    return getPermissionStatuses()
+  }
+
+  // MARK: Tracking
+
+  private fun startTracking(options: Map<String, Any?>?) {
+    if (isTracking) return
+
+    enableActivityTracking = (options?.get("enableActivityTracking") as? Boolean) ?: true
+    enableStepCounting = (options?.get("enableStepCounting") as? Boolean) ?: true
+    enableBackground = (options?.get("enableBackground") as? Boolean) ?: false
+
+    // Reset session
+    sessionLocations.clear()
+    sessionActivities.clear()
+    sessionPedometer.clear()
+    sessionStartedAt = System.currentTimeMillis()
+    sessionId = UUID.randomUUID().toString()
+
+    // Location request (used for foreground path)
+    val accuracyStr = options?.get("accuracy") as? String
+    val priority = when (accuracyStr) {
+      "high" -> Priority.PRIORITY_HIGH_ACCURACY
+      "low" -> Priority.PRIORITY_LOW_POWER
+      "lowest" -> Priority.PRIORITY_PASSIVE
+      else -> Priority.PRIORITY_BALANCED_POWER_ACCURACY
+    }
+
+    val interval = ((options?.get("timeInterval") as? Number)?.toLong() ?: 5000L)
+    val minDistance = ((options?.get("distanceFilter") as? Number)?.toFloat() ?: 0f)
+
+    if (enableBackground) {
+      // Delegate to foreground service (bg path)
+      val serviceIntent = Intent(context, ThermsLocationService::class.java).apply {
+        action = ThermsLocationService.ACTION_START
+      }
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        context.startForegroundService(serviceIntent)
+      } else {
+        context.startService(serviceIntent)
+      }
+    } else {
+      // Foreground-only: delegate config + start to LocationProvider
+      locationProvider.configure(priority, interval, minDistance)
+      if (hasLocationPermission()) {
+        locationProvider.startUpdatingLocation()
+      } else {
+        sendError("permission_denied", "Location permission not granted")
+      }
+    }
+
+    // Wire more config from ThermsConfig (smallest; no behavior change).
+    // Only schedule.enabled has side effect here (delegated to ScheduleProvider); other sections use explicit APIs.
+    val sched = options?.get("schedule") as? Map<*, *>
+    if (sched?.get("enabled") as? Boolean == true) {
+      scheduleProvider.start(sched as? Map<String, Any?>)
+    }
+    val gfCfg = options?.get("geofence") as? Map<*, *>
+    if (gfCfg?.get("enabled") as? Boolean == true) {
+      // geofenceProvider could auto-start; keep explicit for API parity
+    }
+    if (options?.get("persistence") != null) {
+      // locationStore ready; maxDays etc stub in store for future
+    }
+    val syncCfg = options?.get("sync") as? Map<*, *>
+    if (syncCfg?.get("enabled") as? Boolean == true) {
+      lastSyncConfig = syncCfg as Map<String, Any?>?
+      syncProvider.start(lastSyncConfig)
+    }
+
+    // Activity recognition now delegated to ActivityRecognitionProvider (real updates, callback seam).
+    // Mirrors LocationProvider pattern and iOS MotionActivityProvider wiring.
+    // Provider uses PendingIntent + ACTION; module receiver forwards to handleActivityResult -> onActivityUpdate.
+    // Placeholder emission removed; real detections arrive via callback when updates fire.
+    if (enableActivityTracking) {
+      if (hasActivityPermission()) {
+        activityProvider.configure(enableActivity = true)
+        activityProvider.start()
+      } else {
+        sendError("permission_denied", "Activity recognition permission not granted")
+      }
+    }
+
+    isTracking = true
+    sendStateChange()
+  }
+
+  private fun stopTracking() {
+    if (!isTracking) return
+
+    if (enableBackground) {
+      val stopIntent = Intent(context, ThermsLocationService::class.java).apply {
+        action = ThermsLocationService.ACTION_STOP
+      }
+      context.startService(stopIntent)
+    } else {
+      locationProvider.stopUpdatingLocation()
+    }
+
+    // Delegate stop to activity provider (idempotent; clears pending intent + removes updates)
+    activityProvider.stop()
+
+    isTracking = false
+    enableBackground = false
+    sendStateChange()
+
+    syncProvider.stop()
+    lastSyncConfig = null
+    sendEvent("onMotionChange", mapOf("isMoving" to false, "location" to nil))
+    // Note: schedule lifecycle independent (no auto stopSchedule on stopTracking; call explicitly if needed)
+  }
+
+  private fun registerBgReceiver() {
+    if (bgReceiver != null) return
+    bgReceiver = object : BroadcastReceiver() {
+      override fun onReceive(ctx: Context?, intent: Intent?) {
+        if (intent?.action == ThermsLocationService.BROADCAST_ACTION) {
+          val lat = intent.getDoubleExtra(ThermsLocationService.EXTRA_LAT, 0.0)
+          val lon = intent.getDoubleExtra(ThermsLocationService.EXTRA_LON, 0.0)
+          val acc = intent.getFloatExtra(ThermsLocationService.EXTRA_ACCURACY, -1f)
+          val spd = intent.getFloatExtra(ThermsLocationService.EXTRA_SPEED, -1f)
+          val ts = intent.getLongExtra(ThermsLocationService.EXTRA_TIMESTAMP, System.currentTimeMillis())
+
+          val record = LocationPointRecord(
+            latitude = lat,
+            longitude = lon,
+            altitude = null,
+            accuracy = if (acc >= 0) acc else null,
+            speed = if (spd >= 0) spd else null,
+            heading = null,
+            timestamp = ts.toDouble()
+          )
+          lastLocation = record
+          sessionLocations.add(record)
+          locationStore.insert(toLocationDict(record))
+          sendEvent("onLocationUpdate", toLocationDict(record))
+          sendEvent("onMotionChange", mapOf("isMoving" to true, "location" to toLocationDict(record)))
+          triggerImmediateSyncIfNeeded()
+          sendStateChange()
+        }
+      }
+    }
+    val filter = IntentFilter(ThermsLocationService.BROADCAST_ACTION)
+    context.registerReceiver(bgReceiver, filter)
+  }
+
+  private fun unregisterBgReceiver() {
+    bgReceiver?.let {
+      try { context.unregisterReceiver(it) } catch (_: Exception) {}
+    }
+    bgReceiver = null
+  }
+
+  private fun registerProviderReceiver() {
+    if (providerReceiver != null) return
+    providerReceiver = object : BroadcastReceiver() {
+      override fun onReceive(ctx: Context?, intent: Intent?) {
+        if (intent?.action == android.location.LocationManager.PROVIDERS_CHANGED_ACTION) {
+          sendEvent("onProviderChange", buildProviderChangeDict())
+        }
+      }
+    }
+    val filter = IntentFilter(android.location.LocationManager.PROVIDERS_CHANGED_ACTION)
+    context.registerReceiver(providerReceiver, filter)
+  }
+
+  private fun unregisterProviderReceiver() {
+    providerReceiver?.let {
+      try { context.unregisterReceiver(it) } catch (_: Exception) {}
+    }
+    providerReceiver = null
+  }
+
+  private fun handleNewLocation(location: Location) {
+    val record = LocationPointRecord(
+      latitude = location.latitude,
+      longitude = location.longitude,
+      altitude = if (location.hasAltitude()) location.altitude else null,
+      accuracy = if (location.hasAccuracy()) location.accuracy else null,
+      speed = if (location.hasSpeed()) location.speed else null,
+      heading = if (location.hasBearing()) location.bearing else null,
+      timestamp = location.time.toDouble()
+    )
+    lastLocation = record
+    sessionLocations.add(record)
+
+    locationStore.insert(toLocationDict(record))
+
+    triggerImmediateSyncIfNeeded()
+
+    sendEvent("onLocationUpdate", toLocationDict(record))
+    sendEvent("onMotionChange", mapOf("isMoving" to true, "location" to toLocationDict(record)))
+    sendStateChange()
+  }
+
+  private fun handleActivityUpdate(dict: Map<String, Any>) {
+    val type = dict["type"] as? String ?: "unknown"
+    val confidence = dict["confidence"] as? Double ?: 0.0
+    val timestamp = dict["timestamp"] as? Double ?: System.currentTimeMillis().toDouble()
+
+    val record = ActivityRecord(type = type, confidence = confidence, timestamp = timestamp)
+    currentActivity = record
+    sessionActivities.add(record)
+
+    sendEvent("onActivityUpdate", dict)
+    sendStateChange()
+  }
+
+  private fun hasLocationPermission(): Boolean {
+    return ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED ||
+           ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
+  }
+
+  private fun hasActivityPermission(): Boolean {
+    return ContextCompat.checkSelfPermission(context, Manifest.permission.ACTIVITY_RECOGNITION) == PackageManager.PERMISSION_GRANTED
+  }
+
+  // MARK: Serialization
+
+  private fun toLocationDict(r: LocationPointRecord): Map<String, Any?> =
+    mapOf(
+      "latitude" to r.latitude,
+      "longitude" to r.longitude,
+      "altitude" to r.altitude,
+      "accuracy" to r.accuracy,
+      "speed" to r.speed,
+      "heading" to r.heading,
+      "timestamp" to r.timestamp
+    )
+
+  private fun toActivityDict(r: ActivityRecord) = mapOf(
+    "type" to r.type,
+    "confidence" to r.confidence,
+    "timestamp" to r.timestamp
+  )
+
+  private fun toPedometerDict(r: PedometerRecord) = mapOf(
+    "steps" to r.steps,
+    "distance" to r.distance,
+    "floorsAscended" to r.floorsAscended,
+    "floorsDescended" to r.floorsDescended,
+    "timestamp" to r.timestamp
+  )
+
+  private fun buildStatusDict(): Map<String, Any?> = mapOf(
+    "state" to if (isTracking) "active" else "inactive",
+    "isBackground" to false, // updated when bg service is wired
+    "sessionId" to sessionId,
+    "startedAt" to sessionStartedAt
+  )
+
+  private fun buildProviderChangeDict(): Map<String, Any> {
+    val lm = context.getSystemService(Context.LOCATION_SERVICE) as android.location.LocationManager
+    val gps = lm.isProviderEnabled(android.location.LocationManager.GPS_PROVIDER)
+    val net = lm.isProviderEnabled(android.location.LocationManager.NETWORK_PROVIDER)
+    val enabled = gps || net
+
+    // Simple status mapping (can be enhanced with permission checks)
+    val status = if (enabled) "always" else "denied"
+
+    return mapOf(
+      "enabled" to enabled,
+      "status" to status,
+      "gps" to gps,
+      "network" to net
+    )
+  }
+
+  private fun sendStateChange() {
+    sendEvent("onTrackingStateChange", buildStatusDict())
+  }
+
+  private fun sendError(code: String, message: String) {
+    sendEvent("onError", bundleOf("code" to code, "message" to message))
+  }
+
+  /**
+   * Extracted to eliminate duplication of the immediate (non-batch) sync trigger.
+   * Called after location inserts from native delivery and from the public insertLocation API.
+   * Mirrors the iOS triggerImmediateSyncIfNeeded helper (intentional small dupe to keep modules thin + focused).
+   */
+  private fun triggerImmediateSyncIfNeeded() {
+    if (lastSyncConfig?.get("enabled") as? Boolean == true &&
+        lastSyncConfig?.get("batch") as? Boolean != true) {
+      syncProvider.syncNow()
+    }
+  }
+
+  // GeofenceProvider owns the state and logic (see GeofenceProvider.kt)
+
+  // Geofence receiver registration (dispatches to onGeofence)
+  private fun registerGeofenceReceiver() {
+    if (geofenceReceiver != null) return
+    geofenceReceiver = object : BroadcastReceiver() {
+      override fun onReceive(ctx: Context?, intent: Intent?) {
+        if (intent?.action != GeofenceTransitionReceiver.ACTION) return
+        val transition = intent.getIntExtra(GeofenceTransitionReceiver.EXTRA_TRANSITION, -1)
+        val ids = intent.getStringArrayListExtra(GeofenceTransitionReceiver.EXTRA_IDS) ?: return
+        geofenceProvider.handleTransition(transition, ids)
+      }
+    }
+    context.registerReceiver(geofenceReceiver, IntentFilter(GeofenceTransitionReceiver.ACTION))
+  }
+
+  private fun unregisterGeofenceReceiver() {
+    geofenceReceiver?.let {
+      try { context.unregisterReceiver(it) } catch (_: Exception) {}
+    }
+    geofenceReceiver = null
+  }
+
+  // Sync result receiver (thin wiring only; delegates to SyncProvider.handleSyncResult which invokes onSync callback).
+  // Mirrors geofence broadcast pattern. No payload logic here. Provider owns emission shape.
+  private fun registerSyncReceiver() {
+    if (syncReceiver != null) return
+    syncReceiver = object : BroadcastReceiver() {
+      override fun onReceive(ctx: Context?, intent: Intent?) {
+        if (intent?.action != SyncProvider.SYNC_RESULT_ACTION) return
+        syncProvider.handleSyncResult(intent)
+      }
+    }
+    context.registerReceiver(syncReceiver, IntentFilter(SyncProvider.SYNC_RESULT_ACTION))
+  }
+
+  private fun unregisterSyncReceiver() {
+    syncReceiver?.let {
+      try { context.unregisterReceiver(it) } catch (_: Exception) {}
+    }
+    syncReceiver = null
+  }
+
+  // Activity receiver: listens for the broadcast fired by the PendingIntent registered with ActivityRecognitionClient.
+  // Delegates to activityProvider.handleActivityResult (which invokes the onActivityUpdate callback).
+  // Keeps provider thin (no registration or sendEvent inside provider). Matches geofence/sync receiver patterns.
+  private fun registerActivityReceiver() {
+    if (activityReceiver != null) return
+    activityReceiver = object : BroadcastReceiver() {
+      override fun onReceive(ctx: Context?, intent: Intent?) {
+        if (intent?.action == ActivityRecognitionProvider.ACTION_ACTIVITY_UPDATE) {
+          activityProvider.handleActivityResult(intent)
+        }
+      }
+    }
+    val filter = IntentFilter(ActivityRecognitionProvider.ACTION_ACTIVITY_UPDATE)
+    context.registerReceiver(activityReceiver, filter)
+  }
+
+  private fun unregisterActivityReceiver() {
+    activityReceiver?.let {
+      try { context.unregisterReceiver(it) } catch (_: Exception) {}
+    }
+    activityReceiver = null
+  }
+
+  // Scheduler logic now lives in the focused ScheduleProvider (see OnCreate wiring and start/stopSchedule).
+  // The provider mirrors iOS ScheduleManager's callback seam and config interval support.
+}
+
+// Lightweight shared object handle (facade / proxy to shared module state).
+// See design notes in Class(ThermsTracker) + JS ThermsDeviceTrackerModuleSharedObject.ts.
+// All ThermsTracker instances share the single tracking session state owned by the module.
+// We set ownerModule so Property handlers can use the 'ref' (instead of ignoring it).
+class ThermsTracker(appContext: AppContext) : expo.modules.kotlin.sharedobjects.SharedObject(appContext) {
+  // Nullable ref to owning module (set at construction time in Class block). No strong cycle.
+  var ownerModule: ThermsDeviceTrackerModule? = null
+
+  override fun sharedObjectDidRelease() {
+    // No per-handle cleanup needed; module owns session resources + receivers.
+    super.sharedObjectDidRelease()
+  }
+}