therms-device-tracker 1.0.0-rc.1

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

@@ -0,0 +1,109 @@
+package expo.modules.thermsdevicetracker
+
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import com.google.android.gms.location.*
+
+/**
+ * Focused provider for activity recognition (Android ActivityRecognition API).
+ *
+ * Mirrors iOS MotionActivityProvider (activity portion) + the style of LocationProvider + other *Provider on Android.
+ *
+ * Responsibilities:
+ * - Configure based on enableActivity flag.
+ * - Start/stop activity updates using ActivityRecognitionClient + PendingIntent.
+ * - Parse DetectedActivity to simple map (type, confidence[0-1], timestamp).
+ * - Emit via `onActivityUpdate` callback only — module wires sendEvent / state.
+ *
+ * Seam: injection of client for testability; callback only (no direct sendEvent).
+ * Uses broadcast action + dynamic receiver pattern in module (consistent with geofence/sync).
+ * Note: pedometer parity (Android data-only: PedometerRecord + enableStepCounting + session history for API shape;
+ * full live support + onPedometerUpdate via CMPedometer in iOS MotionActivityProvider). Full Android impl future.
+ */
+class ActivityRecognitionProvider(
+  private val context: Context,
+  private val client: ActivityRecognitionClient? = null
+) {
+  var onActivityUpdate: ((Map<String, Any>) -> Unit)? = null
+  var onError: ((String, String) -> Unit)? = null
+
+  private val activityClient: ActivityRecognitionClient by lazy {
+    client ?: ActivityRecognition.getClient(context)
+  }
+
+  private var enableActivity = true
+  private var activityPendingIntent: PendingIntent? = null
+
+  companion object {
+    const val ACTION_ACTIVITY_UPDATE = "expo.modules.thermsdevicetracker.ACTIVITY_UPDATE"
+  }
+
+  fun configure(enableActivity: Boolean) {
+    this.enableActivity = enableActivity
+  }
+
+  fun start() {
+    if (!enableActivity) return
+
+    val intent = Intent(ACTION_ACTIVITY_UPDATE).apply {
+      setPackage(context.packageName)
+    }
+    val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+    } else {
+      PendingIntent.FLAG_UPDATE_CURRENT
+    }
+    val pi = PendingIntent.getBroadcast(context, 0, intent, flags)
+    activityPendingIntent = pi
+
+    try {
+      activityClient.requestActivityUpdates(10000L, pi)
+        .addOnFailureListener { e ->
+          onError?.invoke("activity_error", e.message ?: "Failed to request activity updates")
+        }
+    } catch (e: SecurityException) {
+      onError?.invoke("permission_denied", e.message ?: "Activity recognition permission required")
+    }
+  }
+
+  fun stop() {
+    activityPendingIntent?.let { pi ->
+      try {
+        activityClient.removeActivityUpdates(pi)
+      } catch (_: Exception) {}
+    }
+    activityPendingIntent = null
+  }
+
+  /**
+   * Called by module's registered broadcast receiver when the PendingIntent fires.
+   * Parses result and invokes onActivityUpdate callback (seam consistent).
+   */
+  fun handleActivityResult(intent: Intent) {
+    if (intent.action != ACTION_ACTIVITY_UPDATE) return
+    val result = ActivityRecognitionResult.extractResult(intent) ?: return
+    val mostProbable = result.mostProbableActivity ?: return
+
+    val type = when (mostProbable.type) {
+      DetectedActivity.STILL -> "still"
+      DetectedActivity.WALKING, DetectedActivity.ON_FOOT -> "walking"
+      DetectedActivity.RUNNING -> "running"
+      DetectedActivity.ON_BICYCLE -> "cycling"
+      DetectedActivity.IN_VEHICLE -> "automotive"
+      else -> "unknown"
+    }
+    // Normalize 0-100 -> ~0-1 to align with iOS confidence scale used in dicts
+    val confidence = mostProbable.confidence / 100.0
+    val timestamp = result.time.toDouble()
+
+    onActivityUpdate?.invoke(
+      mapOf(
+        "type" to type,
+        "confidence" to confidence,
+        "timestamp" to timestamp
+      )
+    )
+  }
+}

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

