@goliapkg/sentori-react-native 6.2.0 → 6.3.0

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:
@@ -47,6 +50,10 @@ object SentoriPushNotifications {
 
     private var pendingPermissionCallback: ((String) -> Unit)? = null
 
+    private val watcher = java.util.concurrent.Executors.newSingleThreadExecutor { r ->
+        Thread(r, "sentori-push-permission").apply { isDaemon = true }
+    }
+
     // ── status / permission ─────────────────────────────────────
 
     /** Returns `granted` / `denied` / `notDetermined` without
@@ -79,7 +86,12 @@ object SentoriPushNotifications {
      * Callbacks run on the main thread.
      */
     @JvmStatic
-    fun requestPermission(activity: Activity?, completion: (String) -> Unit) {
+    @JvmOverloads
+    fun requestPermission(
+        activity: Activity?,
+        timeoutMs: Long = 60_000,
+        completion: (String) -> Unit,
+    ) {
         val ctx = activity ?: run {
             completion("error:no-activity")
             return
@@ -96,35 +108,89 @@ object SentoriPushNotifications {
             completion("granted")
             return
         }
-        pendingPermissionCallback = completion
+        synchronized(lock) { pendingPermissionCallback = completion }
         ActivityCompat.requestPermissions(
             ctx,
             arrayOf(Manifest.permission.POST_NOTIFICATIONS),
             PERMISSION_REQUEST_CODE,
         )
+        watchForPermission(ctx.applicationContext, timeoutMs)
     }
 
     /**
-     * Hook for the host Activity's `onRequestPermissionsResult`. Not
-     * mandatory — Android dispatches the result back to the same
-     * Activity that requested it, but ActivityCompat's flow doesn't
-     * give us a callback API on older devices. Hosts that want
-     * deterministic delivery can call this from their override.
+     * Fast path for hosts that forward `onRequestPermissionsResult`.
+     *
+     * It used to be the *only* path, and the comment here said the
+     * callback might not fire because "the JS drain loop will still
+     * pick up the granted state next tick". That is true of React
+     * Native and of nothing else. A native host calls `register` and
+     * never hears of this method, so the callback was never invoked,
+     * `finishRegister` never ran, and a first launch registered
+     * nothing at all — silently, with the user having tapped Allow.
+     * The next launch worked, because by then the permission was
+     * already granted and the flow never suspended. New users simply
+     * did not get push until they happened to reopen the app.
      *
-     * The Activity-based ActivityResultLauncher pattern would be
-     * cleaner but requires the Activity to be a ComponentActivity;
-     * we stick with ActivityCompat for broader RN host compat and
-     * accept that the callback may not fire on every device — the
-     * JS drain loop will still pick up the `granted` state next tick.
+     * Nothing needs to call this now. It stays because forwarding the
+     * result resolves in milliseconds instead of on the next poll,
+     * and because hosts that already call it should keep working.
      */
     @JvmStatic
     fun handlePermissionResult(requestCode: Int, grantResults: IntArray) {
         if (requestCode != PERMISSION_REQUEST_CODE) return
-        val cb = pendingPermissionCallback ?: return
-        pendingPermissionCallback = null
         val granted = grantResults.isNotEmpty() &&
             grantResults[0] == PackageManager.PERMISSION_GRANTED
-        cb(if (granted) "granted" else "denied")
+        settlePermission(if (granted) "granted" else "denied")
+    }
+
+    /** Deliver a pending permission outcome exactly once. */
+    private fun settlePermission(status: String) {
+        val cb = synchronized(lock) {
+            pendingPermissionCallback.also { pendingPermissionCallback = null }
+        } ?: return
+        cb(status)
+    }
+
+    /**
+     * Watch the permission the framework actually holds, and settle
+     * when it changes.
+     *
+     * `checkSelfPermission` flips the moment the user answers the
+     * dialog, whether or not anyone forwarded the result — so this
+     * needs no cooperation from the host, works on any Activity
+     * rather than only a `ComponentActivity`, and cannot be defeated
+     * by a host that does not know the hook exists.
+     *
+     * On a background thread, because the caller's thread is never
+     * ours to block. If the user never answers, this settles as
+     * `notDetermined` at the deadline rather than hanging: a
+     * registration that reports nothing is the failure this whole
+     * change is about.
+     */
+    private fun watchForPermission(ctx: Context, timeoutMs: Long) {
+        watcher.execute {
+            val deadline = System.currentTimeMillis() + timeoutMs
+            while (System.currentTimeMillis() < deadline) {
+                if (synchronized(lock) { pendingPermissionCallback } == null) return@execute
+                if (ContextCompat.checkSelfPermission(
+                        ctx,
+                        Manifest.permission.POST_NOTIFICATIONS,
+                    ) == PackageManager.PERMISSION_GRANTED
+                ) {
+                    settlePermission("granted")
+                    return@execute
+                }
+                try {
+                    Thread.sleep(250)
+                } catch (_: InterruptedException) {
+                    return@execute
+                }
+            }
+            // Denied and never-answered are the same observation from
+            // here: the framework only tells them apart through an
+            // Activity that may be gone by now. Say what was seen.
+            settlePermission("notDetermined")
+        }
     }
 
     // ── register / unregister ───────────────────────────────────
@@ -227,8 +293,17 @@ object SentoriPushNotifications {
         }
     }
 
-    /** Called when the user taps a notification (host wires this in
-     *  Activity.onCreate to forward the intent extras). */
+    /**
+     * Record a tap.
+     *
+     * This used to be the only route to `register(onTap:)`, and its
+     * comment said the host wires it in `Activity.onCreate`. Nothing
+     * in the SDK called it and the docs never mentioned it, so a
+     * native host's `onTap` could not fire at all. `SentoriNotificationTap`
+     * now reaches this on its own, from a pending intent the SDK owns
+     * or from the intent an Activity was launched with; this stays
+     * public because a host that already forwards should keep working.
+     */
     @JvmStatic
     fun handleNotificationTap(extras: Map<String, Any?>) {
         synchronized(lock) {
@@ -280,6 +355,85 @@ object SentoriPushNotifications {
         mgr.createNotificationChannel(channel)
     }
 
+    /**
+     * Put a data message in the tray, with a pending intent of ours.
+     *
+     * Nothing here posted a notification before, which left both
+     * kinds of message broken in a different way. A `data` message
+     * reached `onMessage` and the user saw nothing — insight's device
+     * said "No notifications" while the callback had fired. A
+     * `notification` message was drawn by the system, which never
+     * calls this service, so the tap had no way home. Posting it here
+     * is what makes one path work end to end.
+     *
+     * Only messages that carry something to display are posted. A
+     * data message without a title or a body is a silent instruction
+     * to the app, and an app that uses those would not thank us for
+     * turning each one into a notification the user has to dismiss.
+     */
+    @JvmStatic
+    fun postNotification(ctx: Context, data: Map<String, String>) {
+        val title = data["title"]?.takeIf { it.isNotBlank() }
+        val body = data["body"]?.takeIf { it.isNotBlank() }
+        if (title == null && body == null) return
+        if (!NotificationManagerCompat.from(ctx).areNotificationsEnabled()) return
+
+        ensureChannel(ctx)
+        val id = (data["google.message_id"] ?: data["id"] ?: title ?: "").hashCode()
+        val builder = androidx.core.app.NotificationCompat.Builder(
+            ctx,
+            data["channelId"]?.takeIf { it.isNotBlank() } ?: DEFAULT_CHANNEL_ID,
+        )
+            .setSmallIcon(smallIcon(ctx))
+            .setAutoCancel(true)
+            .setPriority(androidx.core.app.NotificationCompat.PRIORITY_DEFAULT)
+        title?.let { builder.setContentTitle(it) }
+        body?.let { builder.setContentText(it) }
+        SentoriNotificationTap.pendingIntent(ctx, data, id)?.let { builder.setContentIntent(it) }
+
+        try {
+            NotificationManagerCompat.from(ctx).notify(id, builder.build())
+        } catch (t: Throwable) {
+            // Losing the tray entry is not worth taking the host down
+            // for — but losing it in silence is what made this cost
+            // insight an afternoon. The channel got created, so they
+            // knew the code had reached `notify`; the tray was empty,
+            // `dumpsys notification` had nothing, and logcat had not
+            // one word. They worked backwards from the channel's
+            // existence to a throw nobody had reported.
+            //
+            // The argument for this line is the same one made when
+            // registration failures started logging, one release
+            // earlier — and then this catch was written silent in the
+            // same release. A failure the host cannot see is the
+            // hardest kind there is.
+            android.util.Log.w("sentori", "push notification not shown: $t")
+        }
+    }
+
+    /**
+     * A small icon that will not throw.
+     *
+     * The host's own, because a push SDK that ships its own artwork
+     * puts a stranger's mark in someone else's tray. But
+     * `applicationInfo.icon` is `0` for an app that declares no
+     * `android:icon` — insight's did not, it drew its logo from a
+     * launch theme — and `notify` throws on an icon of 0 rather than
+     * drawing something ugly. The result was a notification that
+     * silently never appeared.
+     *
+     * A system icon in that case: unbranded and plain, but visible,
+     * and visible is the whole point of the tray.
+     */
+    private fun smallIcon(ctx: Context): Int {
+        val declared = try {
+            ctx.applicationInfo.icon
+        } catch (_: Throwable) {
+            0
+        }
+        return if (declared != 0) declared else android.R.drawable.ic_dialog_info
+    }
+
     private fun isFirebaseAvailable(): Boolean {
         return try {
             Class.forName("com.google.firebase.messaging.FirebaseMessaging")

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,107 @@
+// 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 var _traits: Map<String, Any?>? = null
+    private val _context = mutableMapOf<String, Any?>()
+
+    /**
+     * What to tell when the person changes.
+     *
+     * The push device row carries the identity, and nothing updated it
+     * after registration: an app that registers at launch and signs in
+     * ten seconds later — which is every app with a login screen —
+     * held a row with no user on it for the life of the install. A
+     * send aimed at that person reached nobody and said it had worked.
+     *
+     * A callback rather than a call into [SentoriPush], so this file
+     * keeps knowing nothing about push.
+     */
+    @Volatile private var onIdentityChange: (() -> Unit)? = null
+
+    /** Register interest in identity changes. Only push does. */
+    @JvmStatic
+    fun setIdentityListener(listener: (() -> Unit)?) {
+        onIdentityChange = listener
+    }
+
+    /**
+     * 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
+    @JvmOverloads
+    fun setUser(id: String?, email: String?, traits: Map<String, Any?>? = null) {
+        val key = SentoriIdentity.userKey(id, email)
+        synchronized(lock) {
+            _userKey = key
+            // A call describes the person completely, so one made
+            // without traits means they have none rather than "leave
+            // the last ones". Absent and empty differ on the wire —
+            // absent keeps what the row has, and a signed-out device
+            // that kept them would still be selectable as whoever
+            // just left.
+            _traits = traits?.toMap() ?: emptyMap()
+        }
+        // Outside the lock: a listener that registers a device must
+        // not be holding this while it makes a request.
+        runCatching { onIdentityChange?.invoke() }
+    }
+
+    /** 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 }
+
+    /**
+     * The person's attributes, for the push device row.
+     *
+     * Null until the host has called [setUser] at all, which is
+     * different from an empty map: null leaves the row's traits alone,
+     * empty clears them.
+     */
+    @JvmStatic
+    val traits: Map<String, Any?>?
+        get() = synchronized(lock) { _traits }
+
+    /**
+     * 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
+            _traits = null
+            _context.clear()
+        }
+        onIdentityChange = null
+    }
+}

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() }
+    }
+}