therms-device-tracker 1.0.0-rc.1

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

@@ -0,0 +1,292 @@
+package expo.modules.thermsdevicetracker
+
+import android.content.Context
+import android.content.Intent
+import androidx.work.*
+import org.json.JSONArray
+import org.json.JSONObject
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.TimeUnit
+
+/**
+ * Focused provider for opt-in native background HTTP sync (mirrors GeofenceProvider + schedule).
+ *
+ * Responsibilities:
+ * - Accept config from module (url, method, batch/immediate, interval).
+ * - Schedule via WorkManager (periodic for batch; one-time for immediate).
+ * - Perform native HTTP inside Worker (lightweight, no JS).
+ * - Emit via onSync callback var (consistent with iOS SyncManager; set by module after ctor).
+ *
+ * Naming seam note: iOS uses SyncManager (and *Manager for Schedule/Geofence); Android uses SyncProvider
+ * (and *Provider). This mirrors the established Geofence* split. Do not rename to preserve behavior.
+ *
+ * Result wiring uses broadcast receiver pattern in module (delegates to handleSyncResult).
+ * Keeps main module thin; all sync logic here. onSync callback used (no direct sendEvent from provider).
+ *
+ * This allows true bg sends without full RN/JS runtime. Requires WorkManager (standard in RN/Expo apps).
+ * Worker *prefers live* LocationStore.getAll() at execution (for batch freshness); snapshot in inputData
+ * is only for compat/fallback. Consumer decides on destroyLocations after success (see onSync success).
+ *
+ * Constraints: NETWORK_CONNECTED. Periodic (batch) / OneTime (immediate or syncNow).
+ *
+ * Android note: Periodic batch uses WorkManager; interval is clamped to >=15min minimum.
+ * A "warning" onSync state is emitted on start() if clamping occurred.
+ */
+
+// Protocol for data source seam (testability, mirrors iOS SyncDataSource protocol).
+// Allows injecting mock data sources. Injected store used for snapshot at enqueue (buildWorkInputData);
+// SyncWorker always prefers fresh LocationStore(applicationContext) at execution (live for batch) + snapshot fallback.
+interface SyncDataSource {
+  fun getAll(): List<Map<String, Any?>>
+}
+
+class SyncProvider(
+  private val context: Context,
+  private val store: SyncDataSource? = null
+) {
+  // Callback supplied by owner (module) -- consistent with iOS pattern (no sendEvent in ctor).
+  var onSync: ((Map<String, Any?>) -> Unit)? = null
+
+  private var config: Map<String, Any?>? = null
+  private var enabled = false
+
+  companion object {
+    const val SYNC_RESULT_ACTION = "expo.modules.thermsdevicetracker.SYNC_RESULT"
+    const val EXTRA_STATE = "state"
+    const val EXTRA_SUCCESS = "success"
+    const val EXTRA_STATUS = "status"
+    const val EXTRA_COUNT = "count"
+    const val EXTRA_MESSAGE = "message"
+
+    fun serializeItems(items: List<Map<String, Any?>>): String {
+      val ja = JSONArray()
+      for (item in items) {
+        val jo = JSONObject()
+        for ((k, v) in item) {
+          when (v) {
+            null -> jo.put(k, JSONObject.NULL)
+            is Number -> jo.put(k, v)
+            is Boolean -> jo.put(k, v)
+            else -> jo.put(k, v.toString())
+          }
+        }
+        ja.put(jo)
+      }
+      return ja.toString()
+    }
+
+    fun deserializeItems(jsonStr: String?): List<Map<String, Any?>> {
+      if (jsonStr.isNullOrEmpty()) return emptyList()
+      return try {
+        val ja = JSONArray(jsonStr)
+        (0 until ja.length()).map { i ->
+          val jo = ja.getJSONObject(i)
+          val m = mutableMapOf<String, Any?>()
+          val it = jo.keys()
+          while (it.hasNext()) {
+            val k = it.next() as String
+            val raw = jo.opt(k)
+            m[k] = when {
+              raw == JSONObject.NULL || jo.isNull(k) -> null
+              raw is Boolean -> raw
+              raw is Int -> raw
+              raw is Long -> raw
+              raw is Double -> raw
+              raw is Float -> raw.toDouble()
+              else -> raw.toString()
+            }
+          }
+          m
+        }
+      } catch (_: Exception) { emptyList() }
+    }
+  }
+
+  fun start(cfg: Map<String, Any?>?) {
+    stop()
+    config = cfg
+    enabled = (cfg?.get("enabled") as? Boolean) ?: false
+    if (!enabled || store == null) {
+      onSync?.invoke(mapOf("state" to "disabled"))
+      return
+    }
+    val url = cfg?.get("url") as? String ?: return
+    onSync?.invoke(mapOf("state" to "started", "url" to url))
+
+    val batch = (cfg?.get("batch") as? Boolean) ?: true
+    var intervalSec = ((cfg?.get("interval") as? Number)?.toLong() ?: 60L)
+    if (batch) {
+      val MIN_PERIODIC_SEC = 15 * 60L // Android WorkManager minimum for PeriodicWorkRequest
+      if (intervalSec < MIN_PERIODIC_SEC) {
+        intervalSec = MIN_PERIODIC_SEC
+        onSync?.invoke(mapOf("state" to "warning", "message" to "interval clamped to WorkManager min 15min"))
+      }
+    }
+
+    // Note: result receiver registration moved to module (broadcast pattern); we only emit via onSync.
+    val data = buildWorkInputData()
+
+    val constraints = Constraints.Builder()
+      .setRequiredNetworkType(NetworkType.CONNECTED)
+      .build()
+
+    val work: WorkRequest = if (batch) {
+      PeriodicWorkRequestBuilder<SyncWorker>(intervalSec, TimeUnit.SECONDS)
+        .setConstraints(constraints)
+        .setInputData(data)
+        .build()
+    } else {
+      OneTimeWorkRequestBuilder<SyncWorker>()
+        .setConstraints(constraints)
+        .setInputData(data)
+        .build()
+    }
+
+    if (batch) {
+      WorkManager.getInstance(context).enqueueUniquePeriodicWork(
+        "therms-sync",
+        ExistingPeriodicWorkPolicy.KEEP,
+        work as PeriodicWorkRequest
+      )
+    } else {
+      WorkManager.getInstance(context).enqueue(work)
+    }
+  }
+
+  fun stop() {
+    WorkManager.getInstance(context).cancelUniqueWork("therms-sync")
+    enabled = false
+    config = null
+    onSync?.invoke(mapOf("state" to "stopped"))
+  }
+
+  fun syncNow() {
+    if (!enabled) return
+    // Trigger one-time now. (forces immediate regardless of batch config)
+    val url = config?.get("url") as? String ?: return
+    // no per-call register; module receiver is registered unconditionally
+
+    val data = buildWorkInputData()
+    val req = OneTimeWorkRequestBuilder<SyncWorker>().setInputData(data).build()
+    WorkManager.getInstance(context).enqueue(req)
+  }
+
+  // Extracted to dedupe header+items + serialization (used by start + syncNow).
+  // NOTE on data model: we pass a snapshot via inputData primarily for immediate cases and compat.
+  // Workers prefer *live* store reads at execution time (see SyncWorker) so that batch/periodic
+  // picks up fresh data inserted after scheduling. This aligns batch behavior with iOS SyncManager
+  // (live store.getAll() inside performSync at timer/syncNow fire time).
+  // Snapshot fallback only if live empty (rare; e.g. no persistence or test store without disk).
+  // The `batch` flag is used only for scheduling choice (Periodic vs OneTime) in start(); it is
+  // deliberately not passed into Data (worker never read it; payload uses maxBatchSize + live getAll()).
+  private fun buildWorkInputData(): Data {
+    val url = config?.get("url") as? String ?: ""
+    val method = (config?.get("method") as? String) ?: "POST"
+    val headers = (config?.get("headers") as? Map<*, *>) ?: emptyMap<String, Any?>()
+    val headersJson = JSONObject(headers.mapKeys { it.key.toString() }.mapValues { (it.value ?: "").toString() }).toString()
+    val maxBatchSize = (config?.get("maxBatchSize") as? Number)?.toInt() ?: 0
+
+    // Snapshot at enqueue time (captures injected store at call). Worker will prefer live anyway for batch.
+    val snapshot = store?.getAll() ?: emptyList()
+    val itemsJson = serializeItems(snapshot)
+
+    return Data.Builder()
+      .putString("url", url)
+      .putString("method", method)
+      .putString("headersJson", headersJson)
+      .putInt("maxBatchSize", maxBatchSize)
+      .putString("itemsJson", itemsJson)
+      .build()
+  }
+
+  // Handle result from worker broadcast (called by module's registered receiver).
+  // All payload shaping + emission stays in provider (logic not leaked to thin module).
+  fun handleSyncResult(intent: Intent?) {
+    if (intent?.action != SYNC_RESULT_ACTION) return
+    val payload = mutableMapOf<String, Any?>()
+    intent.getStringExtra(EXTRA_STATE)?.let { payload["state"] = it }
+    payload["success"] = intent.getBooleanExtra(EXTRA_SUCCESS, true)
+    if (intent.hasExtra(EXTRA_STATUS)) payload["status"] = intent.getIntExtra(EXTRA_STATUS, -1)
+    if (intent.hasExtra(EXTRA_COUNT)) payload["count"] = intent.getIntExtra(EXTRA_COUNT, 0)
+    intent.getStringExtra(EXTRA_MESSAGE)?.let { payload["message"] = it }
+    onSync?.invoke(payload)
+  }
+
+  // Worker does the actual native HTTP.
+  // Data fetch: *always prefer live store* at execution (fresh for batch periodic and immediate).
+  // This makes batch use current persisted data at WorkManager run time (aligns with iOS live model in performSync).
+  // Passed itemsJson from buildWorkInputData is only fallback (e.g. if store empty at exec or no disk).
+  // Keeps seam: worker inside provider; module never sees raw items.
+  class SyncWorker(appContext: Context, params: WorkerParameters) : Worker(appContext, params) {
+    override fun doWork(): Result {
+      val urlStr = inputData.getString("url") ?: return Result.failure()
+      val method = inputData.getString("method") ?: "POST"
+      val headersJson = inputData.getString("headersJson") ?: "{}"
+      val maxBatchSize = inputData.getInt("maxBatchSize", 0)
+      val itemsJson = inputData.getString("itemsJson")
+
+      // Prefer live store reads at *execution time* for fresh batch data (consistent across periodic/immediate).
+      // This aligns exactly with iOS SyncManager.performSync which always does store.getAll() at fire time.
+      // Snapshot (itemsJson) is only fallback/compat for immediate cases or when no disk store present.
+      // Fallback to deserialized snapshot only if live yields nothing.
+      // IMPORTANT: consumer decides whether to call destroyLocations/destroyLocation after receiving onSync success.
+      // There is intentionally NO auto-drain here (see onSync success emission and public destroy* APIs).
+      val liveItems = LocationStore(applicationContext).getAll()
+      val items = if (liveItems.isNotEmpty()) liveItems else deserializeItems(itemsJson)
+      if (items.isEmpty()) {
+        sendSyncResult("noop", success = true, count = 0)
+        return Result.success()
+      }
+
+      val payloadList = if (maxBatchSize > 0) items.take(maxBatchSize) else items
+      val count = payloadList.size
+
+      try {
+        val url = URL(urlStr)
+        val conn = (url.openConnection() as HttpURLConnection).apply {
+          requestMethod = method.uppercase()
+          doOutput = true
+          setRequestProperty("Content-Type", "application/json")
+          try {
+            val hj = JSONObject(headersJson)
+            val iter = hj.keys()
+            while (iter.hasNext()) {
+              val k = iter.next() as String
+              setRequestProperty(k, hj.optString(k))
+            }
+          } catch (_: Exception) {}
+        }
+
+        // Use shared serialize (no duplication of map->json logic)
+        val bodyJson = serializeItems(payloadList)
+        conn.outputStream.use { os ->
+          os.write(bodyJson.toByteArray(Charsets.UTF_8))
+          os.flush()
+        }
+
+        val status = conn.responseCode
+        val success = status in 200..299
+        try { conn.inputStream.close() } catch (_: Exception) {}
+        conn.disconnect()
+
+        sendSyncResult(if (success) "success" else "error", success, status, count)
+        return if (success) Result.success() else Result.failure()
+      } catch (e: Exception) {
+        sendSyncResult("error", success = false, count = count, message = e.message ?: "network error")
+        return Result.failure()
+      }
+    }
+
+    private fun sendSyncResult(state: String, success: Boolean, status: Int? = null, count: Int = 0, message: String? = null) {
+      val intent = Intent(SYNC_RESULT_ACTION).apply {
+        putExtra(EXTRA_STATE, state)
+        putExtra(EXTRA_SUCCESS, success)
+        status?.let { putExtra(EXTRA_STATUS, it) }
+        putExtra(EXTRA_COUNT, count)
+        message?.let { putExtra(EXTRA_MESSAGE, it) }
+      }
+      applicationContext.sendBroadcast(intent)
+    }
+  }
+}