@@ -0,0 +1,184 @@
+package expo.modules.thermsdevicetracker
+
+import android.content.Context
+import com.google.android.gms.location.Geofence
+import com.google.android.gms.location.GeofencingClient
+import com.google.android.gms.location.GeofencingRequest
+import com.google.android.gms.location.LocationServices
+
+/**
+ * Focused provider for geofence management.
+ * Extracted from the main module to follow separation of concerns (similar to iOS GeofenceManager).
+ *
+ * Seam: callbacks (onGeofence, onGeofencesChange, onError, lastLocationProvider) are set AFTER construction
+ * (see ThermsDeviceTrackerModule). Mirrors LocationProvider / SyncProvider / ScheduleProvider / ActivityRecognitionProvider.
+ * No send* or get* lambdas in ctor.
+ */
+class GeofenceProvider(
+  private val context: Context,
+  private val geofencingClient: GeofencingClient,
+  private val store: LocationStore? = null   // for geofence durability (persist/restore regions via load/saveGeofences)
+) {
+  private val activeGeofences = mutableMapOf<String, Map<String, Any?>>()
+
+  // Callback seam (set by owner after ctor; consistent style)
+  var onGeofence: ((Map<String, Any?>) -> Unit)? = null
+  var onGeofencesChange: ((Map<String, Any?>) -> Unit)? = null
+  var onError: ((String, String) -> Unit)? = null
+  var lastLocationProvider: (() -> Map<String, Any?>?)? = null
+
+  init {
+    // Stub: could auto-restore here, but caller controls (e.g. on startMonitoring)
+  }
+
+  fun addGeofence(map: Map<String, Any?>) {
+    val id = map["identifier"] as? String ?: return // silent no-op on bad input (consistent prior)
+    val lat = (map["latitude"] as? Number)?.toDouble() ?: return
+    val lon = (map["longitude"] as? Number)?.toDouble() ?: return
+    val radius = (map["radius"] as? Number)?.toFloat() ?: 100f
+
+    val notifyEntry = (map["notifyOnEntry"] as? Boolean) ?: true
+    val notifyExit = (map["notifyOnExit"] as? Boolean) ?: true
+
+    registerGeofence(id, lat, lon, radius, notifyEntry, notifyExit, map)
+
+    persistGeofences()
+    notifyChange()
+  }
+
+  // Internal: performs active set + client registration (no per-call persist/notify).
+  // Used by addGeofence (public) and startMonitoring bulk (to avoid redundant events/persists).
+  private fun registerGeofence(
+    id: String, lat: Double, lon: Double, radius: Float,
+    notifyEntry: Boolean, notifyExit: Boolean, map: Map<String, Any?>
+  ) {
+    val geofence = Geofence.Builder()
+      .setRequestId(id)
+      .setCircularRegion(lat, lon, radius)
+      .setExpirationDuration(Geofence.NEVER_EXPIRE)
+      .setTransitionTypes(
+        (if (notifyEntry) Geofence.GEOFENCE_TRANSITION_ENTER else 0) or
+          (if (notifyExit) Geofence.GEOFENCE_TRANSITION_EXIT else 0) or
+          Geofence.GEOFENCE_TRANSITION_DWELL
+      )
+      .setLoiteringDelay((map["loiteringDelay"] as? Number)?.toInt() ?: 30000)
+      .build()
+
+    val request = GeofencingRequest.Builder()
+      .setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER or GeofencingRequest.INITIAL_TRIGGER_EXIT)
+      .addGeofence(geofence)
+      .build()
+
+    activeGeofences[id] = map
+
+    try {
+      geofencingClient.addGeofences(request, createPendingIntent())
+        .addOnFailureListener { e -> onError?.invoke("geofence_error", e.message ?: "add failed") }
+    } catch (e: SecurityException) {
+      onError?.invoke("permission_denied", e.message ?: "geofence perm")
+    }
+    // Permission ensured by module (hasLocationPermission) + Security catch; geofence requires bg/fine.
+  }
+
+  fun addGeofences(list: List<Map<String, Any?>>) {
+    list.forEach { addGeofence(it) }
+  }
+
+  fun removeGeofence(id: String) {
+    activeGeofences.remove(id)
+    try {
+      geofencingClient.removeGeofences(listOf(id))
+    } catch (_: Exception) {} // Permission via module + caller; tolerate errors (pre-extract behavior)
+    persistGeofences()
+    notifyChange()
+  }
+
+  fun removeGeofences(ids: List<String>?) {
+    if (ids != null) {
+      ids.forEach { removeGeofence(it) }
+    } else {
+      val all = activeGeofences.keys.toList()
+      activeGeofences.clear()
+      if (all.isNotEmpty()) {
+        try { geofencingClient.removeGeofences(all) } catch (_: Exception) {} // consistent error tolerance
+      }
+      persistGeofences()
+      notifyChange()
+    }
+  }
+
+  fun getGeofences(): List<Map<String, Any?>> = activeGeofences.values.toList()
+
+  fun startMonitoring() {
+    // Improve durability: restore populates only (no side effects).
+    restorePersistedGeofences()
+    // Re-register clients in bulk; side effects (persist/notify) done once after to avoid multiples.
+    val toRegister = activeGeofences.values.toList()
+    toRegister.forEach { m ->
+      val id = m["identifier"] as? String ?: return@forEach
+      val lat = (m["latitude"] as? Number)?.toDouble() ?: return@forEach
+      val lon = (m["longitude"] as? Number)?.toDouble() ?: return@forEach
+      val radius = (m["radius"] as? Number)?.toFloat() ?: 100f
+      val entry = (m["notifyOnEntry"] as? Boolean) ?: true
+      val exit = (m["notifyOnExit"] as? Boolean) ?: true
+      registerGeofence(id, lat, lon, radius, entry, exit, m)
+    }
+    if (toRegister.isNotEmpty()) {
+      persistGeofences()
+      notifyChange()
+    }
+  }
+
+  // Called by the receiver (via module) when a transition occurs
+  fun handleTransition(transition: Int, ids: List<String>) {
+    val action = when (transition) {
+      Geofence.GEOFENCE_TRANSITION_ENTER -> "ENTER"
+      Geofence.GEOFENCE_TRANSITION_EXIT -> "EXIT"
+      Geofence.GEOFENCE_TRANSITION_DWELL -> "DWELL"
+      else -> "UNKNOWN"
+    }
+
+    ids.forEach { id ->
+      val base = activeGeofences[id] ?: mapOf("identifier" to id) // fallback tolerant even w/o restore
+      val evt = base.toMutableMap().apply {
+        put("identifier", id)
+        put("action", action)
+        lastLocationProvider?.invoke()?.let { put("location", it) }
+      }
+      onGeofence?.invoke(evt)
+    }
+  }
+
+  private fun notifyChange() {
+    onGeofencesChange?.invoke(
+      mapOf("on" to activeGeofences.values.toList(), "off" to emptyList<Any>())
+    )
+  }
+
+  // Persistence for geofence durability (regions survive app restart).
+  private fun persistGeofences() {
+    store?.saveGeofences(activeGeofences.values.toList())
+  }
+
+  private fun restorePersistedGeofences() {
+    val saved = store?.loadGeofences() ?: emptyList()
+    if (saved.isNotEmpty()) {
+      saved.forEach {
+        val id = it["identifier"] as? String ?: return@forEach
+        activeGeofences[id] = it
+      }
+    }
+  }
+
+  private fun createPendingIntent(): android.app.PendingIntent {
+    val intent = android.content.Intent(context, GeofenceTransitionReceiver::class.java).apply {
+      action = GeofenceTransitionReceiver.ACTION
+    }
+    val flags = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+      android.app.PendingIntent.FLAG_UPDATE_CURRENT or android.app.PendingIntent.FLAG_MUTABLE
+    } else {
+      android.app.PendingIntent.FLAG_UPDATE_CURRENT
+    }
+    return android.app.PendingIntent.getBroadcast(context, 0, intent, flags)
+  }
+}

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

