spotny-sdk 0.2.0

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

@@ -0,0 +1,565 @@
+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 ─────────────────────────────────────────────────────────
+  private var currentUserUUID: String? = null
+  private var userId: Int?             = null
+  @Volatile private var scanning       = false
+
+  // ── Configuration ─────────────────────────────────────────────────────────
+  private var backendURL            = "https://api.spotny.app"
+  private var maxDetectionDistance  = 8.0  // metres
+
+  // ── 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)
+    val stored = prefs.getString("userUUID", null) ?: return
+    currentUserUUID = stored
+    val uid = prefs.getInt("userId", -1).takeIf { it != -1 }
+    userId = uid
+    Log.d(TAG, "Resuming session for UUID: $stored")
+    startBeaconScanning()
+    scanning = true
+  }
+
+  // ── Turbo Module methods ──────────────────────────────────────────────────
+
+  override fun startScanner(userUUID: String, userId: Double?, promise: Promise) {
+    if (scanning) { promise.resolve("Already scanning"); return }
+
+    currentUserUUID = userUUID
+    this.userId = userId?.toInt()
+
+    val prefs = reactContext.getSharedPreferences("SpotnySDK", Context.MODE_PRIVATE).edit()
+    prefs.putString("userUUID", userUUID)
+    this.userId?.let { prefs.putInt("userId", it) } ?: prefs.remove("userId")
+    prefs.apply()
+
+    startBeaconScanning()
+    scanning = true
+    Log.d(TAG, "Started scanning for $userUUID")
+    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("userUUID"); prefs.remove("userId"); prefs.apply()
+
+    scanning = false; currentUserUUID = null; userId = null
+    Log.d(TAG, "Stopped scanning")
+    promise.resolve("Scanning stopped")
+  }
+
+  override fun isScanning(promise: Promise) = promise.resolve(scanning)
+
+  override fun configure(config: ReadableMap?, promise: Promise) {
+    config?.getString("backendURL")?.let { backendURL = it; Log.d(TAG, "backendURL = $it") }
+    config?.getDouble("maxDetectionDistance").takeIf { config?.hasKey("maxDetectionDistance") == true }
+      ?.let { maxDetectionDistance = it; Log.d(TAG, "maxDetectionDistance = $it m") }
+    promise.resolve("Configuration updated")
+  }
+
+  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 deviceId = getDeviceId()
+    val now = System.currentTimeMillis()
+
+    // JS event payload
+    val jsBeacons = WritableNativeArray()
+    for (beacon in beacons) {
+      val raw = beacon.distance
+      val adjusted = raw * 0.5
+      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 * 0.5
+
+      if (distance <= 0 || distance > maxDetectionDistance) continue
+
+      if (activeCampaigns.containsKey(key)) {
+        val isFirst = !lastProximityEventSent.containsKey(key)
+        if (isFirst) {
+          sendProximity("NEARBY", key, distance, deviceId)
+          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, deviceId)
+            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, deviceId)
+            lastImpressionEventSent[key] = now
+          }
+        }
+      } else {
+        fetchCampaign(major, minor, deviceId)
+      }
+    }
+  }
+
+  // ── 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)
+      val deviceId = getDeviceId()
+      for (key in activeCampaigns.keys.toList()) {
+        cleanupBeacon(key, deviceId)
+      }
+      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, deviceId: String) {
+    sendProximity("PROXIMITY_EXIT", key, 0.0, deviceId)
+    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() {
+    val deviceId = getDeviceId()
+    activeCampaigns.keys.toList().forEach { cleanupBeacon(it, deviceId) }
+  }
+
+  // ── Backend API ───────────────────────────────────────────────────────────
+
+  private fun post(
+    endpoint: String,
+    payload: Map<String, Any?>,
+    completion: (Int, String) -> Unit
+  ) {
+    ioExecutor.execute {
+      try {
+        val conn = (URL("$backendURL$endpoint").openConnection() as HttpURLConnection).apply {
+          requestMethod = "POST"
+          setRequestProperty("Content-Type", "application/json")
+          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, deviceId: String) {
+    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, "device_id" to deviceId)
+    userId?.let { payload["user_id"] = it }
+
+    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,
+    deviceId: String,
+    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,
+      "device_id"  to deviceId,
+      "distance"   to distance,
+      "screen_id"  to campaign.screenId
+    )
+    campaign.campaignId?.let { payload["campaign_id"] = it }
+    campaign.sessionId?.let  { payload["session_id"]  = it }
+    userId?.let              { payload["user_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, deviceId: String) =
+    sendTracking(eventType, key, distance, deviceId, "/api/app/impressions/proximity")
+
+  private fun sendImpression(key: String, distance: Double, deviceId: String) =
+    sendTracking("IMPRESSION_HEARTBEAT", key, distance, deviceId, "/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
+  }
+}
+

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

@@ -0,0 +1,31 @@
+package com.spotnysdk
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class SpotnySdkPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == SpotnySdkModule.NAME) {
+      SpotnySdkModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      SpotnySdkModule.NAME to ReactModuleInfo(
+        name = SpotnySdkModule.NAME,
+        className = SpotnySdkModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+    )
+  }
+}