@goliapkg/sentori-react-native 6.1.0 → 6.2.1

package/android/src/main/java-core/com/sentori/SentoriPush.kt

@@ -0,0 +1,359 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriPush.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import android.app.Activity
+import android.content.Context
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+import org.json.JSONObject
+
+/**
+ * Push, as an app writes it.
+ *
+ *     Sentori.push.register(activity) { result ->
+ *         if (result is SentoriPush.Result.Failure) { … }
+ *     }
+ *
+ * The pieces underneath already existed — the POST_NOTIFICATIONS
+ * prompt, the FCM service, the token and tap buffers — and were
+ * reachable only through the React Native bridge. What was missing
+ * everywhere but JavaScript is the part that puts a token on the
+ * server, which is the only reason a registered device is reachable
+ * at all.
+ *
+ * Asked for by insight (2026-08-11): two apps with no React Native,
+ * blocked, and unwilling to reimplement the HTTP contract because a
+ * second implementation drifts silently on the one path nobody
+ * watches.
+ *
+ * Callback-based rather than suspending, so this is usable from Java
+ * and from a codebase that has not adopted coroutines. The callback
+ * runs on a background thread; touch UI from it at your own risk.
+ */
+object SentoriPush {
+
+    /**
+     * Why a registration did not produce a device handle. Same five
+     * names as `PushRegisterFailure` in the React Native SDK and the
+     * Swift one, so a single set of integration notes covers all
+     * three and an operator reading a support thread does not have to
+     * translate.
+     */
+    enum class Failure(val reason: String) {
+        /** [Sentori.start] has not run. A wiring bug. */
+        NOT_INITIALISED("not-initialised"),
+        /**
+         * The user said no. Not an error: do not retry on a timer,
+         * and offer it again from a settings screen.
+         */
+        PERMISSION_DENIED("permission-denied"),
+        /**
+         * No Firebase in this build, or no `google-services.json`.
+         * Nothing to do at runtime.
+         */
+        NO_TRANSPORT("no-transport"),
+        /**
+         * FCM never handed back a token inside the window. Retrying
+         * later is reasonable.
+         */
+        TOKEN_TIMEOUT("token-timeout"),
+        /** Sentori answered non-2xx. Settings ▸ Push is where to look. */
+        SERVER_REJECTED("server-rejected"),
+    }
+
+    /**
+     * Registration never throws. A denied permission is an ordinary
+     * answer, and an opt-in that throws inside someone's ViewModel is
+     * the failure this SDK's contract with its host is written
+     * against.
+     */
+    sealed class Result {
+        /**
+         * The `device_tokens` row id. Revoking takes it, and so does a
+         * targeted send.
+         */
+        data class Success(val handle: String) : Result()
+
+        data class Failure(val reason: SentoriPush.Failure, val message: String) : Result()
+    }
+
+    private val lock = Any()
+    private var cachedHandle: String? = null
+    private var onMessage: ((Map<String, Any?>) -> Unit)? = null
+    private var onTap: ((Map<String, Any?>) -> Unit)? = null
+    private var drainTask: ScheduledFuture<*>? = null
+
+    private const val PREFS = "com.sentori.push"
+    private const val HANDLE_KEY = "handle"
+
+    private val worker =
+        Executors.newSingleThreadScheduledExecutor { r ->
+            Thread(r, "sentori-push").apply { isDaemon = true }
+        }
+
+    /**
+     * Ask for permission, get a token, register it.
+     *
+     * Safe to call on every launch: Android returns its cached
+     * decision without re-prompting, and the server upserts on
+     * `(project, provider, token)`.
+     *
+     * Call [Sentori.user] first if the device should be reachable from
+     * an issue. Without it the registration carries no user key and
+     * the device receives broadcasts only — the dashboard shows that
+     * as "N devices, 0 addressable", which is the one symptom with no
+     * other explanation.
+     *
+     * [activity] is needed only for the Android 13+ runtime prompt;
+     * pass null to skip prompting and use whatever was already
+     * granted.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun register(
+        context: Context,
+        activity: Activity? = null,
+        timeoutMs: Long = 8_000,
+        onMessage: ((Map<String, Any?>) -> Unit)? = null,
+        onTap: ((Map<String, Any?>) -> Unit)? = null,
+        completion: (Result) -> Unit,
+    ) {
+        val config = SentoriConfig.current
+        if (config == null) {
+            completion(Result.Failure(Failure.NOT_INITIALISED, "Sentori.start has not run"))
+            return
+        }
+
+        // Bind before asking for anything: a tap that arrived while
+        // the app was dead is replayed as soon as the service starts,
+        // and a callback set afterwards misses it.
+        synchronized(lock) {
+            this.onMessage = onMessage
+            this.onTap = onTap
+        }
+
+        val appContext = context.applicationContext
+        val proceed = { status: String ->
+            worker.execute {
+                completion(finishRegister(appContext, config, status, timeoutMs))
+            }
+        }
+
+        val current = SentoriPushNotifications.currentPermission(appContext)
+        if (current == "notDetermined" && activity != null) {
+            SentoriPushNotifications.requestPermission(activity) { proceed(it) }
+        } else {
+            proceed(current)
+        }
+    }
+
+    private fun finishRegister(
+        context: Context,
+        config: SentoriConfig,
+        status: String,
+        timeoutMs: Long,
+    ): Result {
+        if (status != "granted") {
+            return Result.Failure(Failure.PERMISSION_DENIED, "push permission '$status'")
+        }
+
+        SentoriPushNotifications.registerForRemoteNotifications(context)
+
+        val token = waitForToken(timeoutMs)
+        if (token == null) {
+            // An FCM that is not on the classpath reports an error
+            // rather than a token, and that is a build fact rather
+            // than something the user chose.
+            val err = SentoriPushNotifications.drainState()["error"] as? String
+            return if (err != null) {
+                Result.Failure(Failure.NO_TRANSPORT, err)
+            } else {
+                Result.Failure(Failure.TOKEN_TIMEOUT, "no device token within ${timeoutMs}ms")
+            }
+        }
+
+        return when (val r = registerWithServer(token, config)) {
+            is Result.Success -> {
+                synchronized(lock) { cachedHandle = r.handle }
+                context
+                    .getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+                    .edit()
+                    .putString(HANDLE_KEY, r.handle)
+                    .apply()
+                startDrain()
+                r
+            }
+            else -> r
+        }
+    }
+
+    /** The handle from an earlier [register], without a round trip. */
+    @JvmStatic
+    fun cachedDeviceHandle(context: Context): String? =
+        synchronized(lock) { cachedHandle }
+            ?: context
+                .getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+                .getString(HANDLE_KEY, null)
+
+    /** Current permission without prompting. */
+    @JvmStatic
+    fun permissionStatus(context: Context): String =
+        SentoriPushNotifications.currentPermission(context.applicationContext)
+
+    /**
+     * Revoke the handle server-side and stop local delivery.
+     * Idempotent — repeat calls do nothing.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun unregister(context: Context, completion: ((Boolean) -> Unit)? = null) {
+        val appContext = context.applicationContext
+        val handle = cachedDeviceHandle(appContext)
+        synchronized(lock) {
+            cachedHandle = null
+            onMessage = null
+            onTap = null
+            drainTask?.cancel(false)
+            drainTask = null
+        }
+        appContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().remove(HANDLE_KEY).apply()
+        SentoriPushNotifications.unregisterForRemoteNotifications(appContext)
+
+        val config = SentoriConfig.current
+        if (handle == null || config == null) {
+            completion?.invoke(false)
+            return
+        }
+        worker.execute {
+            var conn: HttpURLConnection? = null
+            val ok =
+                try {
+                    conn =
+                        URL("${config.ingestUrl}/v1/push/tokens/$handle").openConnection()
+                            as HttpURLConnection
+                    conn.requestMethod = "DELETE"
+                    conn.setRequestProperty("Authorization", "Bearer ${config.token}")
+                    conn.connectTimeout = 15_000
+                    conn.readTimeout = 15_000
+                    conn.responseCode in 200..299
+                } catch (_: Throwable) {
+                    false
+                } finally {
+                    conn?.disconnect()
+                }
+            completion?.invoke(ok)
+        }
+    }
+
+    // ── internals ─────────────────────────────────────────────────
+
+    private fun waitForToken(timeoutMs: Long): String? {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        while (System.currentTimeMillis() < deadline) {
+            val state = SentoriPushNotifications.drainState()
+            flush(state)
+            (state["token"] as? String)?.let { return it }
+            if (state["error"] != null) return null
+            try {
+                Thread.sleep(200)
+            } catch (_: InterruptedException) {
+                Thread.currentThread().interrupt()
+                return null
+            }
+        }
+        return null
+    }
+
+    private fun registerWithServer(token: String, config: SentoriConfig): Result {
+        val body =
+            mutableMapOf<String, Any?>(
+                // `kind`, not `provider`. The React Native SDK sent
+                // `provider` for a year and earned a 422 for every
+                // registration it ever attempted.
+                "kind" to "fcm",
+                "nativeToken" to token,
+                // No `env`: FCM is one host, with no sandbox and
+                // production split for a token to be wrong about.
+            )
+        // The same identity hash every event carries, so the dashboard
+        // can address this device by the person who hit an issue.
+        // Absent until the host calls `Sentori.user`.
+        SentoriScope.userKey?.let { body["userKey"] = it }
+
+        var conn: HttpURLConnection? = null
+        return try {
+            conn =
+                URL("${config.ingestUrl}/v1/push/tokens").openConnection() as HttpURLConnection
+            conn.requestMethod = "POST"
+            conn.setRequestProperty("Content-Type", "application/json")
+            conn.setRequestProperty("Authorization", "Bearer ${config.token}")
+            conn.setRequestProperty("Sentori-Sdk", "kotlin/${SentoriVersion.CURRENT}")
+            conn.connectTimeout = 15_000
+            conn.readTimeout = 15_000
+            conn.doOutput = true
+            conn.outputStream.use {
+                it.write(SentoriTransport.toJson(body).toString().toByteArray(Charsets.UTF_8))
+            }
+
+            val code = conn.responseCode
+            if (code !in 200..299) {
+                Result.Failure(Failure.SERVER_REJECTED, "HTTP $code")
+            } else {
+                val text = conn.inputStream.bufferedReader().readText()
+                // The handle is the `device_tokens` row id, a bare
+                // uuid. The RN SDK parsed it as an `ipt_*` string no
+                // server has ever returned.
+                val handle = JSONObject(text).optString("token_id")
+                if (handle.isNullOrEmpty()) {
+                    Result.Failure(Failure.SERVER_REJECTED, "server returned no device token id")
+                } else {
+                    Result.Success(handle)
+                }
+            }
+        } catch (e: Throwable) {
+            Result.Failure(Failure.SERVER_REJECTED, e.message ?: e.javaClass.name)
+        } finally {
+            conn?.disconnect()
+        }
+    }
+
+    /**
+     * 1 Hz while registered. The FCM service buffers arrivals and
+     * taps; this hands them to the host.
+     */
+    private fun startDrain() {
+        synchronized(lock) {
+            if (drainTask != null) return
+            drainTask =
+                worker.scheduleWithFixedDelay(
+                    { flush(SentoriPushNotifications.drainState()) },
+                    1,
+                    1,
+                    TimeUnit.SECONDS,
+                )
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun flush(state: Map<String, Any?>) {
+        val (message, tap) = synchronized(lock) { onMessage to onTap }
+        if (message == null && tap == null) return
+        (state["notifications"] as? List<Map<String, Any?>>)?.forEach { message?.invoke(it) }
+        (state["taps"] as? List<Map<String, Any?>>)?.forEach { tap?.invoke(it) }
+    }
+
+    internal fun resetForTests() {
+        synchronized(lock) {
+            cachedHandle = null
+            onMessage = null
+            onTap = null
+            drainTask?.cancel(false)
+            drainTask = null
+        }
+    }
+}

package/android/src/main/{java → java-core}/com/sentori/SentoriPushNotifications.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriPushNotifications.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 // v2.10 — Android push notification bridge.
 //
 // Mirrors the iOS shape:

package/android/src/main/{java → java-core}/com/sentori/SentoriReplayCapture.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriReplayCapture.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 import android.app.Activity

package/android/src/main/java-core/com/sentori/SentoriScope.kt

@@ -0,0 +1,60 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriScope.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+/**
+ * Ambient scope: the current user and the context patch that ride
+ * every outgoing event. Two verbs own this state; everything else
+ * reads it.
+ */
+object SentoriScope {
+
+    private val lock = Any()
+    private var _userKey: String? = null
+    private val _context = mutableMapOf<String, Any?>()
+
+    /**
+     * Identify the person using the app. Only the hash goes on the
+     * wire; the id and email stay on the device.
+     *
+     * Unlike the JavaScript version this is genuinely synchronous —
+     * WebCrypto's digest is a promise, so `scope.ts` sets the key a
+     * tick later and events sent in that gap carry none.
+     * `MessageDigest` has no such gap, so the first event after this
+     * call is already addressable.
+     *
+     * Pass null for both to forget the user on sign-out.
+     */
+    @JvmStatic
+    fun setUser(id: String?, email: String?) {
+        val key = SentoriIdentity.userKey(id, email)
+        synchronized(lock) { _userKey = key }
+    }
+
+    /** Merge keys into the ambient context. Later calls win per key. */
+    @JvmStatic
+    fun patchContext(patch: Map<String, Any?>) {
+        synchronized(lock) { _context.putAll(patch) }
+    }
+
+    @JvmStatic
+    val userKey: String?
+        get() = synchronized(lock) { _userKey }
+
+    /**
+     * Null rather than an empty map, so an event with no context omits
+     * the field instead of carrying `{}`.
+     */
+    @JvmStatic
+    val context: Map<String, Any?>?
+        get() = synchronized(lock) { if (_context.isEmpty()) null else _context.toMap() }
+
+    @JvmStatic
+    fun clear() {
+        synchronized(lock) {
+            _userKey = null
+            _context.clear()
+        }
+    }
+}

package/android/src/main/{java → java-core}/com/sentori/SentoriScreenshotCapture.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriScreenshotCapture.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 import android.app.Application

package/android/src/main/java-core/com/sentori/SentoriSignalRing.kt

@@ -0,0 +1,80 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriSignalRing.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import kotlin.math.roundToLong
+
+/**
+ * What the user was doing for the last sixty seconds, shipped inside
+ * `payload.signals` when an error or warn goes out.
+ *
+ * Bounded and overwrite-oldest. [push] is on the hot path — a tap
+ * handler, a navigation — so it does one append and at most one
+ * removal under a lock, and nothing else.
+ *
+ * The window matches the replay buffer deliberately: at 30 s of
+ * signals against 60 s of replay, the left half of a case timeline had
+ * frames and no events, which reads as "nothing happened" rather than
+ * "we were not looking" (insight, round 4).
+ */
+object SentoriSignalRing {
+
+    private data class Entry(val at: Long, val kind: String, val data: Map<String, Any?>?)
+
+    private const val DEFAULT_CAPACITY = 100
+    private const val DEFAULT_WINDOW_MS = 60_000L
+
+    private val lock = Any()
+    private val entries = ArrayDeque<Entry>()
+    private var capacity = DEFAULT_CAPACITY
+    private var windowMs = DEFAULT_WINDOW_MS
+
+    @JvmStatic
+    fun configure(capacity: Int, windowMs: Long) {
+        synchronized(lock) {
+            if (capacity > 0) this.capacity = capacity
+            if (windowMs > 0) this.windowMs = windowMs
+        }
+    }
+
+    /**
+     * Record one signal. Any [kind] is accepted — the server does not
+     * enumerate them, so a host can push its own without waiting for
+     * an SDK release. The five event kinds are a different list and
+     * are validated.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun push(kind: String, data: Map<String, Any?>? = null) {
+        synchronized(lock) {
+            entries.addLast(Entry(System.currentTimeMillis(), kind, data))
+            while (entries.size > capacity) entries.removeFirst()
+        }
+    }
+
+    /**
+     * The ring relative to [now], windowed, oldest first — the shape
+     * `payload.signals` carries. `t` is seconds before now, negative,
+     * to one decimal.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun snapshot(now: Long = System.currentTimeMillis()): List<Map<String, Any?>> {
+        val (all, window) = synchronized(lock) { entries.toList() to windowMs }
+        val cutoff = now - window
+        return all.filter { it.at >= cutoff }.map { e ->
+            val out = mutableMapOf<String, Any?>(
+                "t" to ((e.at - now) / 100.0).roundToLong() / 10.0,
+                "kind" to e.kind,
+            )
+            if (e.data != null) out["data"] = e.data
+            out
+        }
+    }
+
+    @JvmStatic
+    fun clear() {
+        synchronized(lock) { entries.clear() }
+    }
+}