@@ -0,0 +1,34 @@
+package expo.modules.thermsdevicetracker
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.google.android.gms.location.Geofence
+import com.google.android.gms.location.GeofencingEvent
+
+/**
+ * BroadcastReceiver to receive geofence transition events from GeofencingClient.
+ * Forwards to the module via broadcast with extras (module listens).
+ */
+class GeofenceTransitionReceiver : BroadcastReceiver() {
+  companion object {
+    const val ACTION = "expo.modules.thermsdevicetracker.GEOFENCE_TRANSITION"
+    const val EXTRA_TRANSITION = "transition"
+    const val EXTRA_IDS = "geofence_ids"
+  }
+
+  override fun onReceive(context: Context, intent: Intent) {
+    val event = GeofencingEvent.fromIntent(intent) ?: return
+    if (event.hasError()) return
+
+    val transition = event.geofenceTransition
+    val triggeringGeofences = event.triggeringGeofences ?: emptyList()
+    val ids = ArrayList(triggeringGeofences.map { it.requestId })
+
+    val outIntent = Intent(ACTION).apply {
+      putExtra(EXTRA_TRANSITION, transition)
+      putStringArrayListExtra(EXTRA_IDS, ids)
+    }
+    context.sendBroadcast(outIntent)
+  }
+}

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

