spotny-sdk 1.0.0

package/android/src/main/java/com/spotnysdk/SpotnySdkModule.kt

@@ -0,0 +1,685 @@
+package com.spotnysdk
+
+import android.content.Context
+import android.os.RemoteException
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import org.altbeacon.beacon.*
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+import java.text.SimpleDateFormat
+import java.util.*
+import java.util.concurrent.Executors
+import kotlin.math.abs
+
+// ── Kontakt.io iBeacon layout ─────────────────────────────────────────────────
+private const val IBEACON_LAYOUT = "m:2-3=0215,i:4-19,i:20-21,i:22-23,p:24-24"
+private const val BEACON_UUID    = "f7826da6-4fa2-4e98-8024-bc5b71e0893e"
+private const val TAG            = "SpotnySDK"
+
+// ── Campaign data ─────────────────────────────────────────────────────────────
+private data class CampaignData(
+  val campaignId: Int?,
+  val screenId: Int,
+  val sessionId: String?,
+  val inQueue: Boolean,
+  val major: Int,
+  val minor: Int
+)
+
+class SpotnySdkModule(private val reactContext: ReactApplicationContext) :
+  NativeSpotnySdkSpec(reactContext) {
+
+  // ── Managers ──────────────────────────────────────────────────────────────
+  private val beaconManager: BeaconManager = BeaconManager.getInstanceForApplication(reactContext)
+  private val ioExecutor = Executors.newCachedThreadPool()
+
+  // ── Session state ─────────────────────────────────────────────────────────
+  @Volatile private var scanning       = false
+  /** Authenticated user ID — required at initialize(). Embedded in JWT via /api/app/sdk/verify. */
+  private var userId: String? = null
+
+  // ── Configuration ─────────────────────────────────────────────────────────
+  // backendURL is fixed — not overridable by consumers.
+  private val backendURL            = "https://api.spotny.app"
+  private var maxDetectionDistance  = 8.0  // metres
+  /** Multiplier applied to raw BLE distance. Default 0.5 matches Kontakt.io -12 dBm beacons. */
+  private var distanceCorrectionFactor = 0.5
+  /** API key identifying the SDK consumer (e.g. "nike"). Set during initialize(). */
+  private var apiKey: String?     = null
+  /** JWT returned by /api/app/sdk/verify. Injected as Authorization header on all subsequent calls. */
+  private var sdkToken: String?     = null
+  /** Expiry time of the current JWT in ms (epoch). When exceeded the JWT is auto-refreshed. */
+  private var sdkTokenExpiry: Long? = null
+  /** Original SDK token — persisted so JWT can be refreshed without calling initialize() again. */
+  private var sdkCredential: String? = null
+
+  // ── Timing constants ──────────────────────────────────────────────────────
+  private var campaignFetchCooldown         = 5_000L  // ms
+  private var proximityDistanceThreshold    = 0.75
+  private var impressionEventInterval       = 10_000L  // ms
+  private val impressionDistance            = 2.0
+  private var debounceInterval              = 5_000L  // ms
+
+  // ── Per-beacon state ──────────────────────────────────────────────────────
+  private val activeCampaigns           = mutableMapOf<String, CampaignData>()
+  private val lastProximityEventSent    = mutableMapOf<String, Long>()
+  private val lastProximityDistance     = mutableMapOf<String, Double>()
+  private val lastImpressionEventSent   = mutableMapOf<String, Long>()
+  private val lastCampaignFetchAttempt  = mutableMapOf<String, Long>()
+  private val fetchInProgress           = mutableMapOf<String, Boolean>()
+  private val proximityEventInProgress  = mutableMapOf<String, Boolean>()
+  private val impressionEventInProgress = mutableMapOf<String, Boolean>()
+
+  // ── Module registration ───────────────────────────────────────────────────
+
+  override fun getName() = NAME
+
+  override fun initialize() {
+    super.initialize()
+    setupBeaconManager()
+    resumeStoredSession()
+  }
+
+  // ── Setup ─────────────────────────────────────────────────────────────────
+
+  private fun setupBeaconManager() {
+    BeaconManager.setDebug(false)
+    beaconManager.beaconParsers.add(BeaconParser().setBeaconLayout(IBEACON_LAYOUT))
+    beaconManager.foregroundScanPeriod = 1_100L
+    beaconManager.foregroundBetweenScanPeriod = 0L
+    beaconManager.backgroundScanPeriod = 10_000L
+    beaconManager.backgroundBetweenScanPeriod = 5_000L
+  }
+
+  private fun resumeStoredSession() {
+    val prefs = reactContext.getSharedPreferences("SpotnySDK", Context.MODE_PRIVATE)
+    if (!prefs.getBoolean("sessionActive", false)) return
+    // Restore persisted JWT + credentials so all API calls work without initialize()
+    sdkToken      = prefs.getString("jwt", null)
+    sdkCredential = prefs.getString("sdkCredential", null)
+    apiKey        = prefs.getString("sdkApiKey", null)
+    userId        = prefs.getString("sdkUserId", null)
+    val expiry    = prefs.getLong("jwtExpiry", -1L).takeIf { it > 0 }
+    if (expiry != null) sdkTokenExpiry = expiry
+    Log.d(TAG, "Resuming session (device: ${getDeviceId()})")
+    startBeaconScanning()
+    scanning = true
+  }
+
+  // ── Turbo Module methods ──────────────────────────────────────────────────
+
+  override fun startScanner(promise: Promise) {
+    if (scanning) { promise.resolve("Already scanning"); return }
+
+    val prefs = reactContext.getSharedPreferences("SpotnySDK", Context.MODE_PRIVATE).edit()
+    prefs.putBoolean("sessionActive", true)
+    prefs.apply()
+
+    startBeaconScanning()
+    scanning = true
+    Log.d(TAG, "Started scanning (device: ${getDeviceId()})")
+    promise.resolve("Scanning started")
+  }
+
+  override fun stopScanner(promise: Promise) {
+    try {
+      beaconManager.removeAllMonitorNotifiers()
+      beaconManager.removeAllRangeNotifiers()
+      beaconManager.stopRangingBeaconsInRegion(Region("SpotnySDK_General", null, null, null))
+      beaconManager.stopMonitoringBeaconsInRegion(Region("SpotnySDK_General", null, null, null))
+    } catch (_: RemoteException) {}
+
+    cleanupAllState()
+
+    val prefs = reactContext.getSharedPreferences("SpotnySDK", Context.MODE_PRIVATE).edit()
+    prefs.remove("sessionActive"); prefs.apply()
+
+    scanning = false
+    Log.d(TAG, "Stopped scanning")
+    promise.resolve("Scanning stopped")
+  }
+
+  override fun isScanning(promise: Promise) = promise.resolve(scanning)
+
+  override fun initialize(config: ReadableMap?, promise: Promise) {
+    config?.getDouble("maxDetectionDistance").takeIf { config?.hasKey("maxDetectionDistance") == true }
+      ?.let { maxDetectionDistance = it; Log.d(TAG, "maxDetectionDistance = $it m") }
+    config?.getString("apiKey")?.let { apiKey = it; Log.d(TAG, "apiKey = $it") }
+    config?.getDouble("distanceCorrectionFactor")
+      .takeIf { config?.hasKey("distanceCorrectionFactor") == true && it > 0 }
+      ?.let { distanceCorrectionFactor = it; Log.d(TAG, "distanceCorrectionFactor = $it") }
+    val token = config?.getString("token")?.takeIf { it.isNotBlank() }
+    if (token == null) {
+      promise.reject("MISSING_TOKEN", "initialize() requires a token")
+      return
+    }
+    val key = apiKey?.takeIf { it.isNotBlank() }
+    if (key == null) {
+      promise.reject("MISSING_API_KEY", "initialize() requires an apiKey")
+      return
+    }
+    config?.getString("userId")?.takeIf { it.isNotBlank() }?.let { userId = it }
+    val uid = userId?.takeIf { it.isNotBlank() }
+    if (uid == null) {
+      promise.reject("MISSING_USER_ID", "initialize() requires a userId")
+      return
+    }
+
+    // Send token + apiKey + userId to backend — response returns a JWT used for all subsequent calls
+    // sdkToken is null here so no Authorization header is injected on this call
+    val verifyPayload = mapOf("token" to token, "api_key" to key, "user_id" to uid)
+    post("/api/app/sdk/verify", verifyPayload) { status, body ->
+      when {
+        status in 200..299 -> {
+          val verifyJson = try { parseJsonObject(body) } catch (_: Exception) { null }
+          val verifyData = verifyJson?.get("data") as? Map<*, *>
+          val jwt = (verifyData?.get("jwt") as? String)?.takeIf { it.isNotBlank() }
+          if (jwt == null) {
+            promise.reject("VERIFY_FAILED", "SDK verification response missing JWT")
+            return@post
+          }
+          sdkToken      = jwt
+          sdkCredential = token
+          val expiresAt = (verifyData?.get("expires_at") as? Number)?.toLong()
+          if (expiresAt != null) sdkTokenExpiry = expiresAt * 1000L  // seconds → ms
+          persistJWT()
+          Log.d(TAG, "SDK initialized — JWT stored, expires: ${sdkTokenExpiry?.let { java.util.Date(it) } ?: "no expiry"}")
+          promise.resolve("SDK initialized")
+        }
+        status == 401 || status == 403 -> {
+          Log.w(TAG, "Token unauthorized ($status)")
+          promise.reject("UNAUTHORIZED", "Invalid or expired SDK token")
+        }
+        else -> {
+          Log.w(TAG, "Verification failed ($status)")
+          promise.reject("VERIFY_FAILED", "SDK verification returned status $status")
+        }
+      }
+    }
+  }
+
+  override fun requestNotificationPermissions(promise: Promise) {
+    // On Android, notification permission is handled at the app level (API 33+).
+    // We just resolve — the app should request POST_NOTIFICATIONS separately.
+    promise.resolve("handled_by_app")
+  }
+
+  override fun getDebugLogs(promise: Promise) {
+    val file = logFile()
+    promise.resolve(if (file.exists()) file.readText() else "No logs found")
+  }
+
+  override fun clearDebugLogs(promise: Promise) {
+    logFile().takeIf { it.exists() }?.delete()
+    promise.resolve("Logs cleared")
+  }
+
+  override fun setDebounceInterval(interval: Double, promise: Promise) {
+    debounceInterval = interval.toLong() * 1000L
+    promise.resolve("Debounce interval set to ${interval}s")
+  }
+
+  override fun clearDebounceCache(promise: Promise) {
+    lastCampaignFetchAttempt.clear(); fetchInProgress.clear()
+    promise.resolve("Debounce cache cleared")
+  }
+
+
+  override fun getDebounceStatus(promise: Promise) {
+    val map = WritableNativeMap()
+    for ((key, _) in activeCampaigns) {
+      val entry = WritableNativeMap()
+      lastCampaignFetchAttempt[key]?.let { entry.putDouble("lastFetchAttempt", it.toDouble()) }
+      fetchInProgress[key]?.let          { entry.putBoolean("fetchInProgress", it) }
+      lastProximityEventSent[key]?.let   { entry.putDouble("lastProximityEvent", it.toDouble()) }
+      lastImpressionEventSent[key]?.let  { entry.putDouble("lastImpressionEvent", it.toDouble()) }
+      map.putMap(key, entry)
+    }
+    promise.resolve(map)
+  }
+
+  // Required by NativeEventEmitter contract in new-arch
+  override fun addListener(eventName: String) {}
+  override fun removeListeners(count: Double) {}
+
+  // ── Beacon scanning ──────────────────────────────────────────────────────
+
+  private fun startBeaconScanning() {
+    val region = Region("SpotnySDK_General", Identifier.parse(BEACON_UUID), null, null)
+
+    beaconManager.addRangeNotifier(rangeNotifier)
+    beaconManager.addMonitorNotifier(monitorNotifier)
+
+    beaconManager.startRangingBeaconsInRegion(region)
+    beaconManager.startMonitoringBeaconsInRegion(region)
+
+    Log.d(TAG, "Scanning for UUID $BEACON_UUID")
+  }
+
+  // ── Range notifier ────────────────────────────────────────────────────────
+
+  private val rangeNotifier = RangeNotifier { beacons, region ->
+    val now = System.currentTimeMillis()
+
+    // JS event payload
+    val jsBeacons = WritableNativeArray()
+    for (beacon in beacons) {
+      val raw = beacon.distance
+      val adjusted = raw * distanceCorrectionFactor
+      if (adjusted <= 0 || adjusted > maxDetectionDistance) continue
+
+      val b = WritableNativeMap().apply {
+        putString("uuid",      beacon.id1?.toString() ?: BEACON_UUID)
+        putInt("major",        beacon.id2?.toInt() ?: 0)
+        putInt("minor",        beacon.id3?.toInt() ?: 0)
+        putDouble("distance",  adjusted)
+        putInt("rssi",         beacon.rssi)
+        putString("proximity", proximityLabel(adjusted))
+      }
+      jsBeacons.pushMap(b)
+    }
+    if (jsBeacons.size() > 0) {
+      val payload = WritableNativeMap().apply {
+        putArray("beacons", jsBeacons)
+        putString("region",  region.uniqueId)
+      }
+      sendEvent("onBeaconsRanged", payload)
+    }
+
+    // Per-beacon logic
+    for (beacon in beacons) {
+      val major    = beacon.id2?.toInt() ?: continue
+      val minor    = beacon.id3?.toInt() ?: continue
+      val key      = beaconKey(major, minor)
+      val distance = beacon.distance * distanceCorrectionFactor
+
+      if (distance <= 0 || distance > maxDetectionDistance) continue
+
+      if (activeCampaigns.containsKey(key)) {
+        val isFirst = !lastProximityEventSent.containsKey(key)
+        if (isFirst) {
+          sendProximity("NEARBY", key, distance)
+          lastProximityDistance[key] = distance
+          lastProximityEventSent[key] = now
+        } else if (distance >= 1.0) {
+          val lastDist = lastProximityDistance[key] ?: 0.0
+          if (abs(distance - lastDist) >= proximityDistanceThreshold) {
+            sendProximity("NEARBY", key, distance)
+            lastProximityDistance[key] = distance
+            lastProximityEventSent[key] = now
+          }
+        }
+        val campaign = activeCampaigns[key]
+        if (campaign?.campaignId != null && campaign.inQueue == false && distance <= impressionDistance) {
+          val lastImp = lastImpressionEventSent[key]
+          if (lastImp == null || now - lastImp >= impressionEventInterval) {
+            sendImpression(key, distance)
+            lastImpressionEventSent[key] = now
+          }
+        }
+      } else {
+        fetchCampaign(major, minor)
+      }
+    }
+  }
+
+  // ── Monitor notifier ──────────────────────────────────────────────────────
+
+  private val monitorNotifier = object : MonitorNotifier {
+    override fun didEnterRegion(region: Region) {
+      Log.d(TAG, "Entered region: ${region.uniqueId}")
+      val payload = WritableNativeMap().apply {
+        putString("region", region.uniqueId)
+        putString("event",  "enter")
+      }
+      sendEvent("onBeaconRegionEvent", payload)
+      try { beaconManager.startRangingBeaconsInRegion(region) } catch (_: RemoteException) {}
+    }
+
+    override fun didExitRegion(region: Region) {
+      Log.d(TAG, "Exited region: ${region.uniqueId}")
+      val payload = WritableNativeMap().apply {
+        putString("region", region.uniqueId)
+        putString("event",  "exit")
+      }
+      sendEvent("onBeaconRegionEvent", payload)
+      for (key in activeCampaigns.keys.toList()) {
+        cleanupBeacon(key)
+      }
+      try { beaconManager.stopRangingBeaconsInRegion(region) } catch (_: RemoteException) {}
+    }
+
+    override fun didDetermineStateForRegion(state: Int, region: Region) {
+      val label = if (state == MonitorNotifier.INSIDE) "inside" else "outside"
+      val payload = WritableNativeMap().apply {
+        putString("region", region.uniqueId)
+        putString("event",  "determined")
+        putString("state",  label)
+      }
+      sendEvent("onBeaconRegionEvent", payload)
+    }
+  }
+
+  // ── Helpers ───────────────────────────────────────────────────────────────
+
+  private fun beaconKey(major: Int, minor: Int) = "${major}_${minor}"
+
+  private fun proximityLabel(distance: Double) = when {
+    distance < 0   -> "unknown"
+    distance < 0.5 -> "immediate"
+    distance < 3.0 -> "near"
+    else           -> "far"
+  }
+
+  private fun getDeviceId(): String {
+    val prefs = reactContext.getSharedPreferences("SpotnySDK", Context.MODE_PRIVATE)
+    return prefs.getString("deviceId", null) ?: run {
+      val id = UUID.randomUUID().toString()
+      prefs.edit().putString("deviceId", id).apply()
+      id
+    }
+  }
+
+  private fun sendEvent(name: String, payload: WritableMap) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(name, payload)
+  }
+
+  private fun logFile() = File(reactContext.filesDir, "spotny_beacon_debug.log")
+
+  private fun logToFile(message: String) {
+    ioExecutor.execute {
+      try {
+        val ts = SimpleDateFormat("yy-MM-dd HH:mm:ss", Locale.US).format(Date())
+        logFile().appendText("[$ts] $message\n")
+      } catch (_: Exception) {}
+    }
+  }
+
+  // ── State cleanup ─────────────────────────────────────────────────────────
+
+  private fun cleanupBeacon(key: String) {
+    sendProximity("PROXIMITY_EXIT", key, 0.0)
+    activeCampaigns.remove(key)
+    lastProximityEventSent.remove(key)
+    lastProximityDistance.remove(key)
+    lastImpressionEventSent.remove(key)
+    lastCampaignFetchAttempt.remove(key)
+    fetchInProgress.remove(key)
+    proximityEventInProgress.remove(key)
+    impressionEventInProgress.remove(key)
+    Log.d(TAG, "Cleaned up state for beacon $key")
+  }
+
+  private fun cleanupAllState() {
+    // Stagger exit events to avoid firing N simultaneous network requests
+    val keys = activeCampaigns.keys.toList()
+    keys.forEachIndexed { index, key ->
+      android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+        cleanupBeacon(key)
+      }, index * 300L)
+    }
+  }
+
+  // ── Backend API ───────────────────────────────────────────────────────────
+
+  private fun isTokenExpired(): Boolean {
+    if (sdkToken == null) return true
+    val expiry = sdkTokenExpiry ?: return false  // no expiry field = treat as valid
+    return System.currentTimeMillis() >= expiry
+  }
+
+  private fun persistJWT() {
+    val prefs = reactContext.getSharedPreferences("SpotnySDK", Context.MODE_PRIVATE).edit()
+    sdkToken?.let       { prefs.putString("jwt",           it) }
+    sdkCredential?.let  { prefs.putString("sdkCredential", it) }
+    apiKey?.let         { prefs.putString("sdkApiKey",     it) }
+    userId?.let         { prefs.putString("sdkUserId",     it) }
+    sdkTokenExpiry?.let { prefs.putLong("jwtExpiry",      it) }
+    prefs.apply()
+  }
+
+  /** Synchronous JWT refresh — safe to call from ioExecutor thread. */
+  private fun refreshJWTBlocking(): Boolean {
+    val credential = sdkCredential ?: return false
+    val key        = apiKey        ?: return false
+    return try {
+      val conn = (URL("$backendURL/api/app/sdk/verify").openConnection() as HttpURLConnection).apply {
+        requestMethod = "POST"
+        setRequestProperty("Content-Type", "application/json")
+        connectTimeout = 10_000
+        readTimeout    = 10_000
+        doOutput = true
+      }
+      conn.outputStream.use { it.write(buildJsonString(mapOf("token" to credential, "api_key" to key, "user_id" to (userId ?: ""))).toByteArray()) }
+      val status   = conn.responseCode
+      val response = try { conn.inputStream.bufferedReader().readText() }
+                     catch (_: Exception) { conn.errorStream?.bufferedReader()?.readText() ?: "" }
+      conn.disconnect()
+      if (status in 200..299) {
+        val data = (parseJsonObject(response)?.get("data") as? Map<*, *>)
+        val jwt  = (data?.get("jwt") as? String)?.takeIf { it.isNotBlank() }
+        if (jwt != null) {
+          sdkToken = jwt
+          val expiresAt = (data?.get("expires_at") as? Number)?.toLong()
+          if (expiresAt != null) sdkTokenExpiry = expiresAt * 1000L
+          persistJWT()
+          Log.d(TAG, "JWT refreshed, expires: ${sdkTokenExpiry?.let { java.util.Date(it) } ?: "no expiry"}")
+          true
+        } else false
+      } else false
+    } catch (e: Exception) {
+      Log.e(TAG, "JWT refresh error: ${e.message}")
+      false
+    }
+  }
+
+  private fun post(
+    endpoint: String,
+    payload: Map<String, Any?>,
+    completion: (Int, String) -> Unit
+  ) {
+    ioExecutor.execute {
+      // Auto-refresh JWT before every call except verify itself
+      if (endpoint != "/api/app/sdk/verify" && isTokenExpired()) {
+        if (!refreshJWTBlocking()) {
+          reactContext.runOnUiQueueThread { completion(-1, "") }
+          return@execute
+        }
+      }
+      try {
+        val conn = (URL("$backendURL$endpoint").openConnection() as HttpURLConnection).apply {
+          requestMethod = "POST"
+          setRequestProperty("Content-Type", "application/json")
+          sdkToken?.let { setRequestProperty("Authorization", "Bearer $it") }
+          connectTimeout = 10_000
+          readTimeout    = 10_000
+          doOutput = true
+        }
+        val body = buildJsonString(payload)
+        conn.outputStream.use { it.write(body.toByteArray()) }
+        val status = conn.responseCode
+        val response = try { conn.inputStream.bufferedReader().readText() }
+                       catch (_: Exception) { conn.errorStream?.bufferedReader()?.readText() ?: "" }
+        conn.disconnect()
+        reactContext.runOnUiQueueThread { completion(status, response) }
+      } catch (e: Exception) {
+        Log.e(TAG, "POST $endpoint error: ${e.message}")
+        reactContext.runOnUiQueueThread { completion(-1, "") }
+      }
+    }
+  }
+
+  /** Minimal JSON serialiser (avoids adding a full JSON library dependency). */
+  private fun buildJsonString(map: Map<String, Any?>): String {
+    val sb = StringBuilder("{")
+    map.entries.forEachIndexed { i, (k, v) ->
+      if (i > 0) sb.append(",")
+      sb.append("\"$k\":")
+      when (v) {
+        null          -> sb.append("null")
+        is String     -> sb.append("\"${v.replace("\"", "\\\"")}\"")
+        is Boolean    -> sb.append(v)
+        is Number     -> sb.append(v)
+        else          -> sb.append("\"$v\"")
+      }
+    }
+    sb.append("}")
+    return sb.toString()
+  }
+
+  // ── Campaign fetching ─────────────────────────────────────────────────────
+
+  private fun fetchCampaign(major: Int, minor: Int) {
+    val key = beaconKey(major, minor)
+    if (activeCampaigns.containsKey(key)) return
+    if (fetchInProgress[key] == true) return
+
+    val last = lastCampaignFetchAttempt[key]
+    if (last != null && System.currentTimeMillis() - last < campaignFetchCooldown) return
+
+    lastCampaignFetchAttempt[key] = System.currentTimeMillis()
+    fetchInProgress[key] = true
+
+    val payload = mutableMapOf<String, Any?>("beacon_id" to key)
+
+    post("/api/app/campaigns/beacon", payload) { status, body ->
+      fetchInProgress[key] = false
+      if (status != 200) {
+        Log.w(TAG, "Campaign fetch status $status for beacon $key")
+        return@post
+      }
+      try {
+        val json    = parseJsonObject(body) ?: return@post
+        val dataObj = json["data"]   as? Map<*, *> ?: return@post
+        val screen  = dataObj["screen"] as? Map<*, *> ?: return@post
+        val screenId = (screen["id"] as? Number)?.toInt() ?: return@post
+
+        var campaignId: Int? = null
+        var inQueue = false
+        val campaignObj = dataObj["campaign"] as? Map<*, *>
+        if (campaignObj != null) {
+          campaignId = (campaignObj["id"] as? Number)?.toInt()
+          inQueue    = campaignObj["inQueue"] as? Boolean ?: false
+        }
+
+        activeCampaigns[key] = CampaignData(
+          campaignId = campaignId, screenId = screenId,
+          sessionId = null, inQueue = inQueue, major = major, minor = minor)
+        Log.d(TAG, "Campaign loaded for beacon $key — screenId=$screenId")
+      } catch (e: Exception) {
+        Log.e(TAG, "Campaign JSON parse error for $key: ${e.message}")
+      }
+    }
+  }
+
+  // ── Tracking events ───────────────────────────────────────────────────────
+
+  private fun sendTracking(
+    eventType: String,
+    key: String,
+    distance: Double,
+    endpoint: String
+  ) {
+    val isImpression = eventType == "IMPRESSION_HEARTBEAT"
+    if (isImpression && impressionEventInProgress[key] == true) return
+    if (!isImpression && proximityEventInProgress[key] == true) return
+
+    if (isImpression) impressionEventInProgress[key] = true
+    else              proximityEventInProgress[key]  = true
+
+    val campaign = activeCampaigns[key]
+    if (campaign == null) {
+      if (isImpression) impressionEventInProgress[key] = false
+      else              proximityEventInProgress[key]  = false
+      return
+    }
+    if (isImpression && (campaign.campaignId == null || campaign.inQueue)) {
+      impressionEventInProgress[key] = false; return
+    }
+
+    val payload = mutableMapOf<String, Any?>(
+      "event_type" to eventType,
+      "distance"   to distance,
+      "screen_id"  to campaign.screenId
+    )
+    campaign.campaignId?.let { payload["campaign_id"] = it }
+    campaign.sessionId?.let  { payload["session_id"]  = it }
+
+    post(endpoint, payload) { status, body ->
+      if (status in 200..299) {
+        Log.d(TAG, "$eventType sent — distance ${"%.2f".format(distance)}m")
+        if (!isImpression && campaign.sessionId == null) {
+          try {
+            val json = parseJsonObject(body)
+            val sid  = ((json?.get("data") as? Map<*, *>)
+                          ?.get("event") as? Map<*, *>)
+                          ?.get("session_id") as? String
+            if (sid != null) {
+              activeCampaigns[key] = campaign.copy(sessionId = sid)
+              Log.d(TAG, "session_id = $sid")
+            }
+          } catch (_: Exception) {}
+        }
+      } else if (status == 429) {
+        val penalty = System.currentTimeMillis() + 10_000L
+        if (isImpression) lastImpressionEventSent[key] = penalty
+        else              lastProximityEventSent[key]  = penalty
+        Log.w(TAG, "$eventType rate-limited (429)")
+      } else {
+        Log.w(TAG, "$eventType failed — status $status")
+      }
+      if (isImpression) impressionEventInProgress[key] = false
+      else              proximityEventInProgress[key]  = false
+    }
+  }
+
+  private fun sendProximity(eventType: String, key: String, distance: Double) =
+    sendTracking(eventType, key, distance, "/api/app/impressions/proximity")
+
+  private fun sendImpression(key: String, distance: Double) =
+    sendTracking("IMPRESSION_HEARTBEAT", key, distance, "/api/app/impressions/track")
+
+  // ── Minimal JSON parser (avoids org.json / GSON dependency) ──────────────
+  // Only handles flat and one-level-deep objects. For this SDK, that is enough.
+
+  @Suppress("UNCHECKED_CAST")
+  private fun parseJsonObject(json: String): Map<String, Any?>? {
+    return try {
+      org.json.JSONObject(json).toMap()
+    } catch (_: Exception) { null }
+  }
+
+  private fun org.json.JSONObject.toMap(): Map<String, Any?> {
+    val map = mutableMapOf<String, Any?>()
+    keys().forEach { key ->
+      map[key] = when (val v = get(key)) {
+        is org.json.JSONObject -> v.toMap()
+        is org.json.JSONArray  -> v.toList()
+        org.json.JSONObject.NULL -> null
+        else -> v
+      }
+    }
+    return map
+  }
+
+  private fun org.json.JSONArray.toList(): List<Any?> {
+    return (0 until length()).map { i ->
+      when (val v = get(i)) {
+        is org.json.JSONObject -> v.toMap()
+        is org.json.JSONArray  -> v.toList()
+        org.json.JSONObject.NULL -> null
+        else -> v
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = NativeSpotnySdkSpec.NAME
+  }
+}
+