@@ -0,0 +1,84 @@
+package expo.modules.thermsdevicetracker
+
+import android.content.Context
+import android.os.Looper
+import com.google.android.gms.location.*
+
+/**
+ * Focused provider for location concerns (fused client configuration + fg updates).
+ *
+ * Mirrors iOS LocationProvider.swift + the style of other Android providers
+ * (GeofenceProvider, SyncProvider, ScheduleProvider).
+ *
+ * Responsibilities (fg path):
+ * - Configure priority / interval / distanceFilter.
+ * - Start / stop location updates using FusedLocationProviderClient.
+ *
+ * Bg path remains coordinated via ThermsLocationService + broadcast (module level)
+ * for now; this provider focuses on direct fg + shared config seam.
+ * (Full Android bg location provider usage / unification is future work.)
+ *
+ * Seam: module wires `onNewLocation` callback (or consumes via start).
+ * No direct sendEvent here; module owns event + state + sync trigger (keeps provider thin).
+ *
+ * Test seam precedent: callers can inject a mock FusedLocationProviderClient.
+ */
+class LocationProvider(
+  private val context: Context,
+  private val fusedClient: FusedLocationProviderClient? = null
+) {
+  private val client: FusedLocationProviderClient by lazy {
+    fusedClient ?: LocationServices.getFusedLocationProviderClient(context)
+  }
+
+  var onNewLocation: ((android.location.Location) -> Unit)? = null
+  var onError: ((String, String) -> Unit)? = null
+
+  private var currentCallback: LocationCallback? = null
+  private var currentRequest: LocationRequest? = null
+
+  fun configure(
+    priority: Int = Priority.PRIORITY_BALANCED_POWER_ACCURACY,
+    intervalMs: Long = 5000L,
+    minDistanceMeters: Float = 0f
+  ) {
+    currentRequest = LocationRequest.Builder(priority, intervalMs)
+      .setMinUpdateDistanceMeters(minDistanceMeters)
+      .build()
+  }
+
+  fun startUpdatingLocation() {
+    val request = currentRequest ?: LocationRequest.Builder(
+      Priority.PRIORITY_BALANCED_POWER_ACCURACY, 5000L
+    ).build()
+
+    currentCallback = object : LocationCallback() {
+      override fun onLocationResult(result: LocationResult) {
+        result.lastLocation?.let { loc ->
+          onNewLocation?.invoke(loc)
+        }
+      }
+    }
+
+    try {
+      client.requestLocationUpdates(
+        request,
+        currentCallback!!,
+        Looper.getMainLooper()
+      )
+    } catch (e: SecurityException) {
+      onError?.invoke("permission_denied", e.message ?: "Location permission required")
+    }
+  }
+
+  fun stopUpdatingLocation() {
+    currentCallback?.let {
+      try {
+        client.removeLocationUpdates(it)
+      } catch (_: Exception) {}
+    }
+    currentCallback = null
+  }
+
+  fun getClient(): FusedLocationProviderClient = client
+}

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

@@ -0,0 +1,150 @@
+package expo.modules.thermsdevicetracker
+
+import android.content.Context
+import android.content.SharedPreferences
+
+/**
+ * Android equivalent of iOS LocationStore.
+ * Extracted persistence logic (SharedPreferences) to keep main module thin and testable.
+ * Supports stable "id" for destroyLocation(id).
+ *
+ * Follows patterns: simple focused class, like LocationProvider / GeofenceProvider direction.
+ * Includes full geofence storage (save/load/clear + roundtrip) wired by GeofenceProvider for durability.
+ */
+class LocationStore(context: Context, prefs: SharedPreferences? = null) : SyncDataSource {
+  private val prefs: SharedPreferences =
+    prefs ?: context.getSharedPreferences("therms_persist", Context.MODE_PRIVATE)
+  private val persistedLocationsKey = "persisted_locations"
+  private val persistedGeofencesKey = "persisted_geofences"
+
+  fun clear() {
+    prefs.edit().remove(persistedLocationsKey).apply()
+  }
+
+  fun insert(loc: Map<String, Any?>) {
+    var record = loc.toMutableMap()
+    if (record["id"] == null) {
+      record["id"] = java.util.UUID.randomUUID().toString()
+    }
+    val current = load()
+    val updated = (current + record).takeLast(500)
+    save(updated)
+  }
+
+  fun remove(byId: String?) {
+    if (byId == null) return
+    val current = load().toMutableList()
+    current.removeAll { (it["id"] as? String) == byId }
+    save(current)
+  }
+
+  fun count(): Int = load().size
+
+  override fun getAll(): List<Map<String, Any?>> = load()
+
+  // Internal load/save using the compact persisted format (id,lat,lon,ts || separated)
+  // Tolerant of older records.
+  private fun load(): List<Map<String, Any?>> {
+    val raw = prefs.getString(persistedLocationsKey, "") ?: ""
+    if (raw.isEmpty()) return emptyList()
+    return raw.split("||").mapNotNull { seg ->
+      val p = seg.split(",")
+      when {
+        p.size >= 4 -> mapOf(
+          "id" to p[0],
+          "latitude" to (p[1].toDoubleOrNull() ?: 0.0),
+          "longitude" to (p[2].toDoubleOrNull() ?: 0.0),
+          "timestamp" to (p[3].toDoubleOrNull() ?: 0.0)
+        )
+        p.size >= 3 -> mapOf(
+          "id" to java.util.UUID.randomUUID().toString(),
+          "latitude" to (p[0].toDoubleOrNull() ?: 0.0),
+          "longitude" to (p[1].toDoubleOrNull() ?: 0.0),
+          "timestamp" to (p[2].toDoubleOrNull() ?: 0.0)
+        )
+        else -> null
+      }
+    }
+  }
+
+  private fun save(list: List<Map<String, Any?>>) {
+    val s = list.joinToString("||") { m ->
+      val id = m["id"] ?: java.util.UUID.randomUUID().toString()
+      "$id,${m["latitude"] ?: 0},${m["longitude"] ?: 0},${m["timestamp"] ?: 0}"
+    }
+    prefs.edit().putString(persistedLocationsKey, s).apply()
+  }
+
+  // Geofence storage for durability / parity with iOS (core fields roundtrip).
+  // Serialized as delimited (no JSON dep). Optional 7th field for extras (k=v;k2=v2 with minimal escaping for ;/= using %3B/%3D, tolerates legacy 6-field).
+  // Extras roundtripped when present to match iOS dict preservation.
+  // Wired via GeofenceProvider (persist on mutations, restore on startMonitoring).
+  fun loadGeofences(): List<Map<String, Any?>> {
+    val raw = prefs.getString(persistedGeofencesKey, "") ?: ""
+    if (raw.isEmpty()) return emptyList()
+    return raw.split("||").mapNotNull { seg ->
+      val p = seg.split("|")
+      if (p.size >= 6) {
+        val base = mapOf<String, Any?>(
+          "identifier" to p[0],
+          "latitude" to (p[1].toDoubleOrNull() ?: 0.0),
+          "longitude" to (p[2].toDoubleOrNull() ?: 0.0),
+          "radius" to (p[3].toDoubleOrNull() ?: 100.0),
+          "notifyOnEntry" to (p[4] == "1"),
+          "notifyOnExit" to (p[5] == "1")
+        )
+        if (p.size >= 7 && p[6].isNotBlank()) {
+          base + ("extras" to parseExtras(p[6]))
+        } else base
+      } else null
+    }
+  }
+
+  fun saveGeofences(geofences: List<Map<String, Any?>>) {
+    val s = geofences.joinToString("||") { m ->
+      val id = m["identifier"] ?: ""
+      val lat = (m["latitude"] as? Number)?.toDouble() ?: 0.0
+      val lon = (m["longitude"] as? Number)?.toDouble() ?: 0.0
+      val rad = (m["radius"] as? Number)?.toDouble() ?: 100.0
+      val entry = if ((m["notifyOnEntry"] as? Boolean) ?: true) "1" else "0"
+      val exit = if ((m["notifyOnExit"] as? Boolean) ?: true) "1" else "0"
+      val ex = serializeExtras(m["extras"] as? Map<*, *>)
+      "$id|$lat|$lon|$rad|$entry|$exit|$ex"
+    }
+    prefs.edit().putString(persistedGeofencesKey, s).apply()
+  }
+
+  private fun serializeExtras(ex: Map<*, *>?): String {
+    if (ex == null || ex.isEmpty()) return ""
+    return ex.entries.joinToString(";") { e ->
+      val k = escape(e.key?.toString() ?: "")
+      val v = escape(e.value?.toString() ?: "")
+      "$k=$v"
+    }
+  }
+
+  private fun parseExtras(s: String): Map<String, Any?> {
+    if (s.isBlank()) return emptyMap()
+    return s.split(";").mapNotNull { pair ->
+      val kv = pair.split("=", limit = 2)
+      if (kv.size == 2) {
+        val k = unescape(kv[0])
+        val vs = unescape(kv[1])
+        val v: Any? = when {
+          vs.equals("true", ignoreCase = true) -> true
+          vs.equals("false", ignoreCase = true) -> false
+          vs.toDoubleOrNull() != null -> vs.toDoubleOrNull()
+          else -> vs
+        }
+        k to v
+      } else null
+    }.toMap()
+  }
+
+  private fun escape(s: String): String = s.replace(";", "%3B").replace("=", "%3D")
+  private fun unescape(s: String): String = s.replace("%3B", ";").replace("%3D", "=")
+
+  fun clearGeofences() {
+    prefs.edit().remove(persistedGeofencesKey).apply()
+  }
+}

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

@@ -0,0 +1,55 @@
+package expo.modules.thermsdevicetracker
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+
+/**
+ * Focused provider for schedule/heartbeat concerns (mirrors iOS ScheduleManager).
+ *
+ * Extracted to keep the main ThermsDeviceTrackerModule thin and improve cross-platform
+ * parity with iOS (which honors `schedule.interval` via ScheduleManager).
+ *
+ * Responsibilities:
+ * - Start/stop a configurable heartbeat.
+ * - Emit via onSchedule callback (consistent seam with onSync, onGeofence, etc.).
+ * - Accept simple config (interval in seconds).
+ *
+ * Current implementation is still a demo timer (process must be alive). Real background
+ * schedules would use WorkManager + BGTaskScheduler equivalents (documented limitation).
+ *
+ * Seam: owner sets `onSchedule` after construction (or pass via ctor in future).
+ */
+class ScheduleProvider(
+  private val context: Context
+) {
+  var onSchedule: ((Map<String, Any?>) -> Unit)? = null
+
+  private var scheduleHandler: Handler? = null
+  private var scheduleRunnable: Runnable? = null
+
+  fun start(config: Map<String, Any?>? = null) {
+    stop()
+    onSchedule?.invoke(mapOf("state" to "started"))
+
+    // Honor interval from config when provided (parity with iOS ScheduleManager).
+    // Default 60s to match prior inline behavior.
+    val intervalMs = ((config?.get("interval") as? Number)?.toLong() ?: 60L) * 1000L
+
+    scheduleHandler = Handler(Looper.getMainLooper())
+    scheduleRunnable = object : Runnable {
+      override fun run() {
+        onSchedule?.invoke(mapOf("state" to "heartbeat"))
+        scheduleHandler?.postDelayed(this, intervalMs)
+      }
+    }
+    scheduleHandler?.postDelayed(scheduleRunnable!!, intervalMs)
+  }
+
+  fun stop() {
+    scheduleRunnable?.let { scheduleHandler?.removeCallbacks(it) }
+    scheduleHandler = null
+    scheduleRunnable = null
+    onSchedule?.invoke(mapOf("state" to "stopped"))
+  }